Java初始化顺序

1、在类的内部，变量的定义的先后顺序决定了初始化顺序，即使变量定义散布于方法定义间，他们仍旧会在不论什么方法（包含构造器）被调用之前得到初始化

2、静态数据的初始化

class Bowl{
Bowl(int marker){
print("Bowl("+marker+")");
}
void f1(int marker){
print("f1("+marker+")");
}

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

class Cupboard{
Bowl bowl3=new Bowl(3);
static Bowl bowl4=new Bowl(4);

Cupboard(){
print("Cupboard()");
bowl4.f1(2);
}
void f3(int marker){
print("f3("+marker+")");
}
static Bowl bowl5=new Bowl(5);
}

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

static Table table=new Table();
static Cupboard cupboard=new Cupboard();
}

output:

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)

3、显式的静态初始化

class Cup{
Cup(int marker){print("Cup("+marker+")");}
void f(int marker){print("f("+marker+")");}
}

class Cups{
static Cup cup1;
static Cup cup2;
static {
cup1=new Cup(1);
cup2=new Cup(2);
}

Cups(){
print("Cups()");
}

public class ExlicitStatic{
public static void main(String args[]){
print("Inside main()");
Cups.cup1.f(99);   //(1)
}

//static Cups cup1=new Cup();  //(2)
//static Cups cup2=new Cup();  //(2)
}
}

output:

Cup(1)

Cup(2)

f(99)

4、在public class和普通的class中的差异表现

在public class中，首先载入static变量和static块，然后载入main函数，不会载入非static块和非static变量

public class StaticBlockTest {
	static Block b1;
	Block b2 = new Block(2);
	static Block b3=new Block(3);
	{
		b2 = new Block(2);
		System.out.println("non static block");
	}
	
	public static void main(String args[]) {
		Block b = new Block(0);		
	}
	
	static{		
		b1 = new Block(1);
		System.out.println("static block");
	}
}

class Block {	
	public Block(int marker) {
		System.out.println("Block(" + marker + ")");
	}

}

output:

Block(3)
Block(1)
static block
Block(0)

在class中，仅仅有在实例化对象的时候才会载入静态块和非静态块

5、在继承中的初始化顺序

首先载入父类static块，然后是载入子类static块，然后载入父类，然后载入非static块，最后载入构造函数，在父类中相同遵循此顺序

public class InheritanceTest {
	public static void main(String []args){
		Dog d=new Dog();				
	}
}


class Animal{
    
    static int a=print(4);
    int c=print(5);
    Animal(){
        print(0);
    }
    
    public static int print(int i){
        System.out.println(i);
        return i;
    }
}

class Dog extends Animal{
    int b=print(2);
    Dog(){        
        System.out.println("b="+b);
    }
        
    static{
        //new Animal();  //(1)
        System.out.println("dog static");
    }
}

output：

4
dog static
5
0
2
b=2

通过创建父类的实例和在子类构造函数的super()都能够载入父类

假设去掉(1)处的凝视，output为：

4
5
0
dog static
5
0
2
b=2