A a1 = new A(); A a2 = new B(); B b = new B(); C c = new C();

public class A {
	//方法重载
	public String show(D obj) {
		return "A&D";
	}
	public String show(A obj) {
		return "A&A";
	}

}

public class B extends A {
	public String show(B obj) {
		return "B&B";
	}

	public String show(A obj) {
		return "B&A";
	}

}

public class C extends B{

}

public class D extends B{

}

<pre name="code" class="java">public class MainDemo {
	public static void main(String[] args) {
		A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();  
        
        System.out.println(a1.show(b));  //1
        System.out.println(a1.show(c));
        System.out.println(a1.show(d));  //3
        System.out.println(a2.show(a1)); //B中方法A参数类型
        System.out.println(a2.show(b));  //5
        System.out.println(a2.show(c));  //6
        System.out.println(a2.show(d));  //7
        System.out.println(b.show(b));
        System.out.println(b.show(d));
        System.out.println(b.show(c));
	}
}

如图，求打印的结果。

父类A应用多态进行重载，B,C,D都为子类。

对于第一条打印，a1为类A的对象，调用A中的方法，因为没有B类作为参数，故以参数类型为A的方法优先调用，打印结果是A&A;

对于第二条打印，a1为类A的对象，调用A中的方法，因为没有C类作为参数，故以参数类型为A的方法优先调用，打印结果是A&A;

对于第三条打印，a1为类A的对象，调用A中的方法，有D类作为参数的方法，故调用以参数类型为D的方法，打印结果是A&D;

对于第五条打印，父类引用指向子类对象，首先查找B类中以A作为参数的方法，有以A作为参数的方法，故调用B类中的此方法，打印结果是：B&A；

对于第六条打印，父类引用指向子类对象，首先查找B类的子类C类中以C作为参数的方法，没有，则看C类父类B类中以C作为参数类型的，也没有，则优先调用以A作为参数的方法；

对于第七条打印，父类引用指向子类对象，首先查找B类中以D作为参数类型的方法，没有(子类中没有重写父类中的方法，需要到父类中去找)，则查看父类A中以D作为参数类型的方法，A类中有，则调用，打印结果是A&D；

对于最后一条打印，b为B的对象，而b.show(c)传递的是C类的对象参数类型，子类C中没有重写父类，则到父类B中查看，也没有以C类作为参数的，则以父类的参数为准，调用类型为B的方法，打印结果是B&B

其它类似处理。。