java多态小记

例1：

package my.ex1;

/**
 * 基类
 * @author henry
 *
 */
public class Base {
	public void print() {
		System.out.println("Base output");
	}
	
	public void show() {
		print();
	}
}


package my.ex1;

/**
 * 子类
 * @author henry
 *
 */
public class Child extends Base {
		public void print() {
			System.out.println("Child output");
		}
}


package my.ex1;

/**
 * 测试类
 * @author henry
 *
 */
public class Hello {
	public static void main(String[] args) {
		Base obj = new Child();
		obj.show();
	}
}

输出结果为：

Child output

原因：

obj实际是Child对象，由于Child继承自Base, 当obj调用show()方法时，由于子类Child没有重载show()方法，因此调用的是继承而来的show()方法；
但show()内部调用了print()方法，实际可以理解为this.print()，这里的this指的是Child类的对象obj，因此调用的是Child重载过的print()方法，输出结果为Child output。

例2：

package my.ex2;

/**
 * 父类
 * @author henry
 *
 */
public class Father {
    private void f() {
        System.out.println("Father output");
    }
    
    public static void main(String[] args) {
        Father name = new Son();
        name.f();
    }
}


package my.ex2;

/**
 * 子类
 * @author henry
 *
 */
public class Son extends Father {
	public void f() {
		System.out.println("Son output");
	}
}

输出结果为：

Father output

原因：

在Father类的main方法里，定义了一个Son对象赋值给Father类引用name, 我们所期望的输出是public f().但是由于private方法被自动认为是final方法，而且对子类Son是屏蔽的。因此，在这种情况下，Son类中的f()方法就是一个全新的方法；既然父类中的f()方法在子类Son中不可见，因此甚至也不能重载。

结论就是：只有非private方法才可以被覆盖，但是还需要密切注意覆盖private方法的现象，这时虽然编译器不会报错，但是也不会按照我们所期望的来执行。确切的说，在子类中，对于父类中的private方法，最好采用不同的名字。

例3：

package my.ex3;

/**
 * 父类
 * @author henry
 */
public class Super {
	public int field = 1;
	public int getField() {
		return field;
	}
}
package my.ex3;

/**
 * 子类
 * @author henry
 */
public class Sub extends Super {
	public int field = 0;
	public int getField() {
		return field;
	}
}
package my.ex3;

/**
 * 客户端类
 * @author henry
 */
public class Client {
	public static void main(String[] args) {
		Super obj = new Sub();
		System.out.println("obj.field=" + obj.field + ";field=" + obj.getField());
	}
}

输出结果：

obj.field=1;field=0

原因：

当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的。在本例中，为Super.field和Sub.field分配了不同的存储空间。这样，Sub实际上包含两个称为field的域：它自己的和它从Super处得到的。然而，在引用Sub中的field时所产生的默认域并非Super版本的field域，因此obj.getField()得到的值，是Sub中的field值，即0。

例4：

package my.ex4;

public class StaticSuper {
	public static int staticGet() {
		return 1;
	}
	public int dynamicGet() {
		return 10;
	}
}
package my.ex4;

public class StaticSub extends StaticSuper {
	public static int staticGet() {
		return 0;
	}
	public int dynamicGet() {
		return 9;
	}
}
package my.ex4;

public class StaticTest {
	public static void main(String[] args) {
		StaticSuper obj = new StaticSub();
		System.out.println(obj.staticGet());
		System.out.println(obj.dynamicGet());
	}
}

输出结果：

1
9

原因：

静态方法是与类关联的，如果某个方法是静态的，那它的行为就不具有多态性。因此StaticSuper的引用obj所获取到的staticGet()方法，是StaticSuper类中的staticGet()方法，输出结果即为1。而非静态方法才具有多态性，找到了StaticSub的dynamicGet()方法，输出了9.