四種“缺陷”

• 私有方法
• 類的屬性
• 靜態方法
• 構造器和多型

私有方法

程式碼：

public class PrivateOverride {
    private void f() {
        System.out.println("private f()");
    }

    public static void main(String[] args) {
        PrivateOverride po = new Derived();
        po.f();
    }
}

class Derived extends PrivateOverride {
    public void f() {
        System.out.println("public f()");
    }
}
 

輸出結果：

private f()

總結：
只有非 private 方法才可以被覆蓋，因此在匯出類中，對於基類的中的 private 方法，最好採用不同的名字。

類的屬性

程式碼：

class Super {
    public int field = 0;

    public int getField() {
        return field;
    }
}

class Sub extends Super {
    public int field = 1;

    @Override
    public int getField() {
        return field;
    }
    public int getSuperField() {
        return super.field;
    }
}

public class FieldAccess {
    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println("sup.field = " + sup.field + ", sup.getField() = " + sup.getField());
        Sub sub = new Sub();
        System.out.println("sub.field = " + sub.field + ", sub.getField() = " + sub.getField() + ", sub.getSuperField() = " + sub.getSuperField());
    }
}
 

輸出結果：

sup.field = 0, sup.getField() = 1
sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0

總結：
當進行向上轉型時，任何訪問類的屬性操作都是由編譯器解析，因此不是多型。因此，我們一般建議把類的屬性設定為 private，然後通過方法來訪問屬性值，這樣就避免來因為多型而帶來的屬性取值問題。

靜態方法

程式碼：

class StaticSuper {
    public static String staticGet() {
        return "base staticGet()";
    }

    public String get() {
        return "base get()";
    }
}

class StaticSub extends StaticSuper {
    public static String staticGet() {
        return "sub staticGet()";
    }

    @Override
    public String get() {
        return "sub get()";
    }
}

public class StaticAccess {
    public static void main(String[] args) {
        StaticSuper ss = new StaticSub();
        System.out.println(ss.staticGet());
        System.out.println(ss.get());
    }
}
 

輸出結果：

base staticGet()
sub get()

總結：
靜態方法不具有多型行為。

構造器和多型

程式碼：

class Glyph {
    public Glyph() {
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }

    void draw() {
        System.out.println("Glyph.draw()");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;

    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph(i).radius = " + radius);
    }

    void draw() {
        System.out.println("RoundGlyph.draw(), radius = " + radius);
    }
}

public class PolyConstructor {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}

輸出結果：

Glyph() before draw()
RoundGlyph.draw(), radius = 0
Glyph() after draw()
RoundGlyph(i).radius = 5

總結
基類構造器裡面的 draw() 方法實際執行的是子類裡面的，這就導致子類的屬性沒有被正確初始化，因此我們一定要避免這種寫法。