一、內部類基礎

　　在Java中，可以將一個類定義在另一個類裡面或者一個方法裡面，這樣的類稱為內部類。廣泛意義上的內部類一般來說包括這四種：成員內部類、區域性內部類、匿名內部類和靜態內部類。下面就先來了解一下這四種內部類的用法。

　　1、成員內部類

　　成員內部類是最普通的內部類，它的定義為位於另一個類的內部，形如下面的形式：

 1 class Circle {
 2     private double radius = 0;
 3     public static int count =1;
 4     public Circle(double radius) {
 
 5         this.radius = radius;
 6     }
 7      
 8     class Draw {     //內部類
 9         public void drawSahpe() {
10             System.out.println(radius);  //外部類的private成員
11             System.out.println(count);   //外部類的靜態成員
12         }
13     }
14 }

　　這樣看起來，類Draw像是類Circle的一個成員，Circle稱為外部類。成員內部類可以無條件訪問外部類的所有成員屬性和方法（包括private成員和靜態成員）。PS：可以將內部類理解為外部類的一個非靜態的成員方法，其可以訪問類內的所有成員屬性和方法

　　不過要注意的是，當成員內部類擁有和外部類同名的成員變數或者方法時，會發生隱藏現象，即預設情況下訪問的是成員內部類的成員。如果要訪問外部類的同名成員，需要以下面的形式進行訪問：

外部類.this.成員變數
外部類.this.成員方法

　　如：

 1 /**
 2  * @theme Java內部類詳解
 3  * @description 成員內部類示例
 4  * @date 2018/11/24
 5  * @author CodingMengmeng
 6  */
 7 package com.meng.javalanguage.internalClass;
 
 8 
 9 public class Circle {
10     private double radius;
11     public static int count = -1;
12     public Circle(double radius) {
13         this.radius = radius;
14     }
15     
16     public void outputHahah() {
17         System.out.println("Hahah");
18     }
19     class Draw {    // 內部類
20         private double radius = 3.33;
21         public void outputHahah() {
22             System.out.println("Hahah...");
23         }
24         public void drawShape() {
25             System.out.println(radius);    // 訪問內部類的radius
26             System.out.println(Circle.this.radius);    // 訪問外部類的radius
27             System.out.println(count);    // 外部類的靜態成員
28             outputHahah();    // 訪問內部類的outputHahah()方法
29             Circle.this.outputHahah();    // 訪問外部類的utputHahah()方法
30             
31         } 
32     }
33     
34     public static void main(String[] args) {
35         Circle circle = new Circle(3.14);
36         Draw draw = circle.new Draw();
37         draw.drawShape();
38     }
39 }

輸出如下：

　　成員內部類是依附外部類而存在的，也就是說，如果要建立成員內部類的物件，前提是必須存在一個外部類的物件。建立成員內部類物件的一般方式如下：

 1 /**
 2  * @theme Java內部類詳解
 3  * @description 建立成員內部類物件的兩種方式
 4  * @date 2018/11/24
 5  * @author CodingMengmeng
 6  */
 7 package com.meng.javalanguage.internalClass;
 8 
 9 import com.meng.javalanguage.internalClass.Outter.Inner;
10 import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
11 
12 public class Test {
13     public static void main(String[] args) {
14         // 第一種方式：
15         System.out.println("成員內部類的第一種建立方式：");
16         Outter outter = new Outter();
17         Inner inner = outter.new Inner(); // 必須通過Outter物件來建立
18         
19         // 第二種方式：
20         System.out.println("成員內部類的第二種建立方式：");
21         Inner inner1 = outter.getInnerInstance();
22         
23     }
24 }
25 
26 class Outter {
27     private Inner inner = null;
28     public Outter() {
29         System.out.println("i am an Outter Class");
30     }
31     
32     public Inner getInnerInstance() {
33         if(inner == null) {
34             inner = new Inner();
35         }
36         return inner;
37     }
38         
39     class Inner {
40         public Inner() {
41             System.out.println("i am a Inner Class");
42         }
43     }
44 }

輸出如下：

 　　內部類可以擁有private訪問許可權，protected訪問許可權、public訪問許可權及包訪問許可權。比如上面的例子，比如上面的例子，如果成員內部類Inner用private修飾，則只能在外部類的內部訪問，如果用public修飾，則任何地方都能訪問；如果用protected修飾，則只能在同一個包下或者繼承外部類的情況下訪問；如果是預設訪問許可權，則只能在同一個包下訪問。這一點和外部類有一點不一樣，外部類只能被public和包訪問兩種許可權修飾。我個人是這麼理解的，由於成員內部類看起來像是外部類的一個成員，所以可以像類的成員一樣擁有多種許可權修飾。

　　2、區域性內部類

　　區域性內部類是定義在一個方法或者一個作用域裡面的類，它和成員內部類的區別在於區域性內部類的訪問僅限於方法或者該作用域內。

 1 /**
 2  * @theme Java內部類詳解
 3  * @description 區域性內部類示例
 4  * @date 2018/11/25
 5  * @author CodingMengmeng
 6  */
 7 package com.meng.javalanguage.internalClass;
 8 
 9 public class People {
10 
11     public People() {
12         System.out.println("i am a People Class");
13     }
14     
15     public static void main(String[] args) {
16         Man man = new Man();
17         man.getWoman();
18     }
19 }
20 
21 class Man {
22     public Man() {
23         System.out.println("i am a Man Class");
24     }
25     
26     public People getWoman() {
27         class Woman extends People {    // 區域性內部類，不能有public、protected、private以及static修飾符
28             int age = 0;
29             
30             public Woman(int age) {
31                 this.age = age;
32                 System.out.println("i am a Woman Class With age:" + age);
33             }
34         }
35         
36         return new Woman(28);
37     }
38 }

輸出如下：

　　注意：區域性內部類就像是方法裡面的一個區域性變數一樣，是不能有public、protected、private以及static修飾符。

　　3、匿名內部類

　　匿名內部類應該是平時我們編寫程式碼時用得最多的，在編寫事件監聽的程式碼時使用匿名內部類不但方便，而且使程式碼更加容易維護。下面這段程式碼是一段Android事件監聽程式碼：

 1 scan_bt.setOnClickListener(new OnClickListener() {
 2              
 3             @Override
 4             public void onClick(View v) {
 5                 // TODO Auto-generated method stub
 6                  
 7             }
 8         });
 9          
10         history_bt.setOnClickListener(new OnClickListener() {
11              
12             @Override
13             public void onClick(View v) {
14                 // TODO Auto-generated method stub
15                  
16             }
17         });

　　這段程式碼為兩個按鈕設定監聽器，這裡面就使用了匿名內部類。這段程式碼中：

1 new OnClickListener() {
2              
3             @Override
4             public void onClick(View v) {
5                 // TODO Auto-generated method stub
6                  
7             }
8         }

　　就是匿名內部類的使用。程式碼中需要給按鈕設定監聽器物件，使用匿名內部類能夠在實現父類或者介面中的方法情況下同時產生一個相應的物件，但是前提是這個父類或者介面必須先存在才能這樣使用。當然像下面這種寫法也是可以的，跟上面使用匿名內部類達到效果相同。

 1 private void setListener()
 2 {
 3     scan_bt.setOnClickListener(new Listener1());       
 4     history_bt.setOnClickListener(new Listener2());
 5 }
 6  
 7 class Listener1 implements View.OnClickListener{
 8     @Override
 9     public void onClick(View v) {
10     // TODO Auto-generated method stub
11              
12     }
13 }
14  
15 class Listener2 implements View.OnClickListener{
16     @Override
17     public void onClick(View v) {
18     // TODO Auto-generated method stub
19              
20     }
21 }

　　這種寫法雖然能達到一樣的效果，但是既冗長又難以維護，所以一般使用匿名內部類的方法來編寫事件監聽程式碼。同樣的，匿名內部類也是不能有訪問修飾符和static修飾符的。

　　匿名內部類是唯一一種沒有構造器的類。正因為其沒有構造器，所以匿名內部類的使用範圍非常有限，大部分匿名內部類用於介面回撥。匿名內部類在編譯的時候由系統自動起名為Outter$1.class。一般來說，匿名內部類用於繼承其它類或是實現介面，並不需要增加額外的方法，只是對繼承方法的實現或是重寫。

　　4、靜態內部類

　　靜態內部類也是定義在另一個類裡面的類，只不過在類的前面多了一個關鍵字static。靜態內部類是不需要依賴於外部類的，這點和類的靜態成員屬性有點類似，並且它不能使用外部類的非static成員變數或者方法。這點很好理解，因為在沒有外部類的物件的情況下，可以建立靜態內部類的物件，如果允許訪問外部類的非static成員就會產生矛盾，因為外部類的非static成員必須依附於具體的物件。

 1 /**
 2  * @theme Java內部類詳解
 3  * @description 靜態內部類示例
 4  * @date 2018/11/25
 5  * @author CodingMengmeng
 6  */
 7 package com.meng.javalanguage.internalClass;
 8 
 9 import com.meng.javalanguage.internalClass.Outterr.Innerr;    // 注意這個import，刪掉將報錯
10 
11 public class StaticInternalClassTest {
12     public static void main(String[] args) {
13         Innerr innerr = new Innerr();// 靜態內部類的建立不需要依賴於外部類的物件
14     }
15 }
16 
17 class Outterr {
18     private double radius;
19     
20     public static int count = -1;
21     public Outterr() {
22         this.radius = 3.44;
23         System.out.println("i am a Outter Class");
24     }
25     
26     static class Innerr {    // 靜態內部類
27         public Innerr() {
28             System.out.println("i am a Inner Class");
29             System.out.println(count);
30         }
31     }
32 }

輸出如下：

二、深入理解內部類

　　1、為什麼成員內部類可以無條件訪問外部類的成員？

　　在此之前，我們已經討論過了成員內部類可以無條件訪問外部類的成員，那具體究竟是如何實現的呢？下面通過反編譯位元組碼檔案看看究竟。事實上，編譯器在進行編譯的時候，會將成員內部類單獨編譯成一個位元組碼檔案，下面是Outter.java程式碼：

 1 public class Outter {
 2     private Inner inner = null;
 3     public Outter() {
 4          
 5     }
 6      
 7     public Inner getInnerInstance() {
 8         if(inner == null)
 9             inner = new Inner();
10         return inner;
11     }
12       
13     protected class Inner {
14         public Inner() {
15              
16         }
17     }
18 }

　　編譯之後，出現了兩個位元組碼檔案：

　　反編譯Outter$Inner.class檔案得到下面資訊：

 1 E:\Workspace\Test\bin\com\cxh\test2>javap -v Outter$Inner
 2 Compiled from "Outter.java"
 3 public class com.cxh.test2.Outter$Inner extends java.lang.Object
 4   SourceFile: "Outter.java"
 5   InnerClass:
 6    #24= #1 of #22; //Inner=class com/cxh/test2/Outter$Inner of class com/cxh/tes
 7 t2/Outter
 8   minor version: 0
 9   major version: 50
10   Constant pool:
11 const #1 = class        #2;     //  com/cxh/test2/Outter$Inner
12 const #2 = Asciz        com/cxh/test2/Outter$Inner;
13 const #3 = class        #4;     //  java/lang/Object
14 const #4 = Asciz        java/lang/Object;
15 const #5 = Asciz        this$0;
16 const #6 = Asciz        Lcom/cxh/test2/Outter;;
17 const #7 = Asciz        <init>;
18 const #8 = Asciz        (Lcom/cxh/test2/Outter;)V;
19 const #9 = Asciz        Code;
20 const #10 = Field       #1.#11; //  com/cxh/test2/Outter$Inner.this$0:Lcom/cxh/t
21 est2/Outter;
22 const #11 = NameAndType #5:#6;//  this$0:Lcom/cxh/test2/Outter;
23 const #12 = Method      #3.#13; //  java/lang/Object."<init>":()V
24 const #13 = NameAndType #7:#14;//  "<init>":()V
25 const #14 = Asciz       ()V;
26 const #15 = Asciz       LineNumberTable;
27 const #16 = Asciz       LocalVariableTable;
28 const #17 = Asciz       this;
29 const #18 = Asciz       Lcom/cxh/test2/Outter$Inner;;
30 const #19 = Asciz       SourceFile;
31 const #20 = Asciz       Outter.java;
32 const #21 = Asciz       InnerClasses;
33 const #22 = class       #23;    //  com/cxh/test2/Outter
34 const #23 = Asciz       com/cxh/test2/Outter;
35 const #24 = Asciz       Inner;
36  
37 {
38 final com.cxh.test2.Outter this$0;
39  
40 public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);
41   Code:
42    Stack=2, Locals=2, Args_size=2
43    0:   aload_0
44    1:   aload_1
45    2:   putfield        #10; //Field this$0:Lcom/cxh/test2/Outter;
46    5:   aload_0
47    6:   invokespecial   #12; //Method java/lang/Object."<init>":()V
48    9:   return
49   LineNumberTable:
50    line 16: 0
51    line 18: 9
52  
53   LocalVariableTable:
54    Start  Length  Slot  Name   Signature
55    0      10      0    this       Lcom/cxh/test2/Outter$Inner;
56  
57  
58 }

　　第11行到35行是常量池的內容，下面注意第38行的內容：

final com.cxh.test2.Outter this$0;

　　這行是一個指向外部類物件的指標，也就是說編譯器會預設為成員內部類新增一個指向外部類物件的引用，用final來修飾，那麼這個引用是如何賦初值的呢？下面接著看內部類的構造器：

public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);

　　從這裡可以看出，雖然我們在定義的內部類的構造器是無參構造器，但編譯器還是會預設新增一個引數，該引數的型別為指向外部類物件的一個引用，所以成員內部類中的Outter this$0指標便指向了外部類物件，因此可以在成員內部類中隨意訪問外部類的成員。從這裡也間接說明了成員內部類是依賴於外部類的，如果沒有建立外部類的物件，則無法對Outter this$0引用進行初始化賦值，也就無法建立成員內部類的物件了。

　　2、為什麼區域性內部類和匿名內部類只能訪問區域性的final變數？

　　想必這個問題也曾經困擾過很多人，在討論這個問題之前，先看下面這段程式碼：

 1 public class Test {
 2     public static void main(String[] args)  {
 3          
 4     }
 5      
 6     public void test(final int b) {
 7         final int a = 10;
 8         new Thread(){
 9             public void run() {
10                 System.out.println(a);
11                 System.out.println(b);
12             };
13         }.start();
14     }
15 }

　　這段程式碼會被編譯成兩個class檔案：Test.class和Test1.class。預設情況下，編譯器會為匿名內部類和區域性內部類起名為Outterx.class(x為正整數)。

　　根據上圖可知，test方法中的匿名內部類的名字被起為Test$1。

　　上端程式碼中，如果把變數a和變數b前面的任一個final去掉，這段程式碼都編譯不過。我們先考慮這樣一個問題：

　　當test方法執行完畢之後，變數a的生命週期就結束了，而此時Thread物件的生命週期很可能還沒有結束，那麼在Thread的run方法中繼續訪問變數a就變成了不可能，但是又要實現這樣的效果，怎麼辦呢？Java採用了複製的手段來解決這個問題。將這段程式碼的位元組碼反編譯可以得到下面的內容：

　　我們看到在run方法中有一條指令：

bipush 10

　　這條指令表示將運算元10壓棧，表示使用的是一個本地區域性變數。這個過程是在編譯期間由編譯器預設進行的，如果這個變數的值在編譯期間可以確定，則編譯器預設會在匿名內部類（區域性內部類）的常量池中新增一個內容相等的字面量或直接將相應的位元組碼嵌入到執行位元組碼中。這樣一來，匿名內部類使用的變數是另一個區域性變數，只不過值和方法中區域性變數的值相等，因此和方法中的區域性變數完全獨立開。

　　下面再看一個例子：

 1 public class Test {
 2     public static void main(String[] args)  {
 3          
 4     }
 5      
 6     public void test(final int a) {
 7         new Thread(){
 8             public void run() {
 9                 System.out.println(a);
10             };
11         }.start();
12     }
13 }

　　反編譯得到：

　　我們看到匿名內部類Test$1的構造器含有兩個引數，一個是指向外部類物件的引用，一個是int型變數，很顯然，這裡是將test方法中的形參a以引數的形式傳進來對匿名內部類中的拷貝（對變數a的拷貝）進行賦值初始化。

　　也就是說如果區域性變數的值在編譯期間就可以確定，則直接在匿名內部裡面建立一個拷貝。如果區域性變數的值無法在編譯期間確定，則通過構造器傳參的方式來對拷貝進行初始化賦值。

　　從上面可以看出，在run方法中訪問的變數a根本就不是test方法中的區域性變數a。這樣一來，就解決了前面所說的生命週期不一致的問題。但是新的問題又來了，既然在run方法中訪問的變數a和test方法中的變數a不是同一個變數，當在run方法中改變變數a的值的話，會出現什麼情況？

　　對，會造成資料不一致性，這樣就達不到原本的意圖和要求了。為解決這個問題，java編譯器就限定必須將變數a限制為final變數，不允許對變數a進行更改（對於引用型別的變數，是不允許指向新的物件），這樣資料不一致性的問題就得以解決了。

　　到這裡，想必大家應該清楚為何方法中的區域性變數和形參都必須用final進行限定了。

　　3、靜態內部類有特殊的地方嗎？

　　從前面可以知道，靜態內部類是不依賴於外部類的，也就是說可以在不建立外部類物件的情況下建立內部類的物件。另外，靜態內部類是不持有指向外部類物件的引用的，這個讀者可以自己嘗試反編譯class檔案看一下就知道，是沒有Outter this&0引用的。

三、內部類的使用場景和好處

　　為什麼在Java中需要內部類？總結一下主要有以下四點：

　　1、每個內部類都能獨立的繼承一個介面的實現，所以無論外部類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。內部類使得多繼承的解決方案變得完整。

　　2、方便將存在一定邏輯關係的類組織在一起，又可以對外界隱藏。

　　3、方便編寫事件驅動程式。

　　4、方便編寫執行緒程式碼

　　個人覺得第一點是最重要的原因之一，內部類的存在使得Java的多繼承機制變得更完善。

　　轉載自《Java內部類詳解》