静态代码块，构造代码块和构造函数的区别--案列

1.执行顺序：静态代码块>构造代码块>构造方法

    理由：静态代码块（ static {}  ）在类加载的时候执行一次。

               构造代码块（ {}内的部分 ）在 每次创建对象时执行，始终在构造方法前执行。

               构造方法在新建对象时调用（  就是新的时候  ）。

    注意：一个静态代码块在类加载的时候就执行，所以的它优先级高于入口main（）的方法。

                湾当三种形式不止一次出现，同优先级是按照先后顺序执行。

2.现在来看下有继承时的情况：

[java]  view plain  copy

1. public class HelloB extends HelloA {  
2. //<span style="white-space:pre;">   </span>static HelloB hB = new HelloB();  
3.      public HelloB(){  
4.          System.out.println("B的构造方法");  
5.      }  
6.      {  
7.          System.out.println("B的构造代码块");  
8.      }  
9. //   public static HelloB hB = new HelloB();  
10.      static{  
11.          System.out.println("B的静态代码块");  
12.      }  
13. //     public static HelloB hB = new HelloB();  
14.      public static void main(String[] args){  
15.          new HelloB();//调用B的构造方法  
16.      }  
17. }  
18.    
19. class HelloA{  
20.      public HelloA(){  
21.          System.out.println("A的构造方法");  
22.      }  
23.      {  
24.          System.out.println("A的构造代码块");  
25.      }  
26.      static{  
27.          System.out.println("A的静态代码块");  
28.      }  
29. }

输出结果为：

A的静态代码块
B的静态代码块
A的构造代码块
A的构造方法
B的构造代码块
B的构造方法

可以看出：

        一个。 父类始终先调用 （继承先调用父类），并且这 三者之间的相对顺序始终保持不变 

        静态湾因为代码块在 类加载时执行 ，所以先输出的是父类和子类的静态代码块

        调用角乙构造的方法 创建对象 时， 构造块状语从句：构造方法会一起按 顺序执行，还是父类的先调用

以上看下来貌似没什么问题，但看接下来一道阿里笔试题：

[java]  view plain  copy

1. public class B  
2. {  
3. public static B t1 = new B();  
4. public static B t2 = new B();  
5.  {  
6.      System.out.println("构造块");  
7.        
8.  }  
9.  static  
10.  {  
11.      System.out.println("静态块");  
12.        
13.  }  
14.  public static B t1 = new B();  
15.    
16.  public static void main(String[] args)  
17.  {  
18.        
19.      B t =new B();   
20.        
21.  }  
22. }  

显示结果为：

构造块 构造块 静态块 构造块

为什么不是：

静态块  构造块 构造块  构造块

原 因：

静态块：用静态申明，JVM加载类时执行，仅执行一次

构造块：类中直接用{}定义，每一次创建对象时执行

执行顺序优先级：静态块>主（）>构造块>构造方法

因为静缘故T1，T2也上升到静态位，与静态块处于同一优先级，同一优先级就先取按顺序来构造对象，构造对象，静态块

1. public static HelloB hB = new HelloB();  

是在创建对象，创建对象执行构造块，输出---构造块

接下来还是

public static HelloB hB = new HelloB(); 

输出----构造块

接下来静态块，输出------静态块

接下来主中，创建对象，对象为非静态的，所以先静态块，再构造对象，由于静态块只在加载时执行一次，

所以接下来只输出---构造块

注：

第一段代码补充：如果在B的静态代码块之前加一句：

static HelloB hB = new HelloB（）;  

静态代码块会在其执行创建对象（执行构造块）完后再执行，结果如下：

A的静态代码块
A的构造代码块
A的构造方法
B的构造代码块
B的构造方法
B的静态代码块
A的构造代码块
A的构造方法
B的构造代码块
B的构造方法

如果加在之后，则会先执行，说明优先级相同时是按照先后顺序执行的，结果如下：

A的静态代码块
B的静态代码块
A的构造代码块
A的构造方法
B的构造代码块
B的构造方法
A的构造代码块
A的构造方法
B的构造代码块

B的构造方法