java內部類的做用分析

時間 2019-11-07

標籤 java 部類分析欄目 Java 简体版

原文原文鏈接

提起Java內部類（Inner Class）可能不少人不太熟悉，實際上相似的概念在C++裏也有，那就是嵌套類（Nested Class），關於這二者的區別與聯繫，在下文中會有對比。內部類從表面上看，就是在類中又定義了一個類（下文會看到，內部類能夠在不少地方定義），而實際上並無那麼簡單，乍看上去內部相似乎有些多餘，它的用處對於初學者來講可能並非那麼顯著，可是隨着對它的深刻了解，你會發現Java的設計者在內部類身上的確是用心良苦。學會使用內部類，是掌握Java高級編程的一部分，它可讓你更優雅地設計你的程序結構。下面從如下幾個方面來介紹：

第一次見面

[java] view plain copy

public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Goods {
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}

在這個例子裏類Content和GDestination被定義在了類Goods內部，而且分別有着protected和private修飾符來控制訪問級別。Content表明着Goods的內容，而GDestination表明着Goods的目的地。它們分別實現了兩個接口Content和Destination。在後面的main方法裏，直接用 Contents c和Destination d進行操做，你甚至連這兩個內部類的名字都沒有看見！這樣，內部類的第一個好處就體現出來了隱藏你不想讓別人知道的操做，也即封裝性。

同時，咱們也發現了在外部類做用範圍以外獲得內部類對象的第一個方法，那就是利用其外部類的方法建立並返回。上例中的cont()和dest()方法就是這麼作的。那麼還有沒有別的方法呢？固然有，其語法格式以下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在建立非靜態內部類對象時，必定要先建立起相應的外部類對象。至於緣由，也就引出了咱們下一個話題非靜態內部類對象有着指向其外部類對象的引用，對剛纔的例子稍做修改：

[java] view plain copy

public class Goods {
private int valueRate = 2;
private class Content implements Contents {
private int i = 11 * valueRate;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}

在這裏咱們給Goods類增長了一個private成員變量valueRate，意義是貨物的價值係數，在內部類Content的方法value()計算價值時把它乘上。咱們發現，value()能夠訪問valueRate，這也是內部類的第二個好處一個內部類對象能夠訪問建立它的外部類對象的內容，甚至包括私有變量！這是一個很是有用的特性，爲咱們在設計時提供了更多的思路和捷徑。要想實現這個功能，內部類對象就必須有指向外部類對象的引用。Java編譯器在建立內部類對象時，隱式的把其外部類對象的引用也傳了進去並一直保存着。這樣就使得內部類對象始終能夠訪問其外部類對象，同時這也是爲何在外部類做用範圍以外向要建立內部類對象必須先建立其外部類對象的緣由。

有人會問，若是內部類裏的一個成員變量與外部類的一個成員變量同名，也即外部類的同名成員變量被屏蔽了，怎麼辦？沒事，Java裏用以下格式表達外部類的引用：

outerClass.this

有了它，咱們就不怕這種屏蔽的狀況了。

靜態內部類

和普通的類同樣，內部類也能夠有靜態的。不過和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部的引用。這實際上和C++中的嵌套類很相像了，Java內部類與C++嵌套類最大的不一樣就在因而否有指向外部的引用這一點上，固然從設計的角度以及以它一些細節來說還有區別。

除此以外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套能夠不止一層）。不過靜態內部類中卻能夠擁有這一切。這也算是二者的第二個區別吧。

局部內部類

是的，Java內部類也能夠是局部的，它能夠定義在一個方法甚至一個代碼塊以內。

[java] view plain copy

public class Goods1 {
public Destination dest(String s) {
class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
return new GDestination(s);
}
public static void main(String[] args) {
Goods1 g = new Goods1();
Destination d = g.dest("Beijing");
}
}

上面就是這樣一個例子。在方法dest中咱們定義了一個內部類，最後由這個方法返回這個內部類的對象。若是咱們在用一個內部類的時候僅須要建立它的一個對象並創給外部，就能夠這樣作。固然，定義在方法中的內部類可使設計多樣化，用途毫不僅僅在這一點。

下面有一個更怪的例子：

[java] view plain copy

public class Goods2 {
private void internalTracking(boolean b) {
if (b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() {
return id;
}
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}
public void track() {
internalTracking(true);
}
public static void main(String[] args) {
Goods2 g = new Goods2();
g.track();
}
}

你不能在if以外建立這個內部類的對象，由於這已經超出了它的做用域。不過在編譯的時候，內部類TrackingSlip和其餘類同樣同時被編譯，只不過它由它本身的做用域，超出了這個範圍就無效，除此以外它和其餘內部類並無區別。

匿名內部類

java的匿名內部類的語法規則看上去有些古怪，不過如同匿名數組同樣，當你只須要建立一個類的對象並且用不上它的名字時，使用內部類可使代碼看上去簡潔清楚。它的語法規則是這樣的：

new interfacename(){......}; 或 new superclassname(){......};

下面接着前面繼續舉例子：

[java] view plain copy

public class Goods3 {
public Contents cont() {
return new Contents() {
private int i = 11;
public int value() {
return i;
}
};
}
}

這裏方法cont()使用匿名內部類直接返回了一個實現了接口Contents的類的對象，看上去的確十分簡潔。

在java的事件處理的匿名適配器中，匿名內部類被大量的使用。例如在想關閉窗口時加上這樣一句代碼：

[java] view plain copy

frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});

有一點須要注意的是，匿名內部類因爲沒有名字，因此它沒有構造函數（可是若是這個匿名內部類繼承了一個只含有帶參數構造函數的父類，建立它的時候必須帶上這些參數，並在實現的過程當中使用super關鍵字調用相應的內容）。若是你想要初始化它的成員變量，有下面幾種方法：

若是是在一個方法的匿名內部類，能夠利用這個方法傳進你想要的參數，不過記住，這些參數必須被聲明爲final。

將匿名內部類改形成有名字的局部內部類，這樣它就能夠擁有構造函數了。

在這個匿名內部類中使用初始化代碼塊。
內部類訪問局部變量問題：
方法中的內部類訪問方法中的局部變量是有前提的,必須加final修飾.
由於內部類對象的生命週期和方法中的局部變量是不同的，內部類對象存儲在堆內存中，
當對該對象的引用消失時，內部類對象纔會消亡。而方法的局部變量是存儲在棧內存中的，
當調用結束時就會彈棧消失。也就是說，內部類對象的生命週期超過了方法中局部變量
的生命週期，當內部類對象調用局部變量時,局部變量可能已經消亡了,是沒法調用的。
而在局部變量前加修飾符final ，局部變量就會做爲常量存在常量池中，生命周
期長於內部類對象，此時內部類就能夠訪問方法中的局部變量了

爲何須要內部類？

java內部類有什麼好處？爲何須要內部類？

首先舉一個簡單的例子，若是你想實現一個接口，可是這個接口中的一個方法和你構想的這個類中的一個方法的名稱，參數相同，你應該怎麼辦？這時候，你能夠建一個內部類實現這個接口。因爲內部類對外部類的全部內容都是可訪問的，因此這樣作能夠完成全部你直接實現這個接口的功能。

不過你可能要質疑，更改一下方法的不就好了嗎？

的確，以此做爲設計內部類的理由，實在沒有說服力。

真正的緣由是這樣的，java中的內部類和接口加在一塊兒，能夠的解決常被C++程序員抱怨java中存在的一個問題沒有多繼承。實際上，C++的多繼承設計起來很複雜，而java經過內部類加上接口，能夠很好的實現多繼承的效果。