各種介紹語法的程式書上經常出現內部類InnerClass，儘管語法上並不複雜，但如果沒有實際例子供參考的話，在概念上比較難以理解，也難以體會到內部類的精妙之處。

希望這篇博文能幫助你更好地理解內部類 ^_^

一個非常常見的例子：你要在JavaSwing里加一個按鈕，點選按鈕觸發事件。

你知道要觸發按鈕的事件ActionEvent，就得實現ActionListener介面。通過addActionListener(this)來監聽。在事件發生時呼叫ActionListener接口裡的actionPerformed方法。

示意程式碼：（在頁面上加一個按鈕，點選按鈕顯示Hello）

import javax.swing.*;
import java.awt.event.*;

public class SimpleGui implements ActionListener {	//需要ActionListener介面
	JButton button;
	public static void main (String[] args) {
		SimpleGui gui = new SimpleGui();
		gui.go();
	}

	public void go() {
		... 
		button = new JButton("Click me");	//new一個Swing的按鈕
		button.addActionListener(this);		//按鈕繫結事件
		... 
	}

	//實現ActionListener介面內的actionPerformed方法，點選按鈕會顯示Hello
	public void actionPerformed(ActionEvent event) {
		button.setText("Hello");
	}
}
 

上面這段程式碼可以達到目的，但顯然不會有人這樣去做。因為如果頁面上需要多個按鈕呢？你無法為接口裡的actionPerformed方法提供多個實現。

比如，頁面上有兩個按鈕，點選一個按鈕顯示hello，點選另一個按鈕顯示world：

public class SimpleGui implements ActionListener {
	JButton button1;    //兩個按鈕
	JButton button2;
	...
        public static void main (String[] args) {
		SimpleGui gui = new SimpleGui();
		gui.go();
	}

	public void go() {
		... 
		button1 = new JButton("Click me");  //new一個Swing的按鈕
		button.addActionListener(this);
		button2 = new JButton("Click me2"); //再new一個Swing的按鈕
		button2.addActionListener(this);
		... 
	}
	
	public void actionPerformed(ActionEvent event) {
		//how？？？你無法為一個方法提供多個實現
	}
}
 

或許你會這樣來實現actionPerformed方法，以達到點選一個按鈕顯示hello，點選另一個按鈕顯示world的目的：

public void actionPerformed(ActionEvent event) {
	if (event.getSource() == button1) {
		button1.setText("Hello");
	} else if (event.getSource() == button2) {
		button2.setText("world");
	}
}

但這樣看起來太面向過程了，顯得很屌絲，與你高富帥的氣質形象極度不符。你真正需要的是內部類。

顧名思義，定義在一個類內部的類，就是內部類。它外層的類就是外部類。

內部類可以使用外部類的所有方法和變數，就算是外部類的private方法和變數也可以用。但內部類的方法和成員不能被外部類直接使用（即使內部類的public成員也無法被外部類直接訪問），只能通過內部類物件來訪問：

class MyOuterClass {
	private int x;

	class MyInnerClass {		//定義在一個類內部的類，稱為內部類
		void go() { x = 42; }	//沒問題，外部類的private變數也能被內部類訪問
	}
}

定義完內部類，這樣來建立內部類物件：

class MyOuter {
	private int x;
	MyInner inner = new MyInner();	//建立內部類例項，內部類例項一定會綁在外部類例項上

	public void doStuff() { 
		//go();			//Error編譯出錯，外部類無法直接訪問內部類內部的成員，哪怕是public也不行
		inner.go();		//通過內部類物件才能呼叫內部類裡的方法
	}

	class MyInner {			//內部類定義處
		void go() { x = 42; }
	}
}

還有種建立內部類物件的方法，不太常見，但你可以瞭解下：

MyOuter outerObj = new MyOuter();
MyOuter.MyInner innerObj = outerObj.new MyInner();

原理是一樣的，內部類的物件一定會綁在外部類物件上。建立外部類物件，用該外部類物件建立內部類物件。

例子程式碼改成：

public class SimpleGui {
	JButton button1;
	JButton button2;
	...
	public static void main (String[] args) {
		SimpleGui gui = new SimpleGui();
		gui.go();
	}

	public void go() {
		...
		JButton button1 = new JButton("Click me");
		button1.addActionListener(new buttonListener1());
		JButton button2 = new JButton("Click me2");
		button2.addActionListener(new buttonListener2());
		...
	}

	class buttonListener1 implements ActionListener {		//內部類1
		public void actionPerformed(ActionEvent event) {
			button1.setText("Hello");
		}
	}

	class buttonListener2 implements ActionListener {		//內部類2
		public void actionPerformed(ActionEvent event) {
			button2.setText("world");
		}
	}
}

上面都是自解釋程式碼，應該能幫助你理解內部類的精妙：內部類提供了在同一個類中對同一個方法，提供多種實現

PS：

上面這樣將內部類作為外部類的成員來定義（即定義內部類和外部類自身的成員變數和 方法處以同一級別），被稱為成員內部類。

除此之外還有區域性內部類，匿名內部類，靜態內部類。

區域性內部類：定義在類的方法或任意作用域中

interface OutInterface { ... }

class OuterClass {
	public OutInterface doit() {
		class InnerClass implements OutInterface {	//顧名思義，定義在外部類方法或任意作用域中的就是區域性內部類
			...
		}
		return new InnerClass();
	}

	public static void main(String args[]) {
		OuterClass out = new OuterClass();
		out.doit();	
	}
}

該區域性內部類是doit方法的一部分，非OuterClass的一部分，因此doit方法外部無法訪問該內部類。但內部類可以訪問外部類成員（private成員）這一特性仍舊不變。

匿名內部類：沒有類名的內部類

interface OutInterface { … }

class OuterClass {
	public OutInterface doit(){
		return new OutInterface(){	//顧名思義，無類名的稱為匿名內部類(因為無類名，所以只能用預設建構函式)
			...
		};
	}

	public static void main(String args[]) {
		OuterClass out = new OuterClass();
		out.doit();	
	}
}

靜態內部類：內部類前加上static就是靜態內部類。

靜態內部類中可以宣告static成員，而非靜態內部類中不可宣告static成員。且靜態內部類不可以使用外部類的非靜態成員。且不需要外部物件來建立靜態內部類物件：

public class OuterClass {
	int x=0;
	static class Inner{		//靜態內部類
		void doitInner(){
			//x = 5;	//編譯Error，不能在靜態內部類中訪問外部類的非靜態成員
		}
		public static void main(String args[]){ … }   //可將外部類main函式，寫入靜態內部類
	}
}

上面這樣將外部類的static main函式，放入靜態內部類後，編譯將生成OuterClass.class和OuterClass$Inner.class。

執行java OuterClass$Inner就可以執行程式。這樣當完成測試後，需要將.class檔案打包時，只要刪除OuterClass$Inner.class即可。

總結

無論什麼內部類（成員，區域性，匿名，靜態）本質上仍舊是個類，具有普通類的一切特性。

但畢竟是定義在一個普通類的內部，生成訪問許可權受到一定限制（如只能通過外部類物件訪問內部類），不能在程式中直接new一個內部類物件。內部類能訪問外部類的一切成員（靜態內部類有一定限制），但外部類無法直接訪問內部類的成員，只能通過內部類物件來訪問。

如果上面的說法比較難記，可以將外部類想象成丈夫，內部類想象成妻子。對妻子來說，你（丈夫）的就是我的，但我的仍舊是我的。外人無法直接拜訪妻子，必須通過丈夫引見才能拜訪到妻子。

內部類最強大之處在於：能在同一個類中對同一個方法，提供多種實現