java类中数据成员初始化的顺序

Java尽力保证：所有变量在使用前都能得到恰当的初始化。对于方法的局部变量，Java以编译时错误的形式来贯彻这种保证。

void f(){
    int i;
    i++;
}

重点内容
Exception in thread “main” java.lang.Error: Unresolved compilation problem:
The local variable i may not have been initialized

1 数据成员是基本数据类型

类的每个基本类型数据成员保证都会有一个初始值
···java
public class Demo3 {
boolean t;
char c;
byte b;
short s;
int i;
long l;
float f;
double d;
Demo3 demo3;
void printInitialValues(){
System.out.println(t);
System.out.println(c);
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(demo3);
}
public static void main(String[] args){
Demo3 demo = new Demo3();
demo.printInitialValues();
}

}

···
运行结果
false

0
0
0
0
0.0
0.0
null

2 数据成员是非基本类型

2-1

在类的内部，变量定义的先后顺序决定了初始化的顺序。即使变量定义位置在方法的后面，它们仍旧会在任何方法（包括构造函数）被调用之前得到初始化

2-2 静态数据的初始化

无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能运用于局部变量，因此它就只能作用于域。如果一个域是静态的基本类型域，且没有对它进行初始化，那么它就会获得基本类型的标准初值；如果它是一个对象引用，那么它的初始值就是null。
···java
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 Demo2 {
public static void main(String[]args){
System.out.println(“Creating new Cupboard()”);
new Cupboard();
System.out.println(“creating new Cupboard()”);
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()
Bowl(3)
Cupboard()
f1(2)
creating new Cupboard()
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
···

2-3非静态实例初始化

static{
//静态代码块
}
{
//非静态代码块
}

静态代码块是在类加载时自动执行的，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。

···java
class Mug {
Mug(int marker){
System.out.println(“Mug(“+marker+”)”);
}
void f(int marker){
System.out.println(“f(“+marker+”)”);
}
}
public class Demo1 {
Demo1(){
System.out.println(“Mugs()”);
}
Demo1(int i){
System.out.println(“Mugs(int)”);
}
Mug mug1;
Mug mug2;
{
mug1 = new Mug(1);
mug2 = new Mug(2);
System.out.println(“mug1 & mug2 initialized”);;
}

public static  void main(String[] args){
    System.out.println("Inside main()");
    new Demo1();
    System.out.println("new Mugs() completed");
    new Demo1(1);
    System.out.println("new Mug(1) completed");
}

}
运行结果：
Inside main()
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs()
new Mugs() completed
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs(int)
new Mug(1) completed
···