首页手记 Java中初始化的相关问题

Java中初始化的相关问题

标签：

Java

已经快半个月没写博客了，这周在看 Thinking in Java 这本书，准备将书中的第五章和第七章的内容整合一下，写出这篇博客，也算是自己对Java的一些基础知识的复习。

这篇博客要说的是Java中的初始化问题，说到初始化，自然想到的是成员变量和局部变量的初始化了。那么如何对成员变量和局部变量进行初始化就是我们要探讨的问题。

首先是

局部变量的初始化

来看下这段代码：

void f(){    int i;
    i++;    // ERROR -- i没有被初始化}

这里的 i 是一个局部变量，当对 i 进行 i++ 操作的时候，编译器告诉我们这样是不行的，因为 i 没有被初始化。其实万能的编译器完全可以在这种情况下为 i 赋一个初值，但是它没有这样做，Thinking in Java 这本书告诉我们：未初始化的局部变量更有可能是程序员的疏忽，所以采用默认值反而会掩盖这种失误，因此强制程序员提供初值，往往更能帮助更快发现程序中的缺陷。

局部变量是初始化还是很好理解的，编译器不会自动初始化，只能由程序员自己手动提供初始化。而在成员变量上就完全不一样了，下面我们来看看成员变量的初始化是什么样的。

成员变量的初始化

成员变量的初始化又分为自动初始化和手动初始化，并且手动初始化也有一些独特之处，下面就来看看这些不同的地方：

public class InitialValues{    boolean v1;    char v2;    byte v3;    short v4;    int v5;    long v6;    float v7;    double v8;
    InitialValues ref;    void print(){
        System.out.println(v1);
        System.out.println(v2);
        System.out.println(v3);
        System.out.println(v4);
        System.out.println(v5);
        System.out.println(v6);
        System.out.println(v7);
        System.out.println(v8);
        System.out.println(ref);            
    }    public static void main(String[] args){        new InitialValues().print();
    }
}/* output:
false
[]
0
0
0
0
0.0
0.0
null*/

可见当没有给成员变量赋初值的时候，Java的编译器会帮我们处理“ 未初始化变量 ”的风险。这种初始化是自动初始化，当然我们也可以手动的为成员变量进行初始化，就像下面这样：

 1 public class InitialValues{ 2     boolean v1 = true; 3     char v2 = 'a'; 4     byte v3 = 47; 5     short v4 = 0xff; 6     int v5 = 3; 7     long v6 = 4; 8     float v7 = 3.14f; 9     double v8 = 3.14159;10     String str = new String("hello world"); 
11 }

这时是在定义类的成员变量的地方为其赋值，看起来简单明了。可是这种做法有一定的局限性：由类 InitialValues 生成的每个对象都由相同的初始值。这对于程序设计而言是相当缺乏灵活性的一种做法，所以我们需要一种新的方式：在创建对象的时候才对每个对象的成员变量进行赋值，这样每个对象都可以有不同的成员变量数据。这种方式就是下面要说的：构造器初始化。

构造器初始化

通过构造器来对成员变量做初始化是相当灵活的，请看下面一段代码：

public class InitialValue{
    int i;
    InitialValue(int i){
        this.i = i;
    }
}

这样就可以在创建多个对象时，向构造器的形参中传入不同的值。

上面讲解了两种成员变量的初始化，可见第二种构造器初始化更具灵活性。但是有一点要牢记：即使手动进行初始化了，自动初始化过程一样会在手动初始化之前完成。也就是说如果执行 new InitialValue( 7 ) 那么 i 首先会被置0，然后变成7。这种特性对于所有的基本类型和对象引用都是成立的。

静态数据的初始化

这里说的静态数据指的是成员变量为静态的情况，因为 static 关键字不能应用于局部变量。静态数据有一个特点：无论创建多少个对象，静态数据都只占用一份内存。

通过下面的一段代码，可以了解到静态数据是如何初始化的：

 1 class Bowl{ 2     Bowl(int i){ 
 3         System.out.println("Bowl(" + i + ")") 
 4     } 5     void f1(int i){ 
 6         System.out.println("f1(" + i + ")")  
 7     } 8 } 9 clsss Table{10     static Bowl b1 = new Bowl(1);11     Table(){ 
12         b2.f1(1); 
13     }14     void f2(int i){ 
15         System.out.println("f2(" + i + ")")  
16     }17     static Bowl b2 = new Bowl(2);18 }19 class Cupboard{20     Bowl b3 = new Bowl(3);21     static Bowl b4 = new Bowl(4);22     Cupboard(){23         b4.f1(2);24     }25     void f3(int i){ 
26         System.out.println("f3(" + i + ")")  
27     }28     static Bowl b5 = new Bowl(5);29 }30 public class Test{31     public static void main(String[] args){32         new Cupboard();33         new Cupboard();34     }35     static Table table = new Table();36     static Cupboard cupboard = new Cupboard();37 }38 /* output:39 Bowl(1)40 Bowl(2)41 f1(1)42 Bowl(4)43 Bowl(5)44 Bowl(3)45 f1(2)46 Bowl(3) // 这是在main中通过new Cupboar() 打印出来的 start47 f1(2)48 Bowl(3)49 f1(2) // 这是在main中通过new Cupboar() 打印出来的 end50 f2(1)51 f3(1)52 */

可见静态初始化只在必要的时候进行，即第一次访问对象的构造器（或者第一次访问类的静态数据）时静态数据才会被初始化（其实构造器也是一个static方法）。

首先编译器会试图访问 Test.main() ，因为 main() 是静态方法，要执行静态方法必须加载 Test 类，然后静态成员变量 table 和 cupboad 被初始化，这间接的导致他们的类被加载，由于他们都包含静态的 Bowl 成员变量，所以 Bowl 类也被加载。这三个类之间通过 static 关键字联系起来。

下面总结一下对象的创建过程，假设有一个名为Student的类：