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.  */

发表评论 取消回复