有关多态的疑问,后面有注释的两个输出不理解

Question

package test;
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(B obj){//overloading
    return ("B and B");
}

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

}
class C extends B{

}
class D extends B{

}
public class Test {

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("1--" + a1.show(b));    // 1-- A and A  
    System.out.println("2--" + a1.show(c));    // 2-- A and A
    System.out.println("3--" + a1.show(d));    // 3-- A and D
    System.out.println("4--" + a2.show(b));    // 4-- B and A
    System.out.println("5--" + a2.show(c));    // 5-- B and A
    System.out.println("6--" + a2.show(d));    // 6-- B and A 实际为A and D
    System.out.println("7--" + b.show(b));     // 7-- B and B
    System.out.println("8--" + b.show(c));     // 8-- B and B
    System.out.println("9--" + b.show(d));     // 9-- B and B 实际为 A and D  
}

}

Answer 1

其实吧这个问题就是涉及的知识点有好几个：

1. 继承

2. 方法的重写

3. 方法的继承

4. 向上转型和向下转型

解释下向上转型和向下转型

向上转型就是 儿子有爸爸的特性，要变成爸爸
向下转型就是 爸爸要变成儿子，有可能不成功
为啥呢？
拿下面的代码来说吧

    public class Father{
    
        public void work(){}
    
    }
    public class Son extends Father{
        
        public void song(){}
    }
    public static woid main(String[] args){
        Father fa=new Son();//new了一个傻儿子向上转型成功
        fa.work()；//函数调用正常
        Son s1=(Son)fa;//向上转型
        s1.song();//调用函数正常为啥呢？因为fa他的本身就是Son类型啊
        Father fa1=new Father()
        Son s2=(Son)fa1;//编译报错为啥？爸爸又不会唱歌，凑什么热闹？乱搞报错啦
    }

先来看下题目中的类与类的继承关系吧

画的不好看哈，手动滑稽一下
请看A作为老大，他是所有人的祖先。
依次往下继承啦。
而在ABCD他们所拥有的方法是一下这几个

解释一下这几个问题哈
1.B中的为啥有三个方法，这三个方法是怎么来的？

show(A a)是B对A的方法进行**重写**了
show(B b)是B自己独有的
show(D d)是A中继承过来的

这就可以解释

    System.out.println("1--" + a1.show(b));    // 1-- A and A  
    System.out.println("2--" + a1.show(c));    // 2-- A and A
    System.out.println("3--" + a1.show(d));    // 3-- A and D
    System.out.println("4--" + a2.show(b));    // 4-- B and A
    System.out.println("5--" + a2.show(c));    // 5-- B and A

这六个输出啦
1-2.不说啦，懂一点的都知道啦，向上转型肯定调用的A中的方法啦show(A a)
3.我show(D d)方法为啥不调用啊？
4-5. 我本来是想调用A的show(A a)方法的，该方法被B重写了，没办法了，只能调用被重写的方法啦所以调用的是b中重写后的show(B b)，气死啦！！！

    System.out.println("7--" + b.show(b));     // 7-- B and B
    System.out.println("8--" + b.show(c));     // 8-- B and B

7-8. 我就是b创建出来的，而且我的b.xxx中的b的类型也是B这个类型，我就必须匹配最好的方法所以调用了show(B b);这个方法啦

 System.out.println("6--" + a2.show(d));    // 6-- B and A 实际为A and D
 System.out.println("9--" + b.show(d));     // 9-- B and B 实际为 A and D 

6.是因为我在a2被向上转型啦，我只能调用A中的方法哦，所以苦逼的只能调用a中的show(D d)
9.b这个类的类型就是B,但是B中其实有三个方法show(A a),show(B b)show(D d),我肯定找最适合我的方法啦，所以呢show(D d)方法去啦