您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 訊息 >> iOS 相關資訊

Thinking in Java 之內部類:概念、分類與繼承陷阱

編輯:iOS 相關資訊

前言

學 Java 已經有一段時間,最近我又回頭把基礎重新讀過一遍。這個階段的重點不再是語法細節,而是把當年讀得模糊、讀漏的概念整理清楚。剛好翻到內部類這一塊——以前用是會用,但心裡始終沒底,所以特別做一份總結。

一、什麼是內部類

所謂內部類,就是在外部類裡再定義一個類別,讓它作為成員依附於外部類而存在。使用上有個容易忽略的差別:內部類可以宣告為 static、protected、private,但外部類只能使用 public 或預設的套件存取權限。若寫成其他修飾符,編譯會直接報錯:

Illegal modifier for the class Outer; only public, abstract & final are permitted
package com.kiritor;

public class Outer {
    private String type;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    class Inner {
        private String type;

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }
    }
}

二、內部類的意義

乍看之下,內部類好像只是一種程式碼隱藏機制:把類別藏到另一個類別裡面。但它遠不只如此——內部類「認識」它的外部類,能與外部類進行必要的溝通,甚至存取外部類的 private 成員。這帶來三個實際價值:

1. 封裝。把不想讓外界知道的實作細節藏起來,只暴露需要的介面。

2. 存取外部類狀態。內部類可以讀寫建立它的那個外部類物件的內容,包含 private 變數,不必為了共用狀態而刻意放寬存取權限。

3. 變相達成多繼承。Java 不支援多重繼承,但內部類可以繼承一個基類、同時透過外部類再繼承另一個,於是「一個類別同時具備兩種父類行為」的效果就做得出來。寫法是用內部類分別繼承 Student 與 Employee,外部類持有這兩個內部類實例,再把對外的方法轉發出去:

public class Graduate {

    private Graduate_stu gaduate_stu = new Graduate_stu();
    private Graduate_emp graduate_emp = new Graduate_emp();

    private class Graduate_stu extends Student {
        public void getName() {
            // ... 學生身分的行為
        }
    }

    private class Graduate_emp extends Employee {
        public double getMoney() {
            return 0.0;
        }
    }

    public void getName() {
        gaduate_stu.getName();
    }

    public double getMoney() {
        return graduate_emp.getMoney();
    }
}

另外還有一個頗具吸引力的特性:內部類與外部類對介面的實作是「分離」的,彼此不互相干擾。現實中有時候你要實作某個介面,但該介面的方法名稱在這個類別裡已經被別的用途占用了。這時把介面實作放到內部類,就剛好能解掉命名衝突——因為內部類對外部類的成員是可存取的。

三、內部類的分類

依據「位置」與特性,內部類可以分成四類:

· 成員內部類(member inner class)
· 區域內部類(local inner class)
· 靜態內部類(nested class)
· 匿名內部類(anonymous inner class)

3.1 成員內部類

內部類作為外部類的一個成員存在,與方法、屬性並列。它有個關鍵限制:成員內部類裡不允許定義靜態成員。若內部類與外部類的變數同名,可以用 Outer.this 明確指向外部:

package com.kiritor;

public class Outer {
    private String type = "Outer Class";
    private static int flag = 1;

    public String getType() { return type; }
    public void setType(String type) { this.type = type; }

    @Override
    public String toString() {
        System.out.println("" + getType() + ":" + this.flag);
        Inner inner = new Inner();
        inner.toString();   // 外部類的非靜態方法造內部類物件
        return super.toString();
    }

    class Inner {
        private String type = "Inner Class";
        private int flag = 2;   // 成員內部類中不允許定義靜態成員

        public String toString() {
            System.out.println("" + getType() + ":" + this.flag);
            // 若有變數重名,透過這種方式存取外部類成員
            System.out.println("" + Outer.this.getType() + Outer.this.flag);
            return super.toString();
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.toString();

        Outer.Inner inner = outer.new Inner();  // 成員內部類必須綁定外部物件
        inner.toString();
    }
}

要記住的是:除非你手上已經有一個外部類物件,否則無法產生成員內部類物件。因為內部類物件會悄悄關聯到建立它的外部類物件。另外,內部類只是編譯期的概念——編譯完成後會產生 Outer.class 與 Outer$Inner.class 兩個完全獨立的位元碼檔。

3.2 區域內部類

定義在方法內部的類別稱為區域內部類。它和區域變數很像,因此不能加上存取修飾符(它不是外部類的成員),但可以存取該方法區塊內宣告為 final 的區域變數,以及外部類的所有成員。

package com.kiritor;

public class Outer {
    private String type = "Outer Class";
    private static int flag = 1;

    public String getType() { return type; }
    public void setType(String type) { this.type = type; }

    @Override
    public String toString() {
        System.out.println("" + getType() + ":" + this.flag);
        return super.toString();
    }

    public void innerInfo() {
        final String innerFinal = "可以存取方法內的常量";

        class Inner {
            private String type = "Inner Class";
            private int flag = 2;

            public String toString() {
                System.out.println("" + getType() + ":" + this.flag + innerFinal);
                System.out.println("" + Outer.this.getType() + Outer.this.flag);
                return super.toString();
            }
        }
        new Inner().toString();   // 區域內部類就在方法內直接 new
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.toString();
        outer.innerInfo();
    }
}

3.3 靜態內部類(嵌套類)

前面兩種可以類比成成員變數與區域變數。如果內部類不需要與外部類物件產生關聯,就把它宣告為 static。

這裡有個關鍵差異:普通的內部類物件隱含保存了一個外部類物件的參照;一旦加上 static,這個「特性」就消失了。結果是:

1. 建立靜態內部類物件時不需要外部類物件;
2. 靜態內部類無法直接存取外部類的非靜態成員。

package com.kiritor;

public class Outer {
    private String type = "Outer Class";
    private static int flag = 1;

    public String getType() { return type; }
    public void setType(String type) { this.type = type; }

    @Override
    public String toString() {
        System.out.println("" + getType() + ":" + this.flag);

        Inner.info();          // 外部類存取內部類的靜態成員:Inner.靜態成員
        Inner inner = new Inner();  // 不再需要透過外部類物件
        inner.toString();      // 存取非靜態成員則必須先 new 一個物件
        System.out.println(inner.type);
        return super.toString();
    }

    static class Inner {
        private String type = "Inner Class";
        private int flag = 2;
        private static String info = "Inner Class 2";
        // 靜態內部類中可以有非靜態的方法與屬性

        public String getType() { return type; }
        public void setType(String type) { this.type = type; }

        public static void info() {
            System.out.println(info);
        }

        public String toString() {
            System.out.println("" + getType() + ":" + this.flag);
            return super.toString();
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.toString();
    }
}

這也正好說明了靜態內部類與成員內部類在語法上的區別:前者寫 Outer.Inner in = new Outer.Inner();,後者必須寫 in = outer.new Inner();。

3.4 匿名內部類

顧名思義,就是沒有名字的類別。它在 GUI 開發裡特別常見,因為事件監聽器往往只需要用一次:

package com.kiritor;

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class MyFrame extends JFrame {

    private JButton button = null;

    public MyFrame() {
        this.setSize(200, 200);
        this.setVisible(true);

        button = new JButton("匿名內部類");
        button.addMouseListener(new MouseListener() {   // 一個匿名類

            @Override public void mouseReleased(MouseEvent e) { }
            @Override public void mousePressed(MouseEvent e)  { }
            @Override public void mouseExited(MouseEvent e)   { }
            @Override public void mouseEntered(MouseEvent e)  { }
            @Override public void mouseClicked(MouseEvent e)  { }
        });

        this.add(button);
    }
}

匿名內部類的限制是它只能繼承一個父類或實作一個介面,而且沒有建構子——因為它沒有名字可供呼叫。它的好處是把「只用一次的實作」就近寫在使用處,不必多開一個類別。

四、幾個有趣的問題

4.1 內部類能被「覆寫」嗎?

如果你建立了一個外部類並在其中定義內部類,接著繼承外部類、在子類裡再定義一個同名的內部類,會發生什麼事?

package com.kiritor;

class Outer {
    public Outer() {
        System.out.print("Outer:");
        new Inner();
    }

    class Inner {
        public Inner() {
            System.out.println("Inner");
        }
    }
}

public class Outer2 extends Outer {
    class Inner {
        public Inner() {
            System.out.println("outer2:Inner");
        }
    }

    public static void main(String[] args) {
        new Outer2();
    }
}

輸出是 Outer:Inner。子類預設的建構子由編譯器產生,會先呼叫父類建構子,而父類建構子裡 new 的是它自己的 Inner。也就是說,雖然建立的是子類物件,內部類並沒有被「覆寫」掉。結論是:當你繼承某個外部類時,內部類不會自動跟著改變,除非你明確地去繼承那個內部類。

若改成明確繼承:

public class Outer2 extends Outer {
    class Inner extends com.kiritor.Outer.Inner {
        public Inner() {
            System.out.println("outer2:Inner");
        }
    }

    public Outer2() {
        new Inner();
    }

    public static void main(String[] args) {
        new Outer2();
    }
}

這時才會看到子類的 Inner 被執行。

4.2 單獨繼承一個內部類

內部類的建構子需要外部類物件的參照,而在被繼承的子類裡並不存在這個參照——也就是說,單獨繼承內部類時,內部類與其外部類之間的那層關聯會斷掉。解法是在建構子中顯式傳入外部類物件,並用 outer.super() 把關聯補回來:

package com.kiritor;

class Outer {
    public Outer() {
        System.out.print("Outer:");
        new Inner();
    }

    class Inner {
        public Inner() {
            System.out.println("Inner");
        }
    }
}

public class Inner2 extends Outer.Inner {

    Inner2(Outer outer) {
        outer.super();   // 建構子只能是這種寫法
        System.out.println("只能為此種建構子");
    }

    public static void main(String[] args) {
        new Inner2(new Outer());
    }
}

輸出如下:

Outer:Inner
Inner
只能為此種建構子

可以看到 Inner2 雖然繼承了內部類,卻不能沿用預設建構子;而且光是傳一個外部類參照進來還不夠,必須先呼叫外部類的建構方法,才補得回內部類與外部類物件的關聯,編譯才能通過。

把這些規則記住的實際意義是:內部類適合用在「這個類別的實作本來就離不開外部類狀態」的場合;一旦你發現它其實可以獨立存在,宣告成 static 會讓設計更清楚,也少掉一層隱藏的參照。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved