Java初始化快

原创 Laughing  2017-11-05 13:10  阅读 44 次 评论 0 条

使用初始化快

初始化块可以包含任何可执行性的语句,包括定义局部变量,调用其他对象的方法,以及使用分支、循环语句等。

  1. package SecondPackage;  
  2.   
  3. public class Cshk {  
  4.       
  5.     //第一个初始化块  
  6.     {  
  7.         int a = 6;  
  8.         if(a>4){  
  9.             System.out.println(a);  
  10.         }  
  11.     }  
  12.       
  13.     int a = 3;  
  14.       
  15.     /** 
  16.      * 第二个初始化块 
  17.      * @param args 
  18.      */  
  19.     {  
  20.         System.out.println("第二个初始化块");  
  21.     }  
  22.       
  23.     public Cshk() {  
  24.         System.out.println("构造函数");  
  25.     }  
  26.       
  27.     public static void main(String[] args) {  
  28.         // TODO Auto-generated method stub  
  29.         Cshk cshk=  new Cshk();  
  30.         System.out.println(cshk.a);  
  31.     }  
  32.   
  33. }  


通过输出结果,我们可以看到类在实例化的过程中,先调用初始化快,并且初始化块的顺讯是按照定义顺序执行的,然后在执行构造函数。
如果我们将代码顺序简单调整一下

  1. package SecondPackage;  
  2.   
  3. public class Cshk {  
  4.     int a = 3;  
  5.     //第一个初始化块  
  6.     {  
  7.         a = 6;  
  8.         if(a>4){  
  9.             System.out.println(a);  
  10.         }  
  11.     }     
  12.       
  13.     /** 
  14.      * 第二个初始化块 
  15.      * @param args 
  16.      */  
  17.     {  
  18.         System.out.println("第二个初始化块");  
  19.     }  
  20.       
  21.     public Cshk() {  
  22.         System.out.println("构造函数");  
  23.     }  
  24.       
  25.     public static void main(String[] args) {  
  26.         // TODO Auto-generated method stub  
  27.         Cshk cshk=  new Cshk();  
  28.         System.out.println(cshk.a);  
  29.     }  
  30.   
  31. }  


我们可以发现输出的a的结果是6.
所以类的变量赋值结果是按照初始化代码块与变量赋值的顺序执行的。

静态初始化块

使用static关键字修饰的初始化块为静态初始化块,静态初始化块总是在普通初始化块前执行,因为静态初始化块是在类初始化阶段执行的。

  1. public class First {  
  2.     static{  
  3.         System.out.println("First的静态初始化块");  
  4.     }  
  5.     public  First() {  
  6.         System.out.println("First的无参数构造函数");  
  7.     }  
  8.     {  
  9.         System.out.println("First的普通初始化块");  
  10.     }  
  11. }  
  12.   
  13. public class Second extends First{  
  14.     static{  
  15.         System.out.println("Second的静态初始化块");  
  16.     }  
  17.     public  Second() {  
  18.         System.out.println("Second的无参数构造函数");  
  19.     }  
  20.     {  
  21.         System.out.println("Second的普通初始化块");  
  22.     }  
  23.     public Second(String string) {  
  24.         System.out.println("Second的带参数的构造函数");  
  25.     }  
  26. }  
  27.   
  28. public class Third extends Second {  
  29.     static{  
  30.         System.out.println("Third的静态初始化块");  
  31.     }  
  32.     {  
  33.         System.out.println("Third的普通初始化块");  
  34.     }  
  35.     public  Third() {  
  36.         super("调用父类带参数的构造函数");  
  37.         System.out.println("Third的无参数的构造函数");  
  38.     }  
  39. }  

我们调用

  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // TODO Auto-generated method stub  
  5.         new Third();  
  6.     }  
  7.   
  8. }  

执行结果:

本文地址:https://www.lisen.me/java-initialization-fast.html
版权声明:本文为原创文章,版权归 木子网 所有,欢迎分享本文,转载请保留出处!

发表评论


表情