Java內部類詳解

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

　　一.內部類基礎

　　二.深入理解內部類

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

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

　　若有不正之處，請多諒解並歡迎批評指正。

　　請尊重作者勞動成果，轉載請標明原文鏈接：

　　http://www.cnblogs.com/dolphin0520/p/3811445.html

一.內部類基礎

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

　　1.成員內部類

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


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和包訪問兩種權限修飾。我個人是這麼理解的，由於成員內部類看起來像是外部類的一個成員，所以可以像類的成員一樣擁有多種權限修飾。

　　2.局部內部類

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


class People{

    public People()
{

    }

}

class Man{

    public Man(){

    }

    public People
getWoman(){

        class Woman extends People{   //局部內部類

            int age
=0;

        }

        return new Woman();

    }

}

　　注意，局部內部類就像是方法裏面的一個局部變量一樣，是不能有public、protected、private以及static修飾符的。

　　3.匿名內部類

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


scan_bt.setOnClickListener(new OnClickListener()
{

            @Override

            public void onClick(View
v) {

                //
TODO Auto-generated method stub

            }

        });

        history_bt.setOnClickListener(new OnClickListener()
{

            @Override

            public void onClick(View
v) {

                //
TODO Auto-generated method stub

            }

        });

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


new OnClickListener()
{

            @Override

            public 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{

    @Override

    public void onClick(View
v) {

    //
TODO Auto-generated method stub

    }

}

class Listener2 implements View.OnClickListener{

    @Override

    public void onClick(View
v) {

    //
TODO Auto-generated method stub

    }

}

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

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

　　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()
{

        }

    }

}

二.深入理解內部類

　　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.Object

  SourceFile: "Outter.java"

  InnerClass:

   #24=
#1 of
#22; //Inner=class
com/cxh/test2/Outter$Inner of class com/cxh/tes

t2/Outter

  minor
version: 0

  major
version: 50

  Constant
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=2

   0:  
aload_0

   1:  
aload_1

   2:  
putfield        #10; //Field
this$0:Lcom/cxh/test2/Outter;

   5:  
aload_0

   6:  
invokespecial   #12; //Method
java/lang/Object."<init>":()V

   9:   return

  LineNumberTable:

   line 16: 0

   line 18: 9

  LocalVariableTable:

   Start 
Length  Slot  Name   Signature

   0      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.爲什麼局部內部類和匿名內部類只能訪問局部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和Test$1.class。默認情況下，編譯器會爲匿名內部類和局部內部類起名爲Outter$x.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進行限定了。

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

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

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

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

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

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

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

　　4.方便編寫線程代碼

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

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

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）處的代碼分別爲：

Test test = new Test();    

　　Test.Bean1 bean1 = test.new Bean1();

Test.Bean2 b2 = new Test.Bean2();

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);

    }

}