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

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

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

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

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

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

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

demo1：构造方法

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

demo2:普通代码块

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

demo3:构造代码块

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

demo4:静态代码块

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