前一段时间这部分概念非常的迷，最近理了一下，代码说明下~其实挺简单的~~

1. public class ConstructorAndConsChunk {
   
2.    
   
3.     private String name = "默认值";
   
4. 
   
5.     public ConstructorAndConsChunk() {
   
6.         name = "张三";
   
7.         System.out.println("无参构造函数被执行");
   
8.     }
   
9.    
   
10.    
    
11.    
    
12.     public ConstructorAndConsChunk(String name) {
    
13.         super();
    
14.         this.name = name;
    
15.     }
    
16. 
    
17. 
    
18. 
    
19.     public void print(){
    
20.         System.out.println("执行了方法"+" "+name);
    
21.     }
    
22.    
    
23.     {
    
24.         System.out.println("构造代码块被执行"+name);
    
25.     }
    
26.    
    
27.     static{
    
28.         System.out.println("静态代码块被执行");
    
29.     }
    
30. }

复制代码

测试代码

1. public class ConstructorTest {
   
2. 
   
3.     public static void main(String[] args) {
   
4.         System.out.println("主方法开始");   //以前最迷的就是这个部分，静态代码块在类加载到方法区的时候执行，且只执行一次
   
5.         ConstructorAndConsChunk c = new ConstructorAndConsChunk();
   
6.         c.print();
   
7.         System.out.println("------------------------");
   
8.         ConstructorAndConsChunk c1 = new ConstructorAndConsChunk("李四");
   
9.         c1.print();
   
10.     }
    
11. 
    
12. }
    

复制代码

运行结果为：

1. 主方法开始
   
2. 静态代码块被执行
   
3. 构造代码块被执行默认值
   
4. 无参构造函数被执行
   
5. 执行了方法 张三
   
6. ------------------------
   
7. 构造代码块被执行默认值
   
8. 有参构造被执行
   
9. 执行了方法 李四

复制代码

但是，如果在含有静态代码块的类里使用主方法，例如：

1. public class ConstructorAndConsChunk {
   
2. 
   
3.     private String name = "默认值";
   
4. 
   
5.     public static void main(String[] args) {
   
6.         System.out.println("主方法被执行");
   
7.         ConstructorAndConsChunk c = new ConstructorAndConsChunk();
   
8.         c.print();
   
9.     }
   
10. 
    
11.     public ConstructorAndConsChunk() {
    
12.         name = "张三";
    
13.         System.out.println("无参构造函数被执行");
    
14.     }
    
15. 
    
16.     public ConstructorAndConsChunk(String name) {
    
17.         System.out.println("有参构造被执行");
    
18.         this.name = name;
    
19.     }
    
20. 
    
21.     public void print() {
    
22.         System.out.println("执行了方法" + " " + name);
    
23.     }
    
24. 
    
25.     {
    
26.         System.out.println("构造代码块被执行" + name);
    
27.     }
    
28. 
    
29.     static {
    
30.         System.out.println("静态代码块被执行");
    
31.     }
    
32. 
    
33. }

复制代码

那么执行结果变成：

1. 静态代码块被执行
   
2. 主方法被执行
   
3. 构造代码块被执行默认值
   
4. 无参构造函数被执行
   
5. 执行了方法 张三

复制代码

所以：静态代码块总是在类加载的时候执行且执行一次，如果与主方法处于同一个类，那么先于主方法执行
构造代码块在每次创建对象的时候都会执行

.看了你发的帖子,感觉你很有想法.你入学流程走到哪里了?