覆盖私有方法
class Father {
private void f() { System.out.println("Father::f()"); }
public static void main(String[] args) {
Father father = new Son();
father.f(); //输出:Father::f()
}
}
class Son extends Father {
public void f() { System.out.println("Son::f()"); }
public static void main(String[] args) {
Son son = new Son();
son.f(); //输出:Son::f()
}
}上面例子中由于Father的f是私有的，所以在Father的main方法中对f的调用是静态绑定的。
如果把f定义为public的，则在Father中对f的调用将是动态绑定的。
域与静态方法
class Father {
public int i = 0;
public int get() { return i; }
}
class Son extends Father {
public int i = 1;
public int get() { return i; }
public int get_super() { return super.i; }
}
class Test {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.i); //0
System.out.println(f.get());//1
Son s = new Son();
System.out.println(s.i);//1
System.out.println(s.get());//1
System.out.println(s.get_super());//0
Son s1 = (Son)f;
System.out.println(s1.i);//1
System.out.println(s1.get());//1
System.out.println(s1.get_super());//0
}
}对于成员函数的访问是没有多态的，子类型和父类型中的i是不同的存储空间。使用父指针访问的时候使用的父的空间，使用子指针访问的时候使用的是子的空间。
在构造函数中调用的函数如果是可以动态绑定的，并且在子类中被继承了，那么就会调用子类的方法
class Father {
void draw() { System.out.println("Father::draw"); }
Father() { draw(); }
}
class Son extends Father {
int i = 1;
void draw() { System.out.println("Son::draw: " + i); }
}
class Test {
public static void main(String[] args) {
new Son(); //Son::draw: 0
}
}如果把Father中的draw定义为private的，那么在Test中的输出就是Father::draw