几种简单的初始化

几种简单的初始化

成员初始化

如果是类的数据成员，就是类的字段，你可以直接定义一个变量而不给它一个值，这时编译器会给它一个默认值。但是如果是方法内这样就不可以了，会报错，编译器会强制程序员给变量赋值，编译器这样设定是为了防止程序员因为疏忽而忘记赋值，这样默认值会造成程序的运行结果与预期的结果不一致。

-void f(){ int i; }//i没有初始化，会报错；
但是这样是可以的

public class Test{
 int i;
public Test(){
i=1;
System.out.println(i);
}}

有一个很直接的方法为变量赋值，就直接在定义类成员变量的地方直接给变量赋值。
也可以用一个方法的返回值给变量赋值，

public class MethodInit{
int i=f();
int f(){return 1;}//i的值是1；

构造器初始化

public class Counter{
int i;
Counter(){i=1;}
}

可以用构造器来进行初始化，在运行时，可以通过调用某方法或某些动作来确定初值，这给编程带来了很大的灵活性。但是自动初始化无法阻止，上面的代码，i先会被初始化为0；然后变成1；

初始化顺序

class Window{
Window(int marker){System.out.println("Winndow("+marker+")");}
}
class House{
Window w1=new Window(1);
House(){
System.out.println("House");
w3=new Window(33);
}
Window w2=new Window(2);
void f(){System.out.println("f()");}
Window w3=new Window(3);
}
public class Test{
public static void  main(String[] args){
House house=new House();
house.f();
 }
}
//output
Window(1)
Window(2)
Window(3)
House()
Window(33)
f()
 

类中变量的初始化会在方法初始化之前完成。包括构造器。上面的例子中。三个对象的定义放到了方法与方法之间，但运行结果可以看到还是先初始化变量的。

静态数据的初始化

class Bowl{
Bowl(int marker){
System.out.println("Bowl("+maker+")");
}
void f1(int marker){
System.out.println("f1("+marker+")");
  }
}
class Test1
{	
	static Bowl bowl=new Bowl(1);
	Test1(){
		System.out.println("Test1()");
	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 Test2
{	
	public static void main(String args[]){
		System.out.println("Creating new Cupboard() in main");
		new Cupboard();
		System.out.println("Creteing new Test1() in main ");
		new Cupboard();
		test1.f2(1);
		cupboard.f3(1);}
		static Test1 test1=new Test1();//静态域只会初始化一次
		static Cupboard cupboard=new Cupboard();
		
}
//ouput
Bowl(1)
Bowl(2)
Test1()
f1(1）
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Test1() in main
 Bowl(3)
 Cupboard()
 f1(2)
 f2(1);
 f3(1);

初始化的顺序是先静态对象，然后是非静态的对象。然后是构造器。
从上面的例子可以发现静态的对象只会初始化一次。多次创建类的对象，类中的静态对象不会重复初始化。
静态初始化与非静态初始化

public class Spoon{
static int i;
static{
i=47;
  }
}

这是一个静态子句，与其他静态初始化动作一样，这段代码只执行一次；

public class Mugs{
Mug mug1;
Mug mug2;
{
mug1=new Mug(1);
mug2=new Mug(2);
}

看起来和静态初始化一样，就是少了一个static。这种语法对于支持匿名内部类的初始化是必须的。
和静态初始化一样也会在构造器之前初始化。

数组初始化

int[] a1;
int a1[];

定义一个数组，可以向上面这样俩种方法，注意java编译器不允许指定数组的大小。

public class Test{ 
public Test(){ 
	int[]a1={1,1,12,4};
	int[]a2=new int[20];
   }   
}

这是俩种简单的初始化方式，如果把一个数组赋值给另一个数组，那么这俩个数组对应的是同一个数组。
只是引用给了另一个数组。改变一个数组另一个也会跟着改变，它们是同一个数组的俩个引用。指向同一个目标。