Java中静态代码块构造代码块的区别

Posted 2020-10-04 圈圈00

来源：https://liuyanzhao.com/5303.html

 

直接在类中定义且没有加static关键字的代码块称为{}构造代码块。

构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。

注意：1 静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 > 构造代码块  > 构造函数；

 

下面我们来举几个例子说明一切

demo1：构造方法

 

1. public class Test {
2.      static {
3.          System.out.println("静态块");
4.      }
6.      {
7.          System.out.println("构造块，在类中定义");
8.      }
10.      public Test() {
11.          System.out.println("构造方法执行");
12.      }
14.      public static void main(String[] args) {
15.          new Test();
16.          new Test();
17.      }
18.  }
19. /*
20. 静态块
21. 构造块，在类中定义
22. 构造方法执行
23. 构造块，在类中定义
24. 构造方法执行
25. */

demo2:普通代码块

 

1. /*普通代码块：在方法或语句中出现的{}就称为普通代码块。
2. 普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行”*/
3. public class Test {
4.     public static void main(String[] args) {
6.         {
7.             int x = 3;
8.             System.out.println("1,普通代码块内的变量x=" + x);
9.         }
11.         int x = 1;
12.         System.out.println("主方法内的变量x=" + x);
14.         {
15.             int y = 7;
16.             System.out.println("2,普通代码块内的变量y=" + y);
17.         }
18.     }
19. }
21. /* 
22. 1,普通代码块内的变量x=3
23. 主方法内的变量x=1
24. 2,普通代码块内的变量y=7
25. */

demo3:构造代码块

 

1. /*构造块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。
2. 构造代码块在创建对象时被调用，每次创建对象都会被调用，
3. 并且构造代码块的执行次序优先于类构造函数。*/
5. public class Test {
6.     {
7.         System.out.println("第一代码块");
8.     }
10.     public Test() {
11.         System.out.println("构造方法");
12.     }
14.     {
15.         System.out.println("第二构造块");
16.     }
18.     public static void main(String[] args) {
19.         new Test();
20.         new Test();
21.         new Test();
22.     }
23. }
24. /*
25. 第一代码块
26. 第二构造块
27. 构造方法
28. 第一代码块
29. 第二构造块
30. 构造方法
31. 第一代码块
32. 第二构造块
33. 构造方法
34. */

demo4:静态代码块

 

1. /*静态代码块:在java中使用static关键字声明的代码块。
2. 静态块用于初始化类，为类的属性初始化。
3. 每个静态代码块只会执行一次。
4. 由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。
5. 如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。
6. 注意：1 静态代码块不能存在于任何方法体内。
7.           2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。*/
9. class Code {
10.     {
11.         System.out.println("Code的构造块");
12.     }
14.     static {
15.         System.out.println("Code的静态代码块");
16.     }
18.     public Code() {
19.         System.out.println("Code的构造方法");
20.     }
21. }
23. public class Test {
24.     {
25.         System.out.println("Test的构造块");
26.     }
28.     static {
29.         System.out.println("Test的静态代码块");
30.     }
32.     public Test() {
33.         System.out.println("Test的构造方法");
34.     }
36.     public static void main(String[] args) {
37.         System.out.println("Test的主方法");
38.         new Code();
39.         new Code();
40.         new Test();
41.         new Test();
42.     }
43. }
44. /*
45. Test的静态代码块
46. Test的主方法
47. Code的静态代码块
48. Code的构造块
49. Code的构造方法
50. Code的构造块
51. Code的构造方法
52. Test的构造块
53. Test的构造方法
54. Test的构造块
55. Test的构造方法
56.  */