內部類
一個定義在另一個類中的類，叫作內部類
1. 概述
內部類允許你把一些邏輯相關的類組織在一起，並控制位於內部的類的可見性，這麼看來，內部類就像是一種程式碼隱藏機制：將類置於其他類的內部，從而隱藏名字與組織程式碼的模式。
2. 建立內部類
建立內部類的方式就如同你想的一樣，把類的定義置於外部類裡面
public class Outer {
// 其他一些成員宣告
...
public class Inner {
// 其他一些成員宣告
...
}
}
3. 連結外部類
內部類與其外部類之間存在一種聯絡，通過這個聯絡可以訪問外部類的所有成員，而不需要任何特殊條件，可以這麼說，內部類擁有其外部類的所有元素的訪問權。
這是如何做到的呢？當某個外部類的物件建立一個內部類物件時，該內部類物件會祕密地捕獲一個指向外部類物件的引用。在你訪問外部類成員時，可以通過這個引用選擇外部類的成員。所有這些實現的細節由編譯器幫忙處理，大多數時候都無需程式設計師關心。
4. 使用 .this 和 .new
如果你需要生成對外部類物件的引用，可以使用外部類的名字後面緊跟圓點和 this
public class Outer {
public class Inner {
public Outer getOuter() {
return Outer.this;
}
}
public static void main(String[] args) {
Outer outer = new Outer();
Outer outer2 = outer.getOuter();
}
}
如果你想建立某個內部類物件，必須在 new 表示式中提供其外部類的引用，這時需要使用 .new 語法
public class Outer {
public class Inner {}
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
}
}
如果從外部類的非靜態方法之外的位置建立某個內部類物件，要具體指明這個內部類物件的型別：OuterClassName.InnerClassName（在外部類的靜態方法中也可以直接指明型別 InnerClassName）
5. 向上轉型
當將內部類向上轉型為其基類（介面），可以很方便地隱藏實現細節，因為外界所得到的只是指向基類或介面的引用。
// 這是一個介面
public interface Content {...}
class Outer {
// 注意這裡將訪問修飾符設為 private
private class PContent implements Content {
...
}
public Content getContent() {
return new PContent();
}
}
在 Outer 類中，內部類 PContent 是私有的，除了 Outer 外沒有人可以訪問。這意味著，客戶端程式設計師如果想了解這些內部類成員，那是要受限制的。客戶端程式設計師無法訪問任何新增的、不屬於公共介面的方法，也不能向下轉型，因為不能訪問其名字。
6. 多重巢狀內部類
無論一個內部類被巢狀多少層，它都能透明地訪問所有它所嵌入的外部類的所有成員
class MNA {
private void f() {}
class A {
private void g(){}
public class B {
void h() {
g();
f();
}
}
}
}
public class TestClass {
public static void main(String[] args) {
MNA mna = new MNA();
MNA.A mnaa = mna.new A();
MNA.A.B mnaab = mnaa.new B();
mnaab.h();
}
}
成員內部類
成員內部類是最普通的內部類，它和外部類的成員變數一樣，定義在類的內部，可以宣告訪問修飾符。成員內部類有如下特性：
- 不可以定義靜態成員和方法，因為內部類是外部類的一個成員，只有當外部類初始化時，內部類才能初始化，靜態變數屬於類級別，在類載入的時候就初始化，所以兩者本身在語法上就有矛盾。但可以定義常量。
- 可以無條件訪問外部類的所有成員屬性和成員方法（包括 private 成員和靜態成員）。當成員內部類擁有和外部類同名的成員變數或者方法時，會發生隱藏現象，即預設情況下訪問的是成員內部類的成員。如果要訪問外部類的同名成員，需要以下面的形式進行訪問：
OuterClassName.this.innerClassMember
區域性內部類
在方法的作用域內（而不是在其他類的作用域內）建立一個完整的類，這個類被稱作區域性內部類。由於是定義在方法內，所以不能宣告訪問修飾符，作用範圍僅在宣告類的程式碼塊中，但這並不意味著一旦方法作用域執行完畢，區域性內部類就不可用了。區域性內部類有如下特性：
- 區域性內部類同樣不可以定義靜態成員和方法
- 可以無條件訪問外部類的所有成員屬性和成員方法，但不能訪問方法體內的區域性變數，除非定義為 final 常量（仔細想想就知道了，內部類是依靠對外部類的引用進行訪問的）
public class Outer {
public Outer method() {
class Inner {
...
}
}
}
匿名內部類
只用一次的沒有名字的類，具體看下面的例子：
public class Outer {
public Content method() {
return new Content() {
private int i = 11;
@Override
public int getValue() {
return i
}
}
}
}
這種奇怪的語法指的是：建立一個繼承自 Content 的匿名類的物件。通過 new 表示式返回的這個引用被自動向上轉型為 Content 的引用。上述匿名內部類是下述形式的一種簡化形式，也就是說，匿名內部類可以看作對成員內部類或區域性內部類的一種簡寫：
public class Outer {
class MyContent implements Content {
private int i = 11;
@Override
public int getValue() {
return i
}
}
public Content method() {
return new MyContent();
}
}
匿名內部類沒有構造器（因為它根本沒有名字），如果我們希望為匿名內部類做一些初始化操作，那該怎麼辦呢？如果該匿名內部類的基類構造器有引數，則可以直接使用，但編譯器會要求其引數引用是 final（即使你不加，Java8 也會為我們自動加上 final）。或者通過程式碼塊，模仿構造器的行為來實現初始化。
public class Outer {
public Content method() {
return new Content(final int a, final int b) {
private int i = a;
private int j;
{
j = b;
}
}
}
}
靜態內部類
如果不需要內部類物件與其外部類物件之間有聯絡，可以將內部類宣告為 static。既然靜態內部類不需要與外部類有聯絡，那麼也就沒有指向外部類的 this 引用，更像一個獨立的類，這意味著：
- 要建立靜態內部類的物件，並不需要其外部類的物件
- 不能訪問非靜態的外部類物件，只能訪問外部類中的 static 所修飾的成員變數或者是方法
public class Outer {
public static class Inner {
private String label;
public String method1() {
...
}
static int x = 10;
public static void method2() {
...
}
}
}
靜態內部類可以作為介面的一部分，因為你放到介面中的任何類都自動是 public 和 static 的，甚至可以在內部類中實現其外部類介面。
public interface ClassInterface {
void method1();
class InnerClass implements ClassInterface {
@Override
public void method1() {
...
}
}
}
為什麼需要內部類？
內部類的第一個用途就是可以操作建立它的外部類的物件，典型的例子就是集合中常使用的迭代器 iterator。這只是其中之一，使用內部類最吸引人的原因莫過於：
每個內部類都能獨立地繼承自某個類或實現某個介面，無論外部類是否繼承了某個類或實現某個介面
基於這個特性，使得多重繼承成為可能，我們可以讓多個內部類以不同的方式實現不同的介面，或繼承不同的類。下面這個例子使用了匿名內部類，可能你們已經習以為常，但別忘了匿名內部類其實就是內部類的一種簡寫形式。
class D {}
abstract class E {}
class Z extend D {
E getE() {
return new E() {};
}
}
public class TestClass {
static void setD(D d){}
static void setE(E e){}
public static void main(String[] args) {
Z z = new Z();
setD(z);
setE(z.getE);
}
}
另外，內部類也是實現回撥的絕佳選擇。通過內部類可以實現一個閉包，所謂閉包就是一個可呼叫的物件，它記錄了一些資訊。在需要提供閉包來實現回撥時，我們可以採用匿名內部類的方式。
繼承內部類
因為內部類的構造器必須連線到其外部類物件的引用，所以在繼承內部類時，那個指向外部類物件的引用必須被初始化，而在派生類中又不再存在這個引用了。要解決這個問題，必須使用特殊的語法來明確說清它們之間的關係。
class WithInner {
class Inner {}
}
public class InheritInner extends WithInner.Inner {
InheritInner(WithInner wi) {
wi.super();
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner li = new InheritInner(wi);
}
}
構造器要傳遞一個指向外部類物件的引用，此外，還必須顯式地呼叫基類構造器。
內部類可以被覆蓋嗎？答案是不能。如果建立一個內部類，然後繼承其外部類並重新定義此內部類，並不會覆蓋該內部類。兩個內部類是完全獨立的，各自在自己的名稱空間。
內部類識別符號
每個類編譯後都會產生一個 .class 檔案，內部類也會生成一個 .class 檔案，但其命名有嚴格的規則：外部類的名字 + $ + 內部類的名字，例如 OuterClass.java 生成的 .class 檔案包括：
OuterClass.class
OuterClass$InnerClass.class
如果內部類是匿名的，編譯器會簡單地生成一個數字作為其識別符號。如果內部類巢狀在別的內部類之中，只需直接將它們的名字在外部類識別符號與 $ 的後面。