# 內部類詳解
[TOC]
## 內部類基本概念
在程序開發中為了更加準確的描述結構體的作用，通常擁有各種嵌套結構。而程序**類**也是允許嵌套的！
內部類（內部定義普通類，抽象類，接口的統稱）是指一種嵌套的結構關系，即在一個類的內部除了定義屬性和方法外還可以定義一個類結構，這樣的形式使得程序的結構定義更加靈活。
>[info]內部類是一種常見的嵌套結構，利用這樣的結構可以使內部類與外部類共存，并且方便的進行使用操作的訪問。內部類也可以進一步擴展到匿名內部類的使用，在jdk 1.8后所提供的Lambda表達式與方法引用也可以簡化代碼結構
**示例：**
~~~java
package lamda.dodoke.demo1;
class Outer {//外部類
private String msg = "Hello,World";//定義私有成員屬性
public void fun() {//定義普通方法
Inner in = new Inner();//實例化內部類對象
in.print();//調用內部類方法
}
class Inner {//在Outer類的內部定義Inner內部類
public void print() {//定義內部類的方法
System.out.println(Outer.this.msg);//調用Outer類的屬性
}
}
}
public class JavaDemo {//在一個Java文件中可以有多個類，但是只能有一個public修飾的類
public static void main(String[] args) {
Outer out = new Outer();//實例化外部類對象
out.fun();//執行外部類方法
}
}
~~~
準確來說，內部類會使一個類的內部充斥著其他的類結構，所以內部類在整體設計中最大的缺點就是破壞了良好的程序結構，造成代碼結構的混亂。但他最大的優點在于可以方便的訪問外部類的私有成員。所以我們使用內部類，更多的時候是希望**某一個類只為單獨一個類服務**。
## 內部類相關注意點
* 內部類仍然是一個獨立的類，在編譯之后內部類會被編譯成獨立的`.class`文件，前面冠以外部類的類名和`$`符號。
* 內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變量，無論是否為 private 的。
* 內部類聲明成靜態的，就不能隨便訪問外部類的成員變量，仍然是只能訪問外部類的靜態成員變量。
## 成員內部類
成員內部類（實例內部類）是指沒有用 static 修飾的內部類，有的地方也稱為非靜態內部類。示例如下：
~~~
public class Out {
class Inner {}
}
~~~
* 在外部類的靜態方法和外部類以外的其他類中，必須通過外部類的實例創建內部類的實例。
~~~
public class Outer {
class Inner {}
Inner inner = new Inner(); // 不需要創建外部類實例
public void method1() {
Inner i = new Inner(); // 不需要創建外部類實例
}
public static void method2() {
Inner i = new Outer().new Inner(); // 需要創建外部類實例
}
}
~~~
* 在實例內部類中，可以訪問外部類的所有成員。
~~~
public class Outer {
public int a = 100;
static int b = 100;
final int c = 100;
private int d = 100;
public String method3() {
return "實例方法";
}
public static String method4() {
return "靜態方法";
}
class Inner {
int a2 = a + 1; // 訪問 public 的 a
int b2 = b + 1; // 訪問 static 的 b
int c2 = c + 1; // 訪問 final 的 c
int d2 = d + 1; // 訪問 private 的 d
String str1 = method1(); // 訪問實例方法method1
String str2 = method2(); // 訪問靜態方法method2
}
public static void main(String[] args) {
Inner in = new Outer().new Inner();
System.out.println(in.a2); // 輸出 101
System.out.println(in.b2); // 輸出 101
System.out.println(in.c2); // 輸出 101
System.out.println(in.d2); // 輸出 101
System.out.println(in.str1); // 輸出實例方法
System.out.println(in.str2); // 輸出靜態方法
}
}
~~~
* 在外部類中不能直接訪問內部類的成員，而必須通過內部類的實例去訪問。如果類 A 包含內部類 B，類 B 中包含內部類 C，則在類 A 中不能直接訪問類 C，而應該通過類 B 的實例去訪問類 C。
* 外部類實例與內部類實例是一對多的關系，也就是說一個內部類實例只對應一個外部類實例，而一個外部類實例則可以對應多個內部類實例。
~~~
public class Outer {
int a = 10;
class Inner {
int a = 20;
int a1 = this.a;
int b3 = Outer.this.a;
}
}
~~~
* 在實例內部類中不能定義 static 成員，除非同時使用 final 和 static 修飾。
## 靜態內部類
靜態內部類是指使用 static 修飾的內部類。示例代碼如下：
~~~
public class Outer {
static class Inner {} // 靜態內部類
}
~~~
* 在創建靜態內部類的實例時，不需要創建外部類的實例。
~~~
class OtherClass {
Outer.Inner oi = new Outer.Inner();
}
~~~
* 靜態內部類中可以定義靜態成員和實例成員。外部類以外的其他類需要通過完整的類名訪問靜態內部類中的靜態成員，如果要訪問靜態內部類中的實例成員，則需要通過靜態內部類的實例。
~~~
public class Outer {
static class Inner {
int a = 0;
static int b = 0;
}
}
class OtherClass {
Outer.Inner oi = new Outer.Inner();
int a2 = oi.a; // 訪問實例成員
int b2 = Outer.Inner.b; // 訪問靜態成員
}
~~~
* 靜態內部類可以直接訪問外部類的靜態成員，如果要訪問外部類的實例成員，則需要通過外部類的實例去訪問。
~~~
public class Outer {
int a = 0;
static int b = 0;
static class Inner {
Outer o = new Outer();
int a2 = o.b; // 訪問實例變量
int b2 = b; // 訪問靜態變量
}
}
~~~
## 方法內部類
局部內部類（方法內部類）是指在一個方法中定義的內部類。示例代碼如下：
~~~
public class Test {
public void method() {
class Inner {} // 局部內部類
}
}
~~~
* 局部內部類與局部變量一樣，不能使用訪問控制修飾符（public、private 和 protected）和 static 修飾符修飾。
* 局部內部類只在當前方法中有效。
~~~
public class Test {
Inner i = new Inner(); // 編譯出錯
Test.Inner ti = new Test.Inner(); // 編譯出錯
Test.Inner ti2 = new Test().new Inner(); // 編譯出錯
public void method() {
class Inner {}
Inner i = new Inner();
}
}
~~~
* 局部內部類中不能定義 static 成員。
* 局部內部類中還可以包含內部類，但是這些內部類也不能使用訪問控制修飾符（public、private 和 protected）和 static 修飾符修飾。
* 在局部內部類中可以訪問外部類的所有成員。
* 在局部內部類中可以直接訪問當前方法中的參數與變量。如果方法中的成員與外部類中的成員同名，則可以使用`外部類.this.變量`的形式訪問外部類中的成員。
~~~
public class Test {
int a = 0;
int d = 0;
public void method() {
int b = 0;
final int c = 0;
final int d = 10;
class Inner {
int a2 = a; // 訪問外部類中的成員
int b2 = b; // 訪問外部類中的成員
int c2 = c; // 訪問方法中的成員
int d2 = d; // 訪問方法中的成員
int d3 = Test.this.d; //訪問外部類中的成員
}
Inner i = new Inner();
System.out.println(i.d2); // 輸出 10
System.out.println(i.d3); // 輸出 0
}
}
~~~
## 匿名內部類
匿名類是指沒有類名的內部類，必須在創建時使用 new 語句來聲明類。其語法形式如下：
~~~
new <類或接口>() {
// ....
}
~~~
這種形式的 new 語句聲明一個新的匿名類，它對一個給定的類進行擴展，或者實現一個給定的接口。使用匿名類可使代碼更加簡潔、緊湊，模塊化程度更高。
匿名類有兩種實現方式：
* 繼承一個類，重寫其方法。
* 實現一個接口（可以是多個），實現其方法
~~~
public class Out {
void show() {
System.out.println("調用 Out 類的 show() 方法");
}
}
public class Test {
public static void main(String[] args) {
Out o = new Out() {
void show() {
System.out.println("調用匿名類中的 show() 方法");
}
}
o.show(); // 調用匿名類中的 show() 方法
}
}
~~~
* 匿名類和局部內部類一樣，可以訪問外部類的所有成員。
~~~
public static void main(String[] args) {
int a = 10;
final b = 10;
Out o = new Out() {
void show() {
System.out.println(a); // 編譯通過
System.out.println(b); // 編譯通過
}
}
o.show();
}
~~~
* 匿名類中允許使用非靜態代碼塊進行成員初始化操作。
~~~
Out o = new Out() {
int i;
{
i = 10;
}
public void show() {
System.out.println("i");
}
}
~~~
* 匿名類的非靜態代碼塊會在父類的構造方法之后被執行。
