Java成员变量初始化

成员变量：定义在一个Java类中，属于一个类;可以通过public、private、protected、static进行修改;存储在堆中;新对象必须在被静态修改之前使用;可以调用当前类的所有方法;如果类有子类，也可以调用子类;并且不能分配。如果没有指定原始数据类型返回相应的值，则非原始数据类型返回 null。

定义：

public class Test{
  public int num;  
}

初始化方法：

1.如果只定义了一个成员变量没有赋值，编译器会自动添加相应的默认值。如：

public class Test{
    //Basic data types
    private boolean flag;   //Default value: false
	private int _int;       //Default value: 0
	private byte _byte;     //Default value: 0
	private char _char;     //Default value: '0000', but when printed in Eclipse, it will be the blank character "box", because the code of the blank character is 0x20, and the control character below 0x20 is invisible.
	private short _short;   //Default value: 0
	private float _float;   //Default value: 0.0
	private long _long;     //Default value: 0
	private double _double; //Default value: 0.0	
	//Reference type defaults to null
	private String string;
}

2. 直接赋值

public class Test {
   private int num = 1;
   private String name = "xiaomin";
   public Person person = new Person();
}

3. 按方法初始化

public class Test{
  private int i = f();  
  private int j = g(i);
  private int f() {
	return 10;
  }
  private int g(int i){
    return i*2
  }  
}

但是编译器在初始化对象的时候是按顺序执行的，所以不能通过下面的方式进行初始化：

public class Test{
  private int j = g(i);
  private int i = f();  
  private int f() {
	return 10;
  }
  private int g(int i){
    return i*2
  }  
}

4.通过构造函数初始化

public class Test{
  int num ;  
  public Test(){
    num = 10;
  }
}

在进入构造函数之前，编译器默认初始化num为0，进入构造函数后赋值为10。

初始化顺序：

编译类时，首先初始化成员变量，成员变量的初始化顺序由定义成员变量的顺序决定。

package com.extendstest;
public class OrderOfInitialization {
	public static void main(String[] args) {
		Card card = new Card();
		card.f();
	}
}
class Tag {
	Tag(int num) {
		System.out.println("Tag" + num);
	}
}
class Card {
	Tag tag1 = new Tag(1); //Define tag1 variable
	Card() {
		System.out.println("Card()");
		tag3 = new Tag(33); //tag3 is reinitialized
	}
	Tag tag2 = new Tag(2); //Define tag2 variables
	void f() {
		System.out.println("f()");
	}
	Tag tag3 = new Tag(3); //Define tag3 variables
}

在 main 方法中，创建了一个卡片对象。编译器编译 Card 类时，成员变量 tag1、tag2、tag3 在构造函数 Card() 之前初始化。因此，上述代码的输出如下：

Tag1
Tag2
Tag3
Card()
Tag33
f()

静态变量的初始化顺序：静态成员变量优先于非静态成员变量。

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();
		t2.f2(1);
		t3.f3(1);
	}
	static Table t2 = new Table(); 
	static Cupboard t3 = new Cupboard(); 
}
class Bowl{
	Bowl(int i){
		System.out.println("Bowl"+i);
	}
	void f(int i){
		System.out.println("f"+i);
	}
}
class Table{
	static Bowl b1 = new Bowl(1); 
	Table(){
		System.out.println("Table()");
		b2.f(1);
	}
	void f2(int i){
		System.out.println("f2("+i+")");
	}
	static Bowl b2 = new Bowl(2); 	
}
class Cupboard{
	Bowl b3 = new Bowl(3);
	static Bowl b4 = new Bowl(4); 
	Cupboard(){
		System.out.println("Cupboard()");
		b4.f(2);
	}
	void f3(int i){
		System.out.println("f3("+i+")");
	}
	static Bowl b5 = new Bowl(5); 
}

因为静态初始化只在Class对象第一次创建时发生一次，所以上面的代码执行如下：

Bowl1
Bowl2
Table()
f1
Bowl4
Bowl5
Bowl3
Cupboard()
f2
Creating new Cupboard() in main
Bowl3
Cupboard()
f2
Creating new Cupboard() in main
Bowl3
Cupboard()
f2
f2(1)
f3(1)

还有以下静态块初始化方法：

class Cup{
	Cup(int i){
		System.out.println("Cup("+i+")");
	}
	void f(int i){
		System.out.println("f("+i+")");
	}
}
class Cups{
	static Cup c1;
	static Cup c2;
	static {  //Static block initialization
		c1 = new Cup(1);
		c2 = new Cup(2);
	}
	Cups(){
		System.out.println("Cups()");
	}
}
public class StaticInitialization {
	public static void main(String[] args) {
		System.out.println("Inside main()");
		Cups.c1.f(99);
	}
	static Cups x = new Cups();
	static Cups y = new Cups();
}

实施结果：

Cup(1)
Cup(2)
Cups()
Cups()
Inside main()
f(99)

另一个非静态实例初始化，没有 static 关键字：

package com.extendstest;
class Mug{
	Mug(int i){
		System.out.println("Mug("+i+")");
	}
	void f(int i ){
		System.out.println("f("+i+")");
	}
}
public class Mugs {
	Mug c1;
	Mug c2;
	{     //Non-static initialization, which is called many times when an object is created
		c1 = new Mug(1);
		c2 = new Mug(2);
		System.out.println("c1&&c2inin....");
	}	
	Mugs(){
		System.out.println("Mugs()");
	}
	public static void main(String[] args) {
		System.out.println("inin..main");		
		Mugs x = new Mugs();
        Mugs y = new Mugs();
	}
}

实施结果：

inin..main
Mug(1)
Mug(2)
c1&&c2inin....
Mugs()
Mug(1)
Mug(2)
c1&&c2inin....
Mugs()