Java內部類詳解

時間 2019-11-11

標籤 java 部類詳解欄目 Java 简体版

原文原文鏈接

Java內部類詳解html

　　提及內部類這個詞，想必不少人都不陌生，可是又會以爲不熟悉。緣由是平時編寫代碼時可能用到的場景很少，用得最多的是在有事件監聽的狀況下，而且即便用到也不多去總結內部類的用法。今天咱們就來一探究竟。下面是本文的目錄大綱：java

　　一.內部類基礎面試

　　二.深刻理解內部類ide

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

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

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

　　請尊重做者勞動成果，轉載請標明原文連接：指針

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

一.內部類基礎

　　在Java中，能夠將一個類定義在另外一個類裏面或者一個方法裏面，這樣的類稱爲內部類。普遍意義上的內部類通常來講包括這四種：成員內部類、局部內部類、匿名內部類和靜態內部類。下面就先來了解一下這四種內部類的用法。htm

　　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);   //外部類的靜態成員
        }
    }
}

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

1 2	外部類.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和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引用的。