java 初始化

java初始化有什么特点？怎么初始化？初始化的顺序是什么？

实例如下：Test0510.java

//初始化得到保证：类的每个基本类型数据成员在使用前都会得到初始化。
class Init{
	boolean b;
	char c;
	short s;
	int i;
	long l;
	float f;
	double d;
	String str;//对象引用在使用前都会得到特殊值null
	Init init;
	void f(){
		System.out.println("boolean b="+b);
		System.out.println("char c=\""+c+"\"");
		System.out.println("short s="+s);
		System.out.println("int i="+i);
		System.out.println("long l="+l);
		System.out.println("float f="+f);
		System.out.println("double d="+d);
		System.out.println("String str="+str);
		System.out.println("Init init="+init);
	}
	//方法的局部变量，java会通过在编译时出错,来强制程序员在使用前提供一个初始值
	//void g(){int i;i++;}//错误：可能尚未初始化变量i
}
public class Test0510{
	public static void main(String[] args){
		Init i=new Init();
		i.f();
	}
}

public class Test0510{//初始化方法：构造器初始化（构造器是隐式的static方法）
	int i;

	Test0510(){
		System.out.println("i= "+i);//i=0;
		i=10;
		System.out.println("i= "+i);
	}
	
	Test0510(int i){
		System.out.println("i= "+this.i);
		this.i=i;
		System.out.println("i= "+i);
	}
	
	public static void main(String[] args){
		new Test0510();//每次构造器调用之前，都会进行一次自动初始化。
		new Test0510();
		new Test0510(100);
	}
}

class Init{//初始化方法：定义时赋值，类的每个对象都有同样的初值
	int i=10;
	int j=f();
	int z=g(j);
	int f(){return i;}
	int g(int i){return i*10;}
}
public class Test0510{
	public static void main(String[] args){
		Init init=new Init();//创建对象并初始化
	}
}

//初始化顺序：在类的内部，变量定义的先后顺序决定了初始化的顺序
class Window{
	Window(int i){System.out.format("Window(%d)\n",i);}
}

class House{
	Window w1=new Window(1);//2
	
	House(){
		System.out.println("House()");//5
		w3=new Window(4);//6
	}
	
	Window w2=new Window(2);//3
	
	void f(){System.out.println("f()");}
	
	Window w3=new Window(3);//4
}
public class Test0510{
	public static void main(String[] args){
		House h=new House();//1
		h.f();//7
	}
}

class Bowl{//静态数据的初始化
	Bowl(int i){System.out.format("Bowl(%d)\n",i);}
	void f1(int i){System.out.format("f1(%d)\n",i);}
}

class Table{
	static Bowl b1=new Bowl(1);//2
	Table(){
		System.out.println("Table()");//4
		b2.f1(3);//5
	}
	void f2(int i){System.out.format("f2(%d)\n",i);}//18
	static Bowl b2=new Bowl(2);//3
}

class Cupboard{//初始化的顺序是：先静态后非静态
	Bowl b3=new Bowl(6);//9	//14	//每次调用构造器都会进行一次自动初始化
	static Bowl b4=new Bowl(4);//7	//静态初始化只执行一次
	Cupboard(){
		System.out.println("Cupboard()");//10	//15
		b4.f1(7);//11	//16
	}
	void f3(int i){System.out.format("f3(%d)\n",i);}//20
	static Bowl b5=new Bowl(5);//8
}

public class Test0510{//类是在其任何static成员被访问时加载的（构造器是隐式的static方法)
	public static void main(String[] args){//程序入口
		System.out.println("Creating new Cupboard() in main");//12
		new Cupboard();//13
		table.f2(8);//17
		cupboard.f3(9);//19
	}
	static Table table=new Table();//1
	static Cupboard cupboard=new Cupboard();//6
}

class Mug{//静态块和实例块的初始化
	Mug(int i){System.out.format("Mug(%d)\n",i);}
	void f(int i){System.out.format("f(%d)\n",i);}
}
class Mugs{
	Mug m1,m2;
	static Mug m3,m4;
	{//实例块
		m1=new Mug(3);//6		//12
		m2=new Mug(4);//7		//13
		System.out.println("m3 & m4");//8		//14
	}
	static{//静态块
		m3=new Mug(1);//3
		m4=new Mug(2);//4
		System.out.println("m1 & m2");//5
	}
	Mugs(){System.out.println("Mugs()");}//9
	Mugs(int i){System.out.println("Mugs(int)");}//15
}
public class Test0510{
	public static void main(String[] args){
		System.out.println("main()");//1
		new Mugs();//2
		System.out.println("new Mugs() over");//10
		new Mugs(1);//11
		System.out.println("new Mugs(1) over");//16
	}
}

class Art{//初始化基类：基类构造器总是会在导出类构造器之前被调用
	Art(){System.out.println("Art()");}
}
class Drawing extends Art{
	Drawing(){System.out.println("Drawing()");}
}
public class Test0510 extends Drawing{
	Test0510(){System.out.println("Test0510()");}
	public static void main(String[] args){
		new Test0510();
		new Test0510();
	}
}

class Insect{//继承与初始化
	private int i=9;//11
	protected int j;//12	j=0
	Insect(){//
		System.out.format("i = %d,j = %d\n",i,j);//13
		j=39;//14
	}
	private static int x1=printAll("static Insect.x1");//1
	static int printAll(String s){//2	//6	//16
		System.out.println(s);//3		//7	//17
		return 27;//4					//8	//18
	}
}
public class Test0510 extends Insect{
	private int k=printAll("Test0511.k");//15
	public Test0511(){//
		System.out.println("k = "+k);//19
		System.out.println("j = "+j);//20
	}
	private static int x2=printAll("static Test0511.x2");//5
	public static void main(String[] args){//0
		System.out.println("main()");//9
		new Test0511();//10
	}
}

class Soap{//组合与引用初始化
	private String s;
	Soap(){
		System.out.println("Soap()");
		s="constructed";
	}
	public String toString(){return s;}
}
public class Test0511{
	private Soap aSoap;
	private String s1="s1",
		s2,s3,s4;//定义时初始化
	Test0511(){
		System.out.println("Test0511()");
		aSoap=new Soap();
		s2="s2";//构造器内初始化
	}
	{s3="s3";}//实例初始化
	public String toString(){
		if(s4==null) s4="s4";//惰性初始化：使用之前才进行初始化,一定情况下可以减少额外的负担。
		return String.format("s1 = %s,s2 = %s,s3 = %s,s4 = %s\naSoap = %

s\n",s1,s2,s3,s4,aSoap);
	}
	public static void main(String[] args){
		System.out.println(new Test0511());
	}
}