方法和作用域中的內部類

2019-11-18 12:08:20

字體：大中小

來源：轉載

供稿：網友

　　至此，我們已基本理解了內部類的典型用途。對那些涉及內部類的代碼，通常表達的都是“單純”的內部類，非常簡單，且極易理解。然而，內部類的設計非常全面，不可避免地會碰到它們的其他大量用法——假若我們在一個方法甚至一個任意的作用域內創建內部類。有兩方面的原因促使我們這樣做：
　　
　　(1) 正如前面展示的那樣，我們預備實現某種形式的接口，使自己能創建和返回一個句柄。
　　
　　(2) 要解決一個復雜的問題，并希望創建一個類，用來輔助自己的程序方案。同時不愿意把它公開。
　　
　　在下面這個例子里，將修改前面的代碼，以便使用：
　　
　　(1) 在一個方法內定義的類
　　
　　(2) 在方法的一個作用域內定義的類
　　
　　(3) 一個匿名類，用于實現一個接口
　　
　　(4) 一個匿名類，用于擴展擁有非默認構建器的一個類
　　
　　(5) 一個匿名類，用于執行字段初始化
　　
　　(6) 一個匿名類，通過實例初始化進行構建（匿名內部類不可擁有構建器）
　　
　　所有這些都在innerscopes包內發生。首先，來自前述代碼的通用接口會在它們自己的文件里獲得定義，使它們能在所有的例子里使用：
　　
　　//: Destination.java
　　package c07.innerscopes;
　　
　　interface Destination {
　　　String readLabel();
　　} ///:~
　　
　　由于我們已認為Contents可能是一個抽象類，所以可采取下面這種更自然的形式，就象一個接口那樣：
　　
　　//: Contents.java
　　package c07.innerscopes;
　　
　　interface Contents {
　　　int value();
　　} ///:~
　　
　　盡管是含有具體實施細節的一個普通類，但Wrapping也作為它所有衍生類的一個通用“接口”使用：
　　
　　//: Wrapping.java
　　package c07.innerscopes;
　　
　　public class Wrapping {
　　　PRivate int i;
　　　public Wrapping(int x) { i = x; }
　　　public int value() { return i; }
　　} ///:~
　　
　　在上面的代碼中，我們注重到Wrapping有一個要求使用自變量的構建器，這就使情況變得更加有趣了。
　　
　　第一個例子展示了如何在一個方法的作用域（而不是另一個類的作用域）中創建一個完整的類：
　　
　　//: Parcel4.java
　　// Nesting a class within a method
　　package c07.innerscopes;
　　
　　public class Parcel4 {
　　　public Destination dest(String s) {
　　　　class PDestination
　　　　　　implements Destination {
　　　　　private String label;
　　　　　private PDestination(String whereTo) {
　　　　　　label = whereTo;
　　　　　}
　　　　　public String readLabel() { return label; }
　　　　}
　　　　return new PDestination(s);
　　　}
　　　public static void main(String[] args) {
　　　　Parcel4 p = new Parcel4();
　　　　Destination d = p.dest("Tanzania");
　　　}
　　} ///:~
　　
　　PDestination類屬于dest()的一部分，而不是Parcel4的一部分（同時注重可為相同目錄內每個類內部的一個內部類使用類標識符PDestination，這樣做不會發生命名的沖突）。因此，PDestination不可從dest()的外部訪問。請注重在返回語句中發生的上溯造型——除了指向基礎類Destination的一個句柄之外，沒有任何東西超出dest()的邊界之外。當然，不能由于類PDestination的名字置于dest()內部，就認為在dest()返回之后PDestination不是一個有效的對象。
　　
　　下面這個例子展示了如何在任意作用域內嵌套一個內部類：
　　
　　//: Parcel5.java
　　// Nesting a class within a scope
　　package c07.innerscopes;
　　
　　public class Parcel5 {
　　　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();
　　　　}
　　　　// Can't use it here! Out of scope:
　　　　//! TrackingSlip ts = new TrackingSlip("x");
　　　}
　　　public void track() { internalTracking(true); }
　　　public static void main(String[] args) {
　　　　Parcel5 p = new Parcel5();
　　　　p.track();
　　　}
　　} ///:~
　　
　　TrackingSlip類嵌套于一個if語句的作用域內。這并不意味著類是有條件創建的——它會隨同其他所有東西得到編譯。然而，在定義它的那個作用域之外，它是不可使用的。除這些以外，它看起來和一個普通類并沒有什么區別。
　　
　　下面這個例子看起來有些希奇：
　　
　　//: Parcel6.java
　　// A method that returns an anonymous inner class
　　package c07.innerscopes;
　　
　　public class Parcel6 {
　　　public Contents cont() {
　　　　return new Contents() {
　　　　　private int i = 11;
　　　　　public int value() { return i; }
　　　　}; // Semicolon required in this case
　　　}
　　　public static void main(String[] args) {
　　　　Parcel6 p = new Parcel6();
　　　　Contents c = p.cont();
　　　}
　　} ///:~
　　
　　cont()方法同時合并了返回值的創建代碼，以及用于表示那個返回值的類。除此以外，這個類是匿名的——它沒有名字。而且看起來似乎更讓人摸不著頭腦的是，我們預備創建一個Contents對象：
　　
　　return new Contents()
　　
　　但在這之后，在碰到分號之前，我們又說：“等一等，讓我先在一個類定義里再耍一下花招”：
　　
　　return new Contents() {
　　private int i = 11;
　　public int value() { return i; }
　　};
　　
　　這種希奇的語法要表達的意思是：“創建從Contents衍生出來的匿名類的一個對象”。由new表達式返回的句柄會自動上溯造型成一個Contents句柄。匿名內部類的語法其實要表達的是：
　　
　　class MyContents extends Contents {
　　private int i = 11;
　　public int value() { return i; }
　　}
　　return new MyContents();
　　
　　在匿名內部類中，Contents是用一個默認構建器創建的。下面這段代碼展示了基礎類需要含有自變量的一個構建器時做的事情：
　　
　　//: Parcel7.java
　　// An anonymous inner class that calls the
　　// base-class constrUCtor
　　package c07.innerscopes;
　　
　　public class Parcel7 {
　　　public Wrapping wrap(int x) {
　　　　// Base constructor call:
　　　　return new Wrapping(x) {
　　　　　public int value() {
　　　　　　return super.value() * 47;
　　　　　}
　　　　}; // Semicolon required
　　　}
　　　public static void main(String[] args) {
　　　　Parcel7 p = new Parcel7();
　　　　Wrapping w = p.wrap(10);
　　　}
　　} ///:~
　　
　　也就是說，我們將適當的自變量簡單地傳遞給基礎類構建器，在這兒表現為在“new Wrapping(x)”中傳遞x。匿名類不能擁有一個構建器，這和在調用super()時的常規做法不同。
　　
　　在前述的兩個例子中，分號并不標志著類主體的結束（和C++不同）。相反，它標志著用于包含匿名類的那個表達式的結束。因此，它完全等價于在其他任何地方使用分號。
　　
　　若想對匿名內部類的一個對象進行某種形式的初始化，此時會出現什么情況呢？由于它是匿名的，沒有名字賦給構建器，所以我們不能擁有一個構建器。然而，我們可在定義自己的字段時進行初始化：
　　
　　//: Parcel8.java
　　// An anonymous inner class that performs
　　// initialization. A briefer version
　　// of Parcel5.java.
　　package c07.innerscopes;
　　
　　public class Parcel8 {
　　　// Argument must be final to use inside
　　　// anonymous inner class:
　　　public Destination dest(final String dest) {
　　　　return new Destination() {
　　　　　private String label = dest;
　　　　　public String readLabel() { return label; }
　　　　};
　　　}
　　　public static void main(String[] args) {
　　　　Parcel8 p = new Parcel8();
　　　　Destination d = p.dest("Tanzania");
　　　}
　　} ///:~
　　
　　若試圖定義一個匿名內部類，并想使用在匿名內部類外部定義的一個對象，則編譯器要求外部對象為final屬性。這正是我們將dest()的自變量設為final的原因。假如忘記這樣做，就會得到一條編譯期出錯提示。
　　
　　只要自己只是想分配一個字段，上述方法就肯定可行。但假如需要采取一些類似于構建器的行動，又應怎樣操作呢？通過Java 1.1的實例初始化，我們可以有效地為一個匿名內部類創建一個構建器：
　　
　　//: Parcel9.java
　　// Using "instance initialization" to perform
　　// construction on an anonymous inner class
　　package c07.innerscopes;

上一篇：鏈接到外部類

下一篇：引用外部類對象