成員變量：定義在一個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()