java 內部類詳解 - xiaoxi－IT工程師數位筆記本

文章出處

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

一.內部類基礎

二.深入理解內部類

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

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

一、內部類基礎

在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成員 
        } 
    } 
}

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

package com.demo;

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

package com.demo;

public 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文件得到下面信息：

 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;

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

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和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進行限定了。

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