此篇文章作者為：Matrix海子　　　　
出處：http://www.cnblogs.com/dolphin0520/

最近也是在學習java，看的是《java核心技術卷一》jdk8，看到內部類的知識點有一點模糊不清，偶然間看到作者寫的這篇文章，把我在書中沒有完全理解和疑惑的地方全講清楚了，雖然關于字節碼那部分對我這個初學者來說有一些參數看不懂，但是大致通過作者的敘述和自己的思考，可以理解大部分，相信對我以后學習jvm會很有幫助，能看到這篇文章，萬分榮幸，感謝作者的心血付出，膜拜。

本文已同步到：https://www.bithachi.cn/posts/bf7b3e18.html

進入正文：
說起內部類這個詞，想必很多人都不陌生，但是又會覺得不熟悉。原因是平時編寫代碼時可能用到的場景不多，用得最多的是在有事件監聽的情況下，并且即使用到也很少去總結內部類的用法。今天我們就來一探究竟。

1.內部類基礎

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

1.1 成員內部類

成員內部類作為類的成員的角色：

和外部類不同，Inner class還可以聲明為private或protected；

可以調用外部類的結構

Inner class 可以聲明為static的，但此時就不能再使用外層類的非static的成員變量；

可以在內部定義屬性、方法、構造器等結構

可以聲明為abstract類 ，因此可以被其它的內部類繼承

可以聲明為final的

編譯以后生成OuterClass$InnerClass.class字節碼文件（也適用于局部內部類）

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

class Circle {double radius = 0;public Circle(double radius) {this.radius = radius;}class Draw { //成員內部類public void drawSahpe() {System.out.println("drawshape");}} }

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

class Circle {private double radius = 0;public static int count =1;public Circle(double radius) {this.radius = radius;}class Draw { //內部類public void drawSahpe() {System.out.println(radius); //外部類的private成員System.out.println(count); //外部類的靜態成員}} }

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

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

雖然成員內部類可以無條件地訪問外部類的成員，而外部類想訪問成員內部類的成員卻不是這么隨心所欲了。在外部類中如果要訪問成員內部類的成員，必須先創建一個成員內部類的對象，再通過指向這個對象的引用來訪問：

class Circle {private double radius = 0;public Circle(double radius) {this.radius = radius;getDrawInstance().drawSahpe(); //必須先創建成員內部類的對象，再進行訪問}private Draw getDrawInstance() {return new Draw();}class Draw { //內部類public void drawSahpe() {System.out.println(radius); //外部類的private成員}} }

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

public class Test {public static void main(String[] args) {//第一種方式：Outter outter = new Outter();Outter.Inner inner = outter.new Inner(); //必須通過Outter對象來創建//第二種方式：Outter.Inner inner1 = outter.getInnerInstance();} }class Outter {private Inner inner = null;public Outter() {}public Inner getInnerInstance() {if(inner == null)inner = new Inner();return inner;}class Inner {public Inner() {}} }

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

這里插入作者當時版本沒有考慮到的一個問題：
“局部內部類和匿名內部類只能訪問局部final變量”
從JDK 1.8開始，會默認給這兩種內部類訪問的field 加上final(隱式地)，所以你可能會在編譯器中看到可以訪問沒有加final的變量，只有你去修改它時，編譯器才會報錯。

1.2 局部內部類

局部內部類的特點:

內部類仍然是一個獨立的類，在編譯之后內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號，以及數字編號。

只能在聲明它的方法或代碼塊中使用，而且是先聲明后使用。除此之外的任何地方都不能使用該類。

局部內部類可以使用外部類的成員，包括私有的。

局部內部類可以使用外部方法的局部變量，但是必須是final的。由局部內部類和局部變量的聲明周期不同所致。

局部內部類和局部變量地位類似，不能使用public,protected,缺省,private

局部內部類不能使用static修飾，因此也不能包含靜態成員

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

class People{public People() {} }class Man{public Man(){}public People getWoman(){class Woman extends People{ //局部內部類int age =0;}return new Woman();} }

1.3 匿名內部類

• 匿名內部類不能定義任何靜態成員、方法和類，只能創建匿名內部類的一個實例。一個匿名內部類一定是在new的后面，用其隱含實現一個接口或實現一個類。

• 格式：

  new 父類構造器（實參列表）| 實現接口(){ // 匿名內部類的類體部分 }

• 匿名內部類的特點

匿名內部類必須繼承父類或實現接口

匿名內部類只能有一個對象

匿名內部類對象只能使用多態形式引用

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

scan_bt.setOnClickListener(new OnClickListener() {@Overridepublic void onClick(View v) {// TODO Auto-generated method stub}});history_bt.setOnClickListener(new OnClickListener() {@Overridepublic void onClick(View v) {// TODO Auto-generated method stub}});

這段代碼為兩個按鈕設置監聽器，這里面就使用了匿名內部類。這段代碼中的：

new OnClickListener() {@Overridepublic void onClick(View v) {// TODO Auto-generated method stub}}

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

private void setListener() {scan_bt.setOnClickListener(new Listener1()); history_bt.setOnClickListener(new Listener2()); }class Listener1 implements View.OnClickListener{@Overridepublic void onClick(View v) {// TODO Auto-generated method stub} }class Listener2 implements View.OnClickListener{@Overridepublic void onClick(View v) {// TODO Auto-generated method stub} }

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

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

1.4 靜態內部類

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

public class Test {public static void main(String[] args) {Outter.Inner inner = new Outter.Inner();} }class Outter {public Outter() {}static class Inner {public Inner() {}} }

2.深入理解內部類

2.1 為什么成員內部類可以無條件訪問外部類的成員？

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

public class Outter {private Inner inner = null;public Outter() {}public Inner getInnerInstance() {if(inner == null)inner = new Inner();return inner;}protected class Inner {public Inner() {}} }

編譯之后，出現了兩個字節碼文件：

反編譯Outter$Inner.class文件得到下面信息：

E:\Workspace\Test\bin\com\cxh\test2>javap -v Outter$Inner Compiled from "Outter.java" public class com.cxh.test2.Outter$Inner extends java.lang.ObjectSourceFile: "Outter.java"InnerClass:#24= #1 of #22; //Inner=class com/cxh/test2/Outter$Inner of class com/cxh/tes t2/Outterminor version: 0major version: 50Constant pool: const #1 = class #2; // com/cxh/test2/Outter$Inner const #2 = Asciz com/cxh/test2/Outter$Inner; const #3 = class #4; // java/lang/Object const #4 = Asciz java/lang/Object; const #5 = Asciz this$0; const #6 = Asciz Lcom/cxh/test2/Outter;; const #7 = Asciz <init>; const #8 = Asciz (Lcom/cxh/test2/Outter;)V; const #9 = Asciz Code; const #10 = Field #1.#11; // com/cxh/test2/Outter$Inner.this$0:Lcom/cxh/t est2/Outter; const #11 = NameAndType #5:#6;// this$0:Lcom/cxh/test2/Outter; const #12 = Method #3.#13; // java/lang/Object."<init>":()V const #13 = NameAndType #7:#14;// "<init>":()V const #14 = Asciz ()V; const #15 = Asciz LineNumberTable; const #16 = Asciz LocalVariableTable; const #17 = Asciz this; const #18 = Asciz Lcom/cxh/test2/Outter$Inner;; const #19 = Asciz SourceFile; const #20 = Asciz Outter.java; const #21 = Asciz InnerClasses; const #22 = class #23; // com/cxh/test2/Outter const #23 = Asciz com/cxh/test2/Outter; const #24 = Asciz Inner;{ final com.cxh.test2.Outter this$0;public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);Code:Stack=2, Locals=2, Args_size=20: aload_01: aload_12: putfield #10; //Field this$0:Lcom/cxh/test2/Outter;5: aload_06: invokespecial #12; //Method java/lang/Object."<init>":()V9: returnLineNumberTable:line 16: 0line 18: 9LocalVariableTable:Start Length Slot Name Signature0 10 0 this Lcom/cxh/test2/Outter$Inner;}

第11行到35行是常量池的內容，下面逐一第38行的內容：
final com.cxh.test2.Outter this$0;

這行是一個指向外部類對象的指針，看到這里想必大家豁然開朗了。也就是說編譯器會默認為成員內部類添加了一個指向外部類對象的引用，那么這個引用是如何賦初值的呢？下面接著看內部類的構造器：
　
public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);

從這里可以看出，雖然我們在定義的內部類的構造器是無參構造器，編譯器還是會默認添加一個參數，該參數的類型為指向外部類對象的一個引用，所以成員內部類中的Outter this&0 指針便指向了外部類對象，因此可以在成員內部類中隨意訪問外部類的成員。從這里也間接說明了成員內部類是依賴于外部類的，如果沒有創建外部類的對象，則無法對Outter this&0引用進行初始化賦值，也就無法創建成員內部類的對象了。

2.2 為什么局部內部類和匿名內部類只能訪問局部final變量？

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

public class Test {public static void main(String[] args) {}public void test(final int b) {final int a = 10;new Thread(){public void run() {System.out.println(a);System.out.println(b);};}.start();} }

這段代碼會被編譯成兩個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壓棧，表示使用的是一個本地局部變量。這個過程是在編譯期間由編譯器默認進行，如果這個變量的值在編譯期間可以確定，則編譯器默認會在匿名內部類（局部內部類）的常量池中添加一個內容相等的字面量或直接將相應的字節碼嵌入到執行字節碼中。這樣一來，匿名內部類使用的變量是另一個局部變量，只不過值和方法中局部變量的值相等，因此和方法中的局部變量完全獨立開。

下面再看一個例子：

public class Test {public static void main(String[] args) {}public void test(final int a) {new Thread(){public void run() {System.out.println(a);};}.start();} }

反編譯得到：

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

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

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

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

到這里，想必大家應該清楚為何 方法中的局部變量和形參都必須用final進行限定了。

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

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

3.內部類的使用場景和好處

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

1.每個內部類都能獨立的繼承一個接口的實現，所以無論外部類是否已經繼承了某個(接口的)實現，對于內部類都沒有影響。內部類使得多繼承的解決方案變得完整，

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

3.方便編寫事件驅動程序

4.方便編寫線程代碼

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

4.常見的與內部類相關的筆試面試題

1.根據注釋填寫(1)，(2)，(3)處的代碼

public class Test{public static void main(String[] args){// 初始化Bean1(1)bean1.I++;// 初始化Bean2(2)bean2.J++;//初始化Bean3(3)bean3.k++;}class Bean1{public int I = 0;}static class Bean2{public int J = 0;} }class Bean{class Bean3{public int k = 0;} }

從前面可知，對于成員內部類，必須先產生外部類的實例化對象，才能產生內部類的實例化對象。而靜態內部類不用產生外部類的實例化對象即可產生內部類的實例化對象。

創建靜態內部類對象的一般形式為： 外部類類名.內部類類名 xxx = new 外部類類名.內部類類名()

創建成員內部類對象的一般形式為： 外部類類名.內部類類名 xxx = 外部類對象名.new 內部類類名()
　
因此，（1），（2），（3）處的代碼分別為：

//(1) Test test = new Test(); Test.Bean1 bean1 = test.new Bean1(); //(2) Test.Bean2 b2 = new Test.Bean2(); //(3) Bean bean = new Bean(); Bean.Bean3 bean3 = bean.new Bean3();

2.下面這段代碼的輸出結果是什么？

public class Test {public static void main(String[] args) {Outter outter = new Outter();outter.new Inner().print();} }class Outter {private int a = 1;class Inner {private int a = 2;public void print() {int a = 3;System.out.println("局部變量：" + a);System.out.println("內部類變量：" + this.a);System.out.println("外部類變量：" + Outter.this.a);}} } 3 2 1

最后補充一點知識：關于成員內部類的繼承問題。一般來說，內部類是很少用來作為繼承用的。但是當用來繼承的話，要注意兩點：

1）成員內部類的引用方式必須為 Outter.Inner.
2）構造器中必須有指向外部類對象的引用，并通過這個引用調用super()。這段代碼摘自《Java編程思想》

class WithInner {class Inner{} } class InheritInner extends WithInner.Inner {// InheritInner() 是不能通過編譯的，一定要加上形參InheritInner(WithInner wi) {wi.super(); //必須有這句調用}public static void main(String[] args) {WithInner wi = new WithInner();InheritInner obj = new InheritInner(wi);} }

參考資料：

《java編程思想》

http://www.cnblogs.com/chenssy/p/3388487.html

http://blog.csdn.net/zhangjg_blog/article/details/20000769

http://blog.csdn.net/zhangjg_blog/article/details/19996629

http://blog.csdn.net/zhaoqianjava/article/details/6849812

http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html

總結

以上是生活随笔為你收集整理的Java内部类详解(使用场景和好处、相关内部类的笔试面试题)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。