Java內部類詳解

轉載自：https://www.cnblogs.com/dolphin0520/p/3811445.html

Java內部類詳解

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

一.內部類基礎

二.深入理解內部類

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

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

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

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

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

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

1.成員內部類

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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成員和靜態成員）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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.成員方法
　　雖然成員內部類可以無條件地訪問外部類的成員，而外部類想訪問成員內部類的成員卻不是這麼隨心所欲了。在外部類中如果要訪問成員內部類的成員，必須先建立一個成員內部類的物件，再通過指向這個物件的引用來訪問：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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成員
    }
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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.區域性內部類

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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事件監聽程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
             
        }
    });

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

1
2
3
4
5
6
7
8
new OnClickListener() {

        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
             
        }
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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成員必須依附於具體的物件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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的程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
E:\Workspace\Test\bin\com\cxh\test2>javap -v Outter$InnerCompiledfrom"Outter.java"publicclasscom.cxh.test2.Outter$Inner extends java.lang.Object
SourceFile: “Outter.java”
InnerClass:
#24= #1 of #22; //Inner=class com/cxh/test2/OutterKaTeX parse error: Expected 'EOF', got '#' at position 100: …nt pool: const #̲1 = class …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 thisKaTeX parse error: Expected 'EOF', got '#' at position 10: 0; const #̲6 = Asciz …Inner.this$0:Lcom/cxh/t
est2/Outter;
const #11 = NameAndType #5:#6;// thisKaTeX parse error: Expected 'EOF', got '#' at position 32: …/Outter; const #̲12 = Method …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.""?)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變數？

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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壓棧，表示使用的是一個本地區域性變數。這個過程是在編譯期間由編譯器預設進行，如果這個變數的值在編譯期間可以確定，則編譯器預設會在匿名內部類（區域性內部類）的常量池中新增一個內容相等的字面量或直接將相應的位元組碼嵌入到執行位元組碼中。這樣一來，匿名內部類使用的變數是另一個區域性變數，只不過值和方法中區域性變數的值相等，因此和方法中的區域性變數完全獨立開。

下面再看一個例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
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)處的程式碼

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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.下面這段程式碼的輸出結果是什麼？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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);
}
}
}
View Code

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

1）成員內部類的引用方式必須為 Outter.Inner.

2）構造器中必須有指向外部類物件的引用，並通過這個引用呼叫super()。這段程式碼摘自《Java程式設計思想》

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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