Java中静态代码块、构造代码块

2020-7-21 杨静

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

直接在类中定义且没有加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.  */

发表评论：

@2024 HowTD 浙ICP备18004985号-2

浙公网安备 33010202001281号