Java中成员初始化

1次阅读

共计 3667 个字符，预计需要花费 10 分钟才能阅读完成。

Java 会尽量保障：所有变量在应用前都能失去失当的初始化，对于办法的局部变量，Java 以编译时谬误的模式来保障。如果写成：

viod f(){
int i;
i++;//Error
}

就会失去报错信息，i 可能没有进行初始化。要是类的数据成员是根本类型，状况就不一样了，类的每个根本类型的数据成员都会有一个初始值，比方：

public class InitialValues {
    boolean t;
    char c;
    byte b;
    short s;
    int i;
    long l;
    float f;
    double d;
    InitialValues reference;
    void printInitialValues() {System.out.println("Data type      Initial value");
        System.out.println("boolean" + t);
        System.out.println("char           [" + c + "]");
        System.out.println("byte" + b);
        System.out.println("short" + s);
        System.out.println("int" + i);
        System.out.println("long" + l);
        System.out.println("float" + f);
        System.out.println("double" + d);
        System.out.println("reference" + reference);
    }
    public static void main(String[] args) {InitialValues iv = new InitialValues();
        iv.printInitialValues();}
}
/* 输入:
Data type      Initial value
boolean        false
char           []
byte           0
short          0
int            0
long           0
float          0.0
double         0.0
reference      null
*/

成员变量和局部变量的不同:
成员变量

类中定义的变量，也称类的属性
未赋值会有缺省值，个别在类的构造方法被调用时实现初始化

局部变量

办法中定义的变量，或者办法签名中的参数
不会主动初始化，须要手动赋值。未赋值间接应用，编译器就会报错

结构器是一个在创建对象时被主动调用的非凡办法。在 Java 中应用结构器能够为对象进行一些必须要初始化的工作，也是 Java 的垃圾清理的根底。上面是一个结构器的例子。

class Rock {Rock() {System.out.println("Rock");
    }
}

public class SimpleConstructor1 {public static void main(String[] args) {for (int i = 0; i < 10; i++) {new Rock();
        }
    }
}

在创建对象时，new Rock(); 将会为对象调配空间，并调用相应的结构器 Rock()，这就使得咱们在操作对象之前，对象曾经被初始化了。

结构器的名称必须与类名完全相同；结构器是没有返回值的。

默认结构器
不承受任何参数的结构器叫做默认结构器，它的作用是创立一个默认对象，如果你写的类中没有结构器，则编译器会主动帮你创立一个默认的结构器。例如：

class Bird{}
public class DefaultConstructor {public static void main(String[] args) {Bird bird =new Bird();
    }
}

new Bird()行创立了一个新的对象，并调用其默认结构器（只管没有明确定义 Bird()结构器），这是因为没有结构器的话，就没有办法可调用，也就无奈创建对象。然而如果曾经定义了一个结构器（无论是否有参数）, 编译器就不会再主动创立默认结构器：

class Bird2 {Bird2(int i) { }

    Bird2(double d) {}}

public class NoSynthesis {public static void main(String[] args) {// Bird2 b = new Bird2();
        Bird2 b2 = new Bird2(1);
        Bird2 b3 = new Bird2(1.0);
    }
}

上述代码中，要是这样写：new Bird2()编译器就会报错：Cannot resolve constructor Bird2()。这种状况是因为，要是没有提供任何结构器，编译器会默认建一个。然而如果曾经写了一个结构器，编译器不确定你是刻意省略的，还是脱漏了，也就不再创立默认的结构器了。

也能够在结构器里进行初始化，然而这不影响数据成员的初始化，数据成员的初始化会在结构器被调用之前实现。如果应用下述代码：

class Counter {
    int i;

    Counter() {i = 7;}
}

那么 i 会先被置为 0，而后变成 7。对于所有根本类型和对象援用，包含在定义时曾经指定初值的变量，都是这样的程序。因而编译器不会强制你肯定要在结构器的某个中央或在应用它们之前对元素进行初始化 - 因为曾经进行过初始化。

在类的外部，变量定义的先后顺序决定了初始化的程序。即便变量定义分布于办法定义之间，它们仍旧会在任何办法（包含结构器）被调用之前失去初始化。

静态数据的初始化
无论创立多少个对象，静态数据都只占用一份存储区域。static 关键字不能利用于局部变量，因而它只能作用于局部域。如果一个动态的根本类型成员，也没有对它进行初始化，那么它就会取得根本类型的规范初值；如果它是一个对象援用，那么它的默认初始化值就是 null。
上面的例子能够理解动态成员是何时初始化的：

class Bowl {Bowl(int marker) {System.out.println("Bowl(" + marker + ")");
    }
    void f1(int marker) {System.out.println("f1(" + marker + ")");
    }
}

class Table {static Bowl bowl1 = new Bowl(1);
    Table() {System.out.println("Table()");
        bowl2.f1(1);
    }
    void f2(int marker) {System.out.println("f2(" + marker + ")");
    }
    static Bowl bowl2 = new Bowl(2);
}

class Cupboard {Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);
    Cupboard() {System.out.println("Cupboard()");
        bowl4.f1(2);
    }
    void f3(int marker) {System.out.println("f3(" + marker + ")");
    }
    static Bowl bowl5 = new Bowl(5);
}

public class StaticInitialization {public static void main(String[] args) {System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        table.f2(1);
        cupboard.f3(1);
    }

    static Table table = new Table();
    static Cupboard cupboard = new Cupboard();} /* 输入:
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
*///:~

从下面的例子能够看出：