C# 实例化的执行顺序(转)

首先进行细分
1.类的成员分为：字段，属性，方法，构造函数
2.成员修饰符：静态成员，实例成员
不考虑继承的关系执行顺序为：
1.静态字段
2.静态构造方法
3.实例字段
4.实例构造方法
其中属性和方法只有在调用的时候才执行。
下面是一段代码例子：

 class Test

        {

            public static int temp;

            public int mNum;

            public int mNum2 = ;

            public void Look()

            {

                Console.WriteLine("看我，我是test");

                Console.WriteLine("mNum={0}", mNum);

            }

            private int mNum3 = ;

            private readonly int mNum4 = ;

            public int Num3

            {

                get { return mNum3; }

                set { mNum3 = value; }

            }

            public Test()

            {

                temp = ;

                mNum = ;

            }

        }

定义了一个类，当我们实例化的时候
Test test = new Test();
执行过程是：
0. 静态的最先执行，仿真编译略过
1. F11 执行 public int mNum2=2; //简单的初始化字段
2. private int mNum3 = 3;
private int mNum4 = 4;
3. public Test() { temp = 1;mNum = 0; } //构造函数

注意：public int mNum;也执行了，只不过系统默认赋值0

当存在继承关系的时候，执行的顺序。
1. 子类的静态字段
2. 子类的静态构造方法
3. 子类的实例字段
4. 父类的静态字段
5. 父类的静态构造方法
6. 父类的实例字段
7. 父类的实例构造方法
8. 子类的实例构造方法

 class A : Test

        {

            readonly int x = ;

            public A()

            {

                PrintFields();

                Look();

            }

            readonly int c;

            readonly int sd = ;

            public virtual void PrintFields()

            {

                Console.WriteLine("j={0},k={1}", "AA", "AA");

            }

        }

        class B : A

        {

            readonly int y;

            int z = ;

            public B()

            {

                z = -;

            }

            public override void PrintFields()

            {

                Console.WriteLine("x={0},y={1}", "b", z);

            }

        }

        class C : B {

            int x = ;

            int y = ;

            public override void PrintFields() {

                Console.WriteLine("j={0},k={1}", "CC", y);

            }

        }

        static void Main(string[] args)

        {

            Console.WriteLine("======实例化Test======");

            Test test = new Test();

            Console.WriteLine("======实例化A======");

            A a = new A();

            Console.WriteLine("======实例化B======");

            B b = new B();

            Console.WriteLine("======实例化C======");

            C c = new C();

            Console.ReadKey();

        }

1. 首先执行 class A中 int x = 1;，执行所有已经初始化后的字段，当执行到构造函数首执行父类字段

2. int sd = 6;

3. public A()，首先会去执行父类。

4. 0. 静态的最先执行，仿真编译略过 1. F11 执行 public int mNum2=2; //简单的初始化字段 2. private int mNum3 = 3; private int mNum4 = 4; 3. public Test() { temp = 1;mNum = 0; } //构造函数

5. public A() { PrintFields(); look(); }// 执行子类中自己的构造函数

6. public virtual void PrintFields() ；执行自己类中有意义的虚函数

7. 执行调用父类的函数 look();

8. 接下来就将要执行 class B 中的内容了。过程类似，先一步一步的执行A类，在执行Test类，实现继承。

9. 忽略部分细节，降调B类中的细节。

int z=2;

public B() 运行到这里的时候，再次执行到 public A() { PrintFields(); look(); } 的构造函数的时候，由于执行的是实例化B类，又在B类中重写了PrintFields();，实现多态。

所以执行 public override void PrintFields() { Console.WriteLine("x={0},y={1}", "b", z); } 所以此时的 z=2；而不是 public B() { z = -1; } 中的z=-1,因为还没有执行到它，随后才执行子类中的构造函数。

巴特西

C# 实例化的执行顺序(转)

最新文章

热门文章