從Java1.1開始引入了內部類以來,它就引起了人們的激烈爭論。其實任何優秀的語言特性用得不好就是濫用,內部類用得不好就會導致代碼像迷宮一樣,導致出現毫無重用的綜合徵。
1、內部類分爲成員內部類、靜態嵌套類、方法內部類、匿名內部類。
幾種內部類的共性:
A、內部類仍然是一個獨立的類,在編譯之後會內部類會被編譯成獨立的.class文件,但是前面冠以外部類的類命和$符號。
B、內部類不能用普通的方式訪問。內部類是外部類的一個成員,因此內部類可以自由地訪問外部類的成員變量,無論是否是private的。
2、成員內部類:形式如下
class Outer { class Inner{} }
編譯上述代碼會產生兩個文件:Outer.class和Outer$Inner.class。
成員內部類內不允許有任何靜態聲明!下面代碼不能通過編譯。
class Inner{ static int a = 10; }
能夠訪問成員內部類的唯一途徑就是通過外部類的對象!
A、從外部類的非靜態方法中實例化內部類對象。
class Outer { private int i = 10; public void makeInner(){ Inner in = new Inner(); in.seeOuter(); } class Inner{ public void seeOuter(){ System.out.print(i); } } }
表面上,我們並沒有創建外部類的對象就實例化了內部類對象,和上面的話矛盾。事實上,如果不創建外部類對象也就不可能調用makeInner()方法,所以到頭來還是要創建外部類對象的。 你可能試圖把makeInner()方法修飾爲靜態方法,即static public void makeInner()。這樣不創建外部類就可以實例化外部類了!但是在一個靜態方法裏能訪問非靜態成員和方法嗎?顯然不能。它沒有this引用。沒能跳出那條規則!但是如果在這個靜態方法中實例化一個外部類對象,再用這個對象實例化外部類呢?完全可以!也就是下一條的內容。
B、從外部類的靜態方法中實例化內部類對象。
class Outer { private int i = 10; class Inner{ public void seeOuter(){ System.out.print(i); } } public static void main(String[] args) { Outer out = new Outer(); Outer.Inner in = out.new Inner(); //Outer.Inner in = new Outer().new Inner(); in.seeOuter(); } }
被註釋掉的那行是它上面兩行的合併形式,一條簡潔的語句。
對比一下:在外部類的非靜態方法中實例化內部類對象是普通的new方式:Inner in = new Inner();
在外部類的靜態方法中實例化內部類對象,必須先創建外部類對象:
Outer.Inner in = new Outer().new Inner();
C、內部類的this引用。
普通的類可以用this引用當前的對象,內部類也是如此。但是假若內部類想引用外部類當前的對象呢?用“外部類名”.this;的形式,如下例的 Outer.this。
class Outer { class Inner{ public void seeOuter(){ System.out.println(this); System.out.println(Outer.this); } } }
D、成員內部類的修飾符。
對於普通的類,可用的修飾符有final、abstract、strictfp、public和默認的包訪問。
但是成員內部類更像一個成員變量和方法。
可用的修飾符有:final、abstract、public、private、protected、strictfp和static。 一旦用static修飾內部類,它就變成靜態內部類了。
3、方法內部類。
顧名思義,把類放在方法內。
class Outer { public void doSomething(){ class Inner{ public void seeOuter(){ } } } }
A、方法內部類只能在定義該內部類的方法內實例化,不可以在此方法外對其實例化。
B、方法內部類對象不能使用該內部類所在方法的非final局部變量。
因爲方法的局部變量位於棧上,只存在於該方法的生命期內。當一個方法結束,其棧結構被刪除,局部變量成爲歷史。但是該方法結束之後,在方法內創建的內部類對象可能仍然存在於堆中!例如,如果對它的引用被傳遞到其他某些代碼,並存儲在一個成員變量內。正因爲不能保證局部變量的存活期和方法內部類對象的一樣長,所以內部類對象不能使用它們。
下面是完整的例子:
class Outer { public void doSomething(){ final int a =10;class Inner{ public void seeOuter(){ System.out.println(a); } } Inner in = new Inner(); in.seeOuter(); } public static void main(String[] args) { Outer out = new Outer(); out.doSomething(); } }
C、方法內部類的修飾符。
與成員內部類不同,方法內部類更像一個局部變量。 可以用於修飾方法內部類的只有final和abstract。
D、靜態方法內的方法內部類。
靜態方法是沒有this引用的,因此在靜態方法內的內部類遭受同樣的待遇,即:只能訪問外部類的靜態成員。
4、匿名內部類。
顧名思義,沒有名字的內部類。表面上看起來它們似乎有名字,實際那不是它們的名字。
A、繼承式的匿名內部類。
class Car { public void drive(){ System.out.println("Driving a car!"); } } class Test{ public static void main(String[] args) { Car car = new Car(){ public void drive(){ System.out.println("Driving another car!"); } }; car.drive(); } }
結果輸出了:Driving another car! Car引用變量不是引用Car對象,而是Car匿名子類的對象。
建立匿名內部類的關鍵點是重寫父類的一個或多個方法。再強調一下,是重寫父類的方法,而不是創建新的方法。因爲用父類的引用不可能調用父類本身沒有的方法!創建新的方法是多餘的。簡言之,參考多態。
B、接口式的匿名內部類。
interface Vehicle { public void drive(); } class Test{ public static void main(String[] args) { Vehicle v = new Vehicle(){ public void drive(){ System.out.println("Driving a car!"); } }; v.drive(); } }
上面的代碼很怪,好像是在實例化一個接口。事實並非如此,接口式的匿名內部類是實現了一個接口的匿名類。而且只能實現一個接口。
C、參數式的匿名內部類。
class Bar{ void doStuff(Foo f){} } interface Foo{ void foo(); } class Test{ static void go(){ Bar b = new Bar(); b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); } }); } }
5、靜態嵌套類。
從技術上講,靜態嵌套類不屬於內部類。因爲內部類與外部類共享一種特殊關係,更確切地說是對實例的共享關係。而靜態嵌套類則沒有上述關係。它只是位置在另一個類的內部,因此也被稱爲頂級嵌套類。 靜態的含義是該內部類可以像其他靜態成員一樣,沒有外部類對象時,也能夠訪問它。靜態嵌套類不能訪問外部類的成員和方法。
class Outer{ static class Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }