一、只有非private方法才可以被覆盖。
public class PrivateOverride {
private void f() {
System.out.println("private f()");
}
public static void main(String[] args) {
PrivateOverride po = new Derived();//UpCasting
po.f();
}
}
class Derived extends PrivateOverride {
public void f() {
System.out.println("public f()");
}
} /* Output:
private f()
*/
在上面的程序中，导出类的f()是一个全新的方法，因为基类中的f()方法是private型的，在导出类中是不可见的，就更不能覆盖它了。
二、只有普通的方法调用可以是多态的。
即：如果直接访问某个域，这个访问就会在编译器进行解析。
class Super {
public int field = 0;
public int getField() { return field; }
}
class Sub extends Super {
public int field = 1;
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());
}
} /* Output:
sup.field = 0, sup.getField() = 1
sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0
*/
在上面的程序中，Super sup = new Sub();这句话对Sub对象转型为Super引用，sup.field访问的是Super类的field变量，而sup.getField()则访问的是Sup类的getField()方法。即：访问域没有表现多态，而访问普通的方法时表现了多态。
三、如果某个方法时静态的，它的行为就不具有多态性。
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()";
}
public String dynamicGet() {
return "Derived dynamicGet()";
}
}
public class StaticPolymorphism {
public static void main(String[] args) {
StaticSuper sup = new StaticSub(); // Upcast
System.out.println(sup.staticGet());
System.out.println(sup.dynamicGet());
}
} /* Output:
Base staticGet()
Derived dynamicGet()
*/
在上面的程序中，StaticSuper sup = new StaticSub();这行代码将StaticSub对象转型为StaticSuper引用，当调用sup,staticGet()方法时，由于是静态方法而不能表现多态，因此访问的是基类的方法。这种现象由静态方法是属于类的，与对象无关也可以很好的解释。
