java中重载方法与覆盖方法调用规则

问题：

代码如下：
class A {
public String show(D obj){
return ("A and D");
}
public String show(A obj){
return ("A and A");
}
}
class B extends A{
public String show(A obj){
return ("B and A");
}
public String show(B obj){
return ("B and B");
}
}
class C extends B{}
class D extends B{}

public class MultiTest{
public static void main(String[] args){
A ab = new B();
B b = new B();
C c = new C();
System.out.println(ab.show(b));
System.out.println(ab.show(c));
}
}

运行代码结果如下：
B and A
B and A

为什么不是

B and B
B and B

网友们给出的各种解答，挺好的

网友1、

A ab = new B();
这里ab的引用类型是A，但是它指向的内存是类型为B的一个实例

想对ab进行方法调用，你调用的方法都必须在 class A里面有的才行（因为你的引用类型为A）
这里 class A有show(A obj) show(D obj)着两个方法

ab.show(b) 在class A中没有找到类型匹配的方法，但是对b进行类型提升后，可以找到 show(A obj)方法，同理 ab.show(c)也是show(A obj)方法；但是ab内存地址指向一个类型为B内存空间，如果class B Override 了 class A的show(A obj)方法，则调用B的方法，反之，则调用A自己的方法

可以猜测  D d = new D()；  ab.show(d)的结果是 A and D
如果注释掉 class A的  show(A obj)方法， ab.show(b)  ab.show(c)都会出错。

这里你只要记住，能调用那些方法，由引用类型决定，具体执行情况，由实际内存对象类型决定

网友2、
Override 是多态，由运行时实际类决定，所以调用的是B类的方法而不是A类的方法。 
Overload 是由编译器在编译时决定的，因为 ab 的声明类型为 A，所以会调用 show(A obj) 方法，编译类型一致。

网友3、
Java 执行方法时，是动态匹配的，在运行时才会决定用哪个方法。A
ab = new B(); 你调用ab.show(b)时，会根据对象的类型A，去找方法，A中的show(A obj)匹配上，但是此方法在B中被覆盖了，所以会调用B中的show(A obj)。 
如果将代码改为：B ab = new B();，这个执行时：ab.show(b)会直接调用show(B obj)；ab.show(c)会将c向上转型一次，然后调用show(B obj)。 
这样的话最后的结果就会是： 
                 B and B 
                 B and B 
总结： 
    java执行方法时，会根据对象的类型得到相应的方法，如果不存在编译时会报错，真正执行时，会动态去匹配，如果真正的对象是子类的话，且此方法在子类中被覆盖的话，就会执行子类方法。 
    java类型匹配时，如果不能匹配的话就做向上类型转换，转换为父类，直到能够匹配为止，若一直不能匹配在编译时会报错。

网友4、
这个涉及到了java的多态中的向上转型，简单来说，父类引用生成子类对象，那这个引用只能调用在父类中已经定义过的属性和方法，而对子类自己新定义的属性和方法则不能访问。比如你这里的A ab=new B();,ab是一个父类引用，之后执行ab.show(b),这时ab先从父类中查找方法，与之匹配的只有show(A
obj)方法，而且发现子类重写了该方法，这时动态链接到子类的show(A obj)方法。 

假如你执行b.show(c),这里，b中有show(A obj)方法和show（B obj)方法，继承层次为C->B->A，根据重载的最近匹配原则，会调用show（B obj)方法。
总结：

覆盖方法调用先从父类查起，若此方法被子类覆盖，则调用子类的方法，直到查找到引用所指向的对象的这一层类。

重载如果涉及到参数为子类与父类的关系，若在这一层没有最匹配的则实行参数类型向上转型，转型后若子类覆盖了此方法，则调用子类的此方法，与上面覆盖的规则一样。

public static void main(String[] args) {
Stu1 s = new Stu2();
Stu2 s2 = new Stu2();
Stu3 s3 = new Stu3();
Stu4 s4 = new Stu4();
1 s.fun(s3);//2
2 s.fun(s4);//5
3 s.fun(s2);//5

}
}
class Stu1{
void fun(Stu1 o){
System.out.println("1");
}
void fun(Stu3 o){
System.out.println("2");
}
void fun(Stu2 o){
System.out.println("3");
}
}
class Stu2 extends Stu1{
void fun(Stu4 o){
System.out.println("4");
}
void fun(Stu2 o){
System.out.println("5");
}
}
class Stu3 extends Stu2{

}
class Stu4 extends Stu2{

}

输出的是2，5，5，可以看出1语句是直接调用父类中的对应方法（子类没有覆盖），2语句是在类Stu1中先找参数为s4的方法，没找到，然后找参数为s4最近父类的方法，找到了s2，但此方法被在子类中覆盖，所以调用子类的此方法，输出5.  3语句是找到类Stu1中的此方法，被子类覆盖，则调用子类的此方法，输出5.