老师在讲的时候都是说的 一加载类,  就会加载静态.  而且这三个是分开讲的.  . 后面做了一台习题是.  一个静态  一个 构造代码块 一个构造函数 .  这个我当然知道 顺序.   .  
但是 静态的三个成员 的执行顺序是什么呢. ?   静态代码块 静态函数 和静态属性  

这个加载和执行是不同的概念，静态的所有都会随着类的加载而加载，只是存储到了内存当中而不会执行。
这个执行顺序就要看主函数里面的语句顺序了。
如果楼主是想问这三个的加载顺序，那就有点困难了，因为这个三个没有可比性嘛。

顺序是 静态属性、静态块、静态方法
我写了一个demo，

1. package lu.statics;
   
2. 
   
3. public class StaticDemo {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.        
   
9.         static StaticDemo sd=new StaticDemo();
   
10.        
    
11.         static{
    
12.                
    
13.                 System.out.println("static block");
    
14.                
    
15.         }
    
16.        
    
17.        
    
18.         private StaticDemo(){
    
19.                
    
20.                 System.out.println("static element");
    
21.         }
    
22.        
    
23.         public static StaticDemo getSingle(){
    
24.                
    
25.                 return sd;
    
26.         }
    
27.        
    
28.         public static void main(String[] args) {
    
29.                 // TODO Auto-generated method stub
    
30.                
    
31.                
    
32.                 staticMethod();
    
33. 
    
34.         }
    
35.        
    
36.        
    
37.         public static void staticMethod(){
    
38.                
    
39.                 System.out.println("staticMethod");
    
40.                
    
41.         }
    
42. 
    
43. }
    

复制代码

执行的结果是
static element
static block
staticMethod

这需要分析类可以初始化对象前的一系列动作。类加载器把一个类装入虚拟机中，要经过三个阶段来完成：加载，连接和初始化。加载阶段是查找并加载类的二进制数据。连接阶段包括验证，准备和解析三个过程，其中准备过程中为类的静态变量分配内存，并将其初始化为默认值。注意：初始化阶段为类的静态变量赋予正确的初始值，执行静态代码块。初始化类中的属性是静态代码块的常用用途。而静态方法是被调用的时候才执行的。

静态代码块、非静态代码块、构造函数三者的执行顺序是：

1. public class ExA {  
   
2.     static {  
   
3.         System.out.println("父类--静态代码块");  
   
4.     }  
   
5.   
   
6.     public ExA() {  
   
7.         System.out.println("父类--构造函数");  
   
8.     }  
   
9.   
   
10.     {  
    
11.         System.out.println("父类--非静态代码块");  
    
12.     }  
    
13.   
    
14.     public static void main(String[] args) {  
    
15.         new ExB();  
    
16.     }  
    
17. }  
    
18.   
    
19. class ExB extends ExA {  
    
20.     static {  
    
21.         System.out.println("子类--静态代码块");  
    
22.     }  
    
23.     {  
    
24.         System.out.println("子类--非静态代码块");  
    
25.     }  
    
26.   
    
27.     public ExB() {  
    
28.         System.out.println("子类--构造函数");  
    
29.     }  
    
30. }  
    

复制代码

执行结果
=====
父类--静态代码块
子类--静态代码块
父类--非静态代码块
父类--构造函数
子类--非静态代码块
子类--构造函数



可是静态代码块真的会一定在非静态代码块之前执行吗？
下面这段代码

1. public class ExA {  
   
2.     private static ExA a = new ExA();  
   
3.     static {  
   
4.         System.out.println("父类--静态代码块");  
   
5.     }  
   
6.   
   
7.     public ExA() {  
   
8.         System.out.println("父类--构造函数");  
   
9.     }  
   
10.   
    
11.     {  
    
12.         System.out.println("父类--非静态代码块");  
    
13.     }  
    
14.   
    
15.     public static void main(String[] args) {  
    
16.         new ExB();  
    
17.     }  
    
18. }  
    
19.   
    
20. class ExB extends ExA {  
    
21.     private static ExB b = new ExB();  
    
22.     static {  
    
23.         System.out.println("子类--静态代码块");  
    
24.     }  
    
25.     {  
    
26.         System.out.println("子类--非静态代码块");  
    
27.     }  
    
28.   
    
29.     public ExB() {  
    
30.         System.out.println("子类--构造函数");  
    
31.     }  
    
32. }  
    

复制代码

执行结果
=====
父类--非静态代码块
父类--构造函数
父类--静态代码块
父类--非静态代码块
父类--构造函数
子类--非静态代码块
子类--构造函数
子类--静态代码块
父类--非静态代码块
父类--构造函数
子类--非静态代码块
子类--构造函数
=====
可以发现非静态代码块并不是一定在静态代码块之后执行的。
我认为此时private static ExA a = new ExA()是静态变量。而java里面静态变量与静态代码块是按代码先后顺序执行。所以就导致非静态代码块在静态代码块之前执行。