静态代码块，main方法，构造代码块，构造方法执行顺序

代码转载自：https://blog.csdn.net/lzxomg/article/details/51858664

执行顺序优先级

（优先级从高到低）静态代码块 > main方法 > 构造代码块 > 构造方法（函数）

其中静态代码块只执行一次。构造代码块在每次创建对象是都会执行。

当涉及到继承时，按照如下顺序：

执行父类的静态代码块 > 执行子类的静态代码块 > 执行父类的构造代码块 > 执行父类的构造方法 > 执行子类的构造代码块> 执行子类的构造方法

各部分作用

1.静态代码块：

有static修饰的代码块。

是在类的加载过程中初始化的时候进行的，主要目的是给类变量赋予初始值。

 1 class Code {  
 2     {  
 3         System.out.println("Code的构造块");  
 4     }  
 5   
 6     static {  
 7         System.out.println("Code的静态代码块");  
 8     }  
 9   
10     public Code() {  
11         System.out.println("Code的构造方法");  
12     }  
13 }  
14   
15 public class CodeBlock03 {  
16     {  
17         System.out.println("CodeBlock03的构造块");  
18     }  
19   
20     static {  
21         System.out.println("CodeBlock03的静态代码块");  
22     }  
23   
24     public CodeBlock03() {  
25         System.out.println("CodeBlock03的构造方法");  
26     }  
27   
28     public static void main(String[] args) {  
29         System.out.println("CodeBlock03的main方法");  
30         new Code();  
31         new CodeBlock03();  
32     }  
33 }  
34 /* 运行结果: 
35 CodeBlock03的静态代码块 
36 CodeBlock03的main方法 
37 Code的静态代码块 
38 Code的构造块 
39 Code的构造方法 
40 CodeBlock03的构造块 
41 CodeBlock03的构造方法*/

2.构造代码块：

直接在类中定义且没有static修饰没有名字的{}代码块称为构造代码块。构造代码块在每次创建对象时都会被调用，并且构造代码块的执行次序优先于类构造函数。

是独立的，必须依附载体才能运行，Java会把构造代码放到每种构造方法的前面，用于实例化一些共有的实例变量，减少代码量。

 1     public class CodeBlock02  
 2     {  
 3         {  
 4           System.out.println("第一代码块");      
 5         }  
 6           
 7         public CodeBlock02()  
 8         {  
 9           System.out.println("构造方法");  
10         }  
11               
12         {  
13           System.out.println("第二构造块");  
14         }  
15         public static void main(String[] args)  
16         {  
17           new CodeBlock02();  
18           new CodeBlock02();  
19              
20         }  
21     }      
22       
23     /* 
24     执行结果： 
25         第一代码块 
26         第二构造块 
27         构造方法 
28         第一代码块 
29         第二构造块 
30         构造方法 
31     */

3.构造方法：用于实例化变量。

比如A是类级别的， B是实例级别的，自然A要优先B。

对子类的主动使用会导致对其父类的主动使用，所以尽管实例化的是子类，但也会导致父类的初始化和实例化，且优于子类执行。

4.普通代码块

在方法或语句中出现的{ }就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行”，比如在main方法中出现的{}

 1     public class CodeBlock01  
 2     {  
 3        public static void main(String[] args)  
 4        {  
 5              
 6             {  
 7                 int x=3;  
 8                 System.out.println("1,普通代码块内的变量x="+x);      
 9             }  
10                 
11             int x=1;  
12             System.out.println("主方法内的变量x="+x);  
13                
14             {  
15                 int y=5;  
16                 System.out.println("2,普通代码块内的变量y="+y);      
17             }  
18         }  
19     }  
20           
21     /* 
22     运行结果： 
23         1,普通代码块内的变量x=3 
24         主方法内的变量x=1 
25         2,普通代码块内的变量y=5 
26     */