1. class Day06
   
2. {
   
3.         static int i=2;//随着类的加载而加载。加载到方法区中的静态区中。
   
4.         int j=9;//定义了一个属性，也就是一个成员变量，也叫实例变量。当对象存在时，该变量存在于堆内存的对象中。
   
5. 
   
6.         static{//静态代码块。随着类的加载而执行。
   
7.            System.out.println("静态代码块...i="+i);
   
8.         }
   
9.        
   
10.         Day06(int a){//带一个int参数的构造函数。
    
11.                 this();//调用了本类中空参数的构造函数。
    
12.            System.out.println("有参的构造函数...i="+i+",j="+j);
    
13.         }
    
14. 
    
15.         { //构造代码块，定义在类中的代码块，用于给所有对象进行初始化动作的代码块。
    
16.            System.out.println("构造代码块...i="+i+",j="+j);
    
17.         }
    
18. 
    
19.         static void show(){//静态函数。函数中没有访问非静态的成员。
    
20.             System.out.println("静态show方法...i="+i);
    
21.         }
    
22. 
    
23.         Day06(){// 空参数的构造函数。
    
24.            System.out.println("无参的构造函数..."+",j="+j);
    
25.         }
    
26. }
    
27. 
    
28. class Test
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 Day06 d = new Day06(1);//通过Day06.class类文件创建了对象。
    
33.                 int a = Day06.i;
    
34.                 System.out.println(a);
    
35.                 System.out.println("----");
    
36.                 new Day06(3);
    
37.                 show();               
    
38.         }
    
39.         public static void show()
    
40.         {
    
41.         }
    
42. }

复制代码

请问程序的运行结果是什么？为什么》

明确了类初始化的顺序就能明白这是怎么执行的了
Day06 d = new Day06(1)
这一句整个过程如下
1，首先加载Day06的类，同时加载静态成员和静态代码块，这时i=2,输出  静态代码块...i=2,
2，对对象进行默认初始化，这时j=9
3，对对象进行显示初始化
4，对对象进行构造代码块初始化，这时输出  构造代码块...i=2，j=9
5，调用带参数的构造函
6，调用无参数的构造函数 输出  无参的构造函数...j=9
7，回到带参数的构造函数中  输出 有参的构造函数...i=2，j=9




int a = Day06.i;
将i值付给a,   a=2


输出 2
输出 ----


new Day06(3);
除了不加载静态代码块剩下的与第一句都是相同的