Java字段初始化详解-优快云博客

http://wxl24life.iteye.com/blog/1924719

在 Java 里定义一个类的时候，很多时候我们需要提供成员变量，成员变量专业叫法是 Memeber Variable 或者干脆的叫作 Field. 根据是否使用 static 关键字修饰，可以将 Field 分为两种：

static field：也称作 class variable，这种 filed 属于 class，并不属于单个 instance，所有该 class 的 intance 共享内存中的同一份 class field。
non-static field：也称作 instance variable，它属于每一个具体的 instance，class 的每一个 instance 独享一份 non-static field。

接下来进入本文的主题：java 中 field 的初始化方式。

从初始化代码所在的位置看，可以粗略的分为三种：

在声明 field 的地方进行初始化。
在类的构造方法（constructor) 里对 field 进行初始化
在初始化块（initialization block）中对已声明的 field 进行初始化

第一种方式主要用于简单的赋值，使用这种方式的前提是作为初始化变量的值是已知的并且通常可以使用单行的赋值语句完成（例外？参见 Double Brace Initialization）。

    Java代码   
    
  
 public class Foo {  
     // class variable initializer  
     private static Logger logger = LoggerFactory.getLogger(Foo.class);  
   
     // instance variable initializer  
     private List<String> fooList = new ArrayList<String>();  
 }  

对于复杂的初始化语句，如包含异常处理（try-catch）、使用循环结构初始化等，则需要考虑另外两种初始化方式：constructor 和 initialization block。其中 initialization block 根据是否由 static 关键字修饰，又可分为 static(class) initialization block 和 instance(object) initialization block，前一种只能初始化 class variable，用它进行 instance variable 的初始化会导致编译错误。

构造方法（constructor）可以用于初始化 instance variable。除此之外，少数情况下，instance variable 的初始化需要考虑使用 instance initialization block 完成。例如，在匿名类中的初始化（因匿名类无构造方法），或者类中包含了多个 constructor，而它们有公共的一些复杂初始化操作，此时可以考虑将这些操作提取到 instance initialization block 里。除了这两种情况，在你的代码中应该尽量少使用 instance initialization block。

static initialization block 用于处理带有 class variable 的初始化操作。

    Java代码   
    
  
 public class BarClass {  
   
     private static Properties propTable;  
   
     static {  
         try {  
             propTable.load(new FileInputStream("/data/user.prop"));  
         } catch (Exception e) {  
             propTable.put("user", System.getProperty("user"));  
             propTable.put("password", System.getProperty("password"));  
         }  
     }  
 }  

static initialization block 的另一个功能与线程安全（thread safe）相关。JVM 保证使用同一个 ClassLoader 加载的类中的 static initialization block 只被执行一次，因而它是线程安全的。也正因为这一点，很多时候我们可以利用 static initialization block 执行一些初始化（write）操作，而无需对该 block 使用任何同步机制。

最后来看一下初始化代码的执行顺序问题。在此之前，先看下面这段代码，它可以完整执行，请试着分析一下最后的输出是什么。

    Java代码   
    
  
 /** 
  * @author wxl24life 
  * 
  */  
 public class ClassInitializerOrderTest{  
     public static void main(String[] args) {  
         B a = new B();  
     }  
 }  
   
 class A {  
     static int a = initA();  
     static int initA() {  
         System.out.println("call 1");  
         return 0;  
     }  
       
     {  
         System.out.println("call 5");  
     }  
     {  
         System.out.println("call 6");  
     }  
       
     static {  
         System.out.println("call 2");  
     }  
     static {  
         System.out.println("call 3");  
     }  
       
     static int b = initB();  
     static int initB() {  
         System.out.println("call 4");  
         return 0;  
     }  
   
     A() {  
         System.out.println("call 7");  
     }  
 }  
   
 class B extends A {  
     {  
         System.out.println("call 8");  
     }  
   
     String str = initStr();  
     String initStr() {  
         System.out.println("call 9");  
         return "call 8";  
     }  
       
     static {  
         System.out.println("call 10");  
     }  
   
     B() {  
         super();  
         System.out.println("call 12");  
     }  
   
     {  
         System.out.println("call 11");  
     }  
 }  

用几句话概括下初始化顺序规则（假设调用方式类似于上面代码，即使用 new 操作符）：

static 先于 non-static, non-static 先于 constructor。这里的 static 统指 static field 和 static initialization block 两种初始化方式，non-static 同上。
static 初始化代码按照在源代码中定义的顺序从上往下以此执行，non-static 同上。
存在继承关系时，优先执行基类中的初始化语句。

执行顺序测试代码的输出结果：

    Console text代码   
    
  
 call 1  
 call 2  
 call 3  
 call 4  
 call 10  
 call 5  
 call 6  
 call 7  
 call 8  
 call 9  
 call 11  
 call 12  

参考阅读：

http://coolshell.cn/articles/5826.html

让我们先来看两个类：Base和Derived类。注意其中的whenAmISet成员变量，和方法preProcess()

 
        public 
        class 
         Base 
       
        { 
       
        Base() { 
       
        preProcess(); 
       
        } 
       
        void 
        preProcess() {} 
       
        }

 
        public 
        class 
         Derived  
        extends 
         Base 
       
        { 
       
        public 
        String whenAmISet =  
        "set when declared" 
        ; 
       
        @Override 
        void 
         preProcess() 
       
        { 
       
        whenAmISet =  
        "set in preProcess()" 
        ; 
       
        } 
       
        }

如果我们构造一个子类实例，那么，whenAmISet 的值会是什么呢？

 
        public 
        class 
         Main 
       
        { 
       
        public 
        static 
         void 
        main(String[] args) 
       
        { 
       
        Derived d =  
        new 
         Derived(); 
       
        System.out.println( d.whenAmISet ); 
       
        } 
       
        }

再续继往下阅读之前，请先给自己一些时间想一下上面的这段程序的输出是什么？是的，这看起来的确相当简单，甚至不需要编译和运行上面的代码，我们也应该知道其答案，那么，你觉得你知道答案吗？你确定你的答案正确吗？

很多人都会觉得那段程序的输出应该是“set in preProcess()”，这是因为当子类Derived 的构造函数被调用时，其会隐晦地调用其基类Base的构造函数（通过super()函数），于是基类Base的构造函数会调用preProcess() 函数，因为这个类的实例是Derived的，而且在子类Derived中对这个函数使用了override关键字，所以，实际上调用到的是：Derived.preProcess()，而这个方法设置了whenAmISet 成员变量的值为：“set in preProcess()”。

当然，上面的结论是错误的。如果你编译并运行这个程序，你会发现，程序实际输出的是“set when declared ”。怎么为这样呢？难道是基类Base 的preProcess() 方法被调用啦？也不是！你可以在基类的preProcess中输出点什么看看，你会发现程序运行时，Base.preProcess()并没有被调用到（不然这对于Java所有的应用程序将会是一个极具灾难性的Bug）。

虽然上面的结论是错误的，但推导过程是合理的，只是不完整，下面是整个运行的流程：

进入Derived 构造函数。
Derived 成员变量的内存被分配。
Base 构造函数被隐含调用。
Base 构造函数调用preProcess()。
Derived 的preProcess 设置whenAmISet 值为 “set in preProcess()”。
Derived 的成员变量初始化被调用。
执行Derived 构造函数体。

等一等，这怎么可能？在第6步，Derived 成员的初始化居然在 preProcess() 调用之后？是的，正是这样，我们不能让成员变量的声明和初始化变成一个原子操作，虽然在Java中我们可以把其写在一起，让其看上去像是声明和初始化一体。但这只是假象，我们的错误就在于我们把Java中的声明和初始化看成了一体。在C++的世界中，C++并不支持成员变量在声明的时候进行初始化，其需要你在构造函数中显式的初始化其成员变量的值，看起来很土，但其实C++用心良苦。

在面向对象的世界中，因为程序以对象的形式出现，导致了我们对程序执行的顺序雾里看花。所以，在面向对象的世界中，程序执行的顺序相当的重要。

下面是对上面各个步骤的逐条解释。