C# 类初始化顺序（转）

C#的类初始化顺序和Java以及C++类初始化顺序是不同的，曾经我被这个问题害惨了。
对于C#和Java，其共同点都是先变量后构造函数，先静态后普通 
区别在于，C#是子类变量->父类变量->父类构造函数->子类构造函数，才轮到构造函数，但是Java的是父类变量->父类构造函数->子类变量->子类构造函数.

 现在给出测试代码，用事实说话：

1. using System; 
2.  
3. namespace Test 
4. { 
5.     public class A 
6.     { 
7.  
8.         private static Display d1 = new Display("基类静态变量"); 
9.         private Display d2 = new Display("基类变量"); 
10.         private static readonly Display d3 = new Display("基类静态readonly常量"); 
11.         private readonly Display d4 = new Display("基类 readonly常量"); 
12.  
13.         public A() 
14.         { 
15.             Console.WriteLine("基类 构造函数"); 
16.         } 
17.  
18.     } 
19.  
20.     class B : A 
21.     { 
22.         private static Display d1 = new Display("子类静态变量"); 
23.         private Display d2 = new Display("子类变量"); 
24.         private static readonly Display d3 = new Display("子类静态readonly常量"); 
25.         private readonly Display d4 = new Display("子类readonly常量"); 
26.  
27.  
28.         public B() 
29.         { 
30.             Console.WriteLine("子类 构造函数"); 
31.         } 
32.   
33.     } 
34.  
35.     /// <summary> 
36.     /// 用于显示的类 
37.     /// </summary> 
38.     class Display 
39.     { 
40.         public Display(string str) 
41.         { 
42.             Console.WriteLine(str); 
43.         } 
44.     } 
45.  
46.     class programe 
47.     { 
48.         static void Main(string[] args) 
49.         { 
50.             B b = new B(); 
51.  
52.         } 
53.     } 
54. } 
55.  

1. 子类静态变量 
2. 子类静态readonly常量 
3. 子类变量 
4. 子类readonly常量 
5. 基类静态变量 
6. 基类静态readonly常量 
7. 基类变量 
8. 基类 readonly常量 
9. 基类 构造函数 
10. 子类 构造函数 

而对于java呢，源码如下：

 

1. package com.vision.paintTest; 
2.  
3. class A { 
4.  
5.     private static Display d1 = new Display("基类静态变量"); 
6.     private Display d2 = new Display("基类变量"); 
7.     private static final Display d3 = new Display("基类静态final常量"); 
8.     private final Display d4 = new Display("基类 final常量"); 
9.  
10.     public A() { 
11.         System.out.println("基类 构造函数"); 
12.     } 
13.  
14. } 
15.  
16. class B extends A { 
17.     private static Display d1 = new Display("子类静态变量"); 
18.     private Display d2 = new Display("子类变量"); 
19.     private static final Display d3 = new Display("子类静态final常量"); 
20.     private final Display d4 = new Display("子类final常量"); 
21.  
22.     public B() { 
23.         System.out.println("子类 构造函数"); 
24.     } 
25.  
26. } 
27.  
28. class Display { 
29.     public Display(String str) { 
30.         System.out.println(str); 
31.     } 
32. } 
33.  
34. public class Mytest { 
35.  
36.     /** 
37.      * @param args 
38.      */ 
39.     public static void main(String[] args) { 
40.         // TODO Auto-generated method stub 
41.         B b = new B(); 
42.     } 
43.  
44. } 

结果如下：

1. 基类静态变量 
2. 基类静态final常量 
3. 子类静态变量 
4. 子类静态final常量 
5. 基类变量 
6. 基类 final常量 
7. 基类 构造函数 
8. 子类变量 
9. 子类final常量 
10. 子类 构造函数 

转载于:https://www.cnblogs.com/naariah/articles/2119339.html