陷阱:”覆写“私有方法
package polymorphism;
public class PrivateOverride {
private void f() {
System.out.println("private f()");
}
public static void main(String[] args) {
PrivateOverride po = new Derived();
po.f();
}
}
public Derived extends PrivateOverride {
public void f() {
System.out.println("public f()");
}
}
>输出结果:
private f()
-
你可能期望输出是 public f(),然而 private 方法也是 final 的,对于派生类来说是隐蔽的。因此,这里 Derived 的 f() 是一个全新的方法;因为基类版本的 f() 屏蔽了 Derived ,因此它都不算是重载方法。
-
结论是只有非 private 方法才能被覆写,但是得小心覆写 private 方法的现象,编译器不报错,但不会按我们所预期的执行。为了清晰起见,派生类中的方法名采用与基类中 private 方法名不同的命名。
如果使用了 @Override 注解,就能检测出问题。
陷阱:属性与静态方法
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(); // Upcast
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, super.getField() = 1
sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0
-
当 Sub 对象向上转型为 Super 引用时,任何属性访问都被编译器解析,因此不是多态的。在这个例子中,Super.field 和 Sub.field 被分配了不同的存储空间,因此,Sub 实际上包含了两个称为 field 的属性:它自己的和来自 Super 的。然而,在引用 Sub 的 field 时,默认的 field 属性并不是 Super 版本的 field 属性。为了获取 Super 的 field 属性,需要显式地指明 super.field。
-
尽管这看起来是个令人困惑的问题,实际上基本不会发生。首先,通常会将所有的属性都指明为 private,因此不能直接访问它们,只能通过方法来访问。此外,你可能也不会给基类属性和派生类属性起相同的名字,这样做会令人困惑。
如果一个方法是静态(static)的,它的行为就不具有多态性:
class StaticSuper {
public static String staticGet() {
return "Base staticGet()";
}
public String dynamicGet() {
return "Base dynamicGet()";
}
}
class StaticSub extends StaticSuper {
public static String staticGet() {
return "Derived staticGet()";
}
@Override
public String dynamicGet() {
return "Derived dynamicGet()";
}
}
public class StaticPolymorphism {
public static void main(String[] args) {
StaticSuper sup = new StaticSub(); // Upcast
System.out.println(StaticSuper.staticGet());
System.out.println(sup.dynamicGet());
}
}
>输出结果:
Base staticGet()
Derived dynamicGet()
静态的方法只与类关联,与单个的对象无关。
构造器内部多态方法的行为
class Glyph {
void draw() {
System.out.println("Glyph.draw()");
}
Glyph() {
System.out.println("Glyph() before draw()");
// draw();
this.draw(); // 这里就算写了 this. 关于方法调用任然是按照子类类型
System.out.println("Glyph() after draw()");
}
}
class RoundGlyph extends Glyph {
private int radius = 1;
RoundGlyph(int r) {
radius = r;
System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
}
@Override
void draw() {
System.out.println("RoundGlyph.draw(), radius = " + radius);
}
}
public class PolyConstructors {
public static void main(String[] args) {
// new RoundGlyph(5); // 上下两句效果一样
Glyph rg = new RoundGlyph(5);
}
}
>输出结果:
Glyph() before draw()
RoundGlyph.draw(), radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 5
初始化的实际过程是:
- 在所有事发生前,分配给对象的存储空间会被初始化为二进制 0。
- 如前所述调用基类构造器。此时调用覆写后的 draw() 方法(是的,在调用 RoundGraph 构造器之前调用),由步骤 1 可知,radius 的值为 0。
- 按声明顺序初始化成员。
- 最终调用派生类的构造器。
原文地址:https://lingcoder.gitee.io/onjava8/#/book/09-Polymorphism?id=%e7%ac%ac%e4%b9%9d%e7%ab%a0-%e5%a4%9a%e6%80%81