C# 靜態成員與實例成員

靜態成員：在類的成員的類型或者返回值類型前面加上關鍵字static，就可以將該成員定義為靜態成員。常量或類型聲明會隱式地聲明為靜態成員，其他沒有用static修飾的成員都是實例成員。靜態成員屬於類，被這個類的所有實例所共享；實例成員屬於對象（類的實例），每一個對象都有實例成員的不同副本。 

下面看一下靜態成員和實例成員的特點：

靜態成員：1>靜態成員必須通過類名使用.運算符來引用，而不能用對象來引用。                     

        2>一個靜態字段只標識一個存儲位置。無論創建了一個類的多少個實例，它的靜態字段在內存中都只占

          用同一塊區域。

        3>靜態函數成員（方法，屬性，事件，運算符或構造函數）不能作用於具體的實例，在這類函數成員中

          不能直接使用實例成員，必須通過類名來引用。

實例成員：1>實例成員必須通過對象名使用.運算符來引用，而不能用類名來引用。

         2>類的實例字段屬於類的實例所有，每創建一個類的實例，都在內存中為實例字段開辟了一塊區域。

           類的每個實例分別包含一組該類的所有實例字段的副本。

         3>類的函數成員（方法，屬性，索引器，實例構造函數或析構函數）作用於類的給定的實例，在它們

           的代碼體內可以直接引用類的靜態和實例成員。

下面用具體的代碼來看它們的用法

/**//*
    要點：靜態成員屬於類，實例成員屬於對象（類的實例）
    靜態成員必須通過類名使用.運算符來引用，而不能用對象來引用
    實例成員必須通過對象名使用.運算符來引用，而不能通過類名來引用
*/
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication5
...{
    class Program
    ...{
        int x;                             //實例字段
        static int y;                      //靜態字段
        void F()                           //實例方法
        ...{
            x = 1;                         //正確，實例方法內可以直接引用實例字段
            y = 1;                         //正確，實例方法內可以直接引用靜態字段
        }
        static void G()                    //靜態方法
        ...{
       //   x = 1;                         //錯誤，靜態方法內不能直接引用實例字段
            y = 1;                         //正確，靜態方法內可以直接引用靜態字段
        }
        static void Main(string[] args)    //靜態方法
        ...{
            Program t = new Program();     //創建對象
            t.x = 1;                       //正確，用對象引用實例字段
       //   t.y = 1;                       //錯誤，不能用對象引用實例字段
       //   Program.x = 1;                 //錯誤，不能用類名引用實例字段
        Program.y = 1;                 //正確，用類目引用靜態字段
            t.F();                         //正確，用對象引用實例方法
       //   t.G();                         //錯誤，不能用對象名調用靜態方法
       //   Program.F();                   //錯誤，不能用類目調用實例方法
            Program.G();                   //正確，用類名調用靜態方法
        }
    }
}
 
在看下面的一個例子
 


/**//*
    靜態字段只標識一個存儲位置，無論創建了一個類的多少個實例，它的靜態字段在內存中都只占用一塊區域，而類的實例字段屬於類的實例所有，
    每創建一個類的實例，都在內存中為實例字段開辟了一塊區域。                          
*/
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication6
...{
    public class Count
    ...{
        static int count;
            int number;
        public Count()
        ...{
            count = count + 1;
            number = count;
        }
        public void show()
        ...{
            Console.WriteLine("Object{0} ： count={1}",number,count);
        }
    }
    class Test
    ...{
        static void Main(string[] args)
        ...{
            Count a = new Count();
            a.show();
            Console.WriteLine("-------------------");
                 Count b = new Count();
            a.show();
            b.show();
            Console.WriteLine("-------------------");
            Count c = new Count();
            a.show();
            b.show();
            c.show();
            Console.ReadLine();
        }
    }
}
 
該程序的輸出結果如下
                                        Object1 ： count=1            
                                        -------------------
                                        Object1 ： count=2
                                        Object2 ： count=2
                                        -------------------
                                        Object1 ： count=3
                                        Object2 ： count=3
                                        Object3 ： count=3

結果分析：實例化a時，number=1 count=1；實例化b時，number=2 count=2 但此時的number是新開辟的一個內存區域，不是實例化a時所開辟的區域，但是count在內存中還是原來的那塊區域，因此a.show()的結果為 Object1 ： count=2，b.show()的結果為Object2 ： count=2。
 >