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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值