Java 多态的“缺陷”

私有方法

代码：

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() 方法实际执行的是子类里面的，这就导致子类的属性没有被正确初始化，因此我们一定要避免这种写法。