1. <p>class StaticCode
   
2. {
   
3.                   
   
4.             private static StaticCode tt = new StaticCode();</p><p>             private InstanceCode In = new InstanceCode();
   
5. 
   
6.             static
   
7.              {
   
8.                   System.out.println("StaticCode类的静态代码块");                 
   
9.              }
   
10.            
    
11.            private StaticCode()
    
12.            {                    
    
13.                   System.out.println("StaticCode类的构造函数");
    
14.            }
    
15. 
    
16.             {
    
17.                   System.out.println("StaticCode类的构造代码块");
    
18.             }
    
19.                  
    
20.                 public static void main(String []agrs){
    
21. 
    
22.                   }
    
23. }
    
24. 
    
25. 
    
26. class InstanceCode
    
27. {
    
28.             static
    
29.            {
    
30.                  System.out.println("Instance类的静态代码块");
    
31.            }               
    
32.             {
    
33.                  System.out.println("Instance类的构造代码块");
    
34.             }
    
35.            InstanceCode()
    
36.            {
    
37.                  System.out.println("Instance类的构造函数");
    
38.            }
    
39. 只是改变了一下修饰变成private，为什么会发生执行顺序的变化？？

复制代码

private不会修改执行顺序.
首先了解静态修饰的成员都是优先于对象存在，而且如果一个类中有多个静态成员，就会从上往下执行.
1、首先StaticCode碰到的静态成员是tt变量，所以它就要实例化StaticCode类，实例化StaticCode类第一句碰到的就是实例化InstanceCode，但是由于InstanceCode类里又有静态代码块，所以先执行Instance类的静态代码块。
2、构造代码块都是优先于构造函数先执行的，所以再执行Instance类的构造代码块
3、Instance类的构造函数
4、StaticCode类的构造代码块
5、StaticCode类的构造函数
6、static的tt对象初始化完了，才初始化StaticCode类的静态代码块。
总结:静态执行顺序是，从上往下，从里往外。

这个会不会更改执行顺序，你完全可以进行标志的输出语句，查看运行结果，
以查看结构就知道是否更改执行顺序哦！