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。