Java初始化

2021-08-25 21:57:54

1 概述

Java中，每个类在使用前都需要进行初始化，所以理解初始化是理解java的开端。

在Java中有两个隐藏了的方法：<clinit></clinit>和<init></init>。这两个方法是属于Java虚拟机的，也就是说在程序中我们是不可以调用的。具体可见：

http://dev2dev.bea.com.cn/bbsdoc/20060704286.html

<clinit></clinit><clinit></clinit><clint></clint>"clint<clint></clint>"：对类进行初始化。即在类被装载时，JVM会调用内置的<clinit></clinit>方法对类成员和静态初始化块进行初始化调用（也就是static部分）。

<init></init><init></init>"init<init></init>"：对对象进行初始化。即在创建对象时，JVM会调用<init></init>方法对实例变量和初始化块进行初始化（然后才是构造方法）。

2 举例说明

2.1 普通类初始化

  1. /*  
  2.  * Normal.java  
  3.  *  
  4.  * Created on 2007-5-27, 16:40:14  
  5.  *  
  6.  * 普通类的初始化，先是初始化块，然后是构造方法  
  7.  */  
  8.   
  9. package javabase.init;   
  10.   
  11. /**  
  12.  *  
  13.  * @author Penny Huang  
  14.  */  
  15. public class Normal   
  16. {   
  17.     {   
  18.         System.out.println("Normal <init></init>");   
  19.     }   
  20.     public Normal ()   
  21.     {   
  22.         System.out.println("Normal construct");   
  23.     }       
  24. }   

 输出：

<st1:city w:st="on"><st1:place w:st="on"> Normal</st1:place></st1:city> <init></init>

 Normal construct<o:p> </o:p>

 结论：对象初始化时，先是初始化块，然后才是构造方法。   

2.2 普通类静态初始化 

  1. /*  
  2.  * NormalStatic.java  
  3.  *  
  4.  * Created on 2007-5-27, 16:58:48  
  5.  *  
  6.  * 有静态初始化的类，首先是初始化静态块，然后是一般的初始化块，最后是构造方法  
  7.  */  
  8.   
  9. package javabase.init;   
  10.   
  11. /**  
  12.  *  
  13.  * @author Penny Huang  
  14.  */  
  15. public class NormalStatic   
  16. {   
  17.     static  
  18.     {   
  19.         System.out.println("NormalStatic ");   
  20.     }   
  21.        
  22.     {   
  23.         System.out.println("NormalStatic <init></init>");   
  24.     }   
  25.        
  26.     public NormalStatic ()   
  27.     {   
  28.         System.out.println("NormalStatic construct");   
  29.     }       
  30. }   

输出：

NormalStatic <static init=""></static>

NormalStatic <init></init>

NormalStatic construct<o:p> </o:p>

结论：先是初始化静态部分，然后才初始化其他部分（类是先加载，然后才创建对象，而静态部分是在类加载时初始化的）。

 

 

2.3 继承于普通类的初始化

  1. /*  
  2.  * Special.java  
  3.  *   
  4.  * Created on 2007-5-27, 17:01:34  
  5.  *   
  6.  * 继承于普通类，首先是父类初始化块，然后是父类构造方法，之后是子类的初始化块，最后是子类构造方法  
  7.  */  
  8.   
  9. package javabase.init;   
  10.   
  11. /**  
  12.  *  
  13.  * @author Penny Huang  
  14.  */  
  15. public class Special extends Normal   
  16. {   
  17.   
  18.     {   
  19.         System.out.println("Special <init></init>");   
  20.     }   
  21.   
  22.     public Special()    
  23.     {   
  24.         System.out.println("Special construct");   
  25.     }   
  26.   
  27. }   

输出：

 Special <init></init>

 Special construct

<st1:place w:st="on"><st1:city w:st="on"> Normal</st1:city></st1:place> <init></init>

 Normal construct<o:p> </o:p>

 结论：先初始化父类（默认调用父类的无参构造方法），然后才初始化子类。

 

 

2.4 继承于有静态初始化的类的初始化 

  1. /*  
  2.  * SpecailStatic.java  
  3.  *   
  4.  * Created on 2007-5-27, 17:12:13  
  5.  *   
  6.  * 继承于有静态初始化的类，首先是父类静态初始化，然后是子类静态初始化，之后是父类初始化，最后子类初始化  
  7.  */  
  8.   
  9. package javabase.init;   
  10.   
  11. /**  
  12.  *  
  13.  * @author Penny Huang  
  14.  */  
  15. public class SpecailStatic extends NormalStatic{   
  16.     static  
  17.     {   
  18.         System.out.println("SpecialStatic ");   
  19.     }   
  20.        
  21.     {   
  22.         System.out.println("SpecialStatic <init></init>");   
  23.     }   
  24.        
  25.     public SpecailStatic ()    
  26.     {   
  27.         System.out.println("SpecialStatic construct");   
  28.     }   
  29.   
  30. }   

输出：

SpecialStatic <static init=""></static>

NormalStatic <static init=""></static>

SpecialStatic <init></init>

SpecialStatic construct

NormalStatic <init></init>

NormalStatic construct<o:p> </o:p>

结论：先静后动，先父后子。 

  

3 总结 

Java初始化的顺序如下：

父类静态初始化---->子类静态初始化---->父类初始化块---->父类构造方法---->子类初始化块---->子类构造方法。

上一篇：JAVA深复制(深克隆)与浅复制(浅克隆)


下一篇：VTK5.6安装配置教程