一个小例子理解多态 - 修改 0 次

1、Java 多态机制

多态机制遵循的原则概括为：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

通俗的解释：当超类对象引用变量引用子类对象时，如果想用到子类里的方法，这个方法必须在父类里也有，也就是必须是子类重写的方法。如果这个方法只有子类有，而父类没有，则必须遵循这样的优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。当超类对象引用变量引用子类对象时，就意味着子类放弃了使用自己独有的方法的权利。

---

举个例子：

package test;

//父类 A
class A {
    public String show(D obj) {
        return ("A and D");
    }

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

}

// 子类 B
class B extends A {
    public String show(B obj) {
        return ("B and B");
    }

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

// 继承类 B 的子类 C
class C extends B {

}

// 继承类 B 的子类 D
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));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a2.show(b));
        System.out.println("4--" + a2.show(d));
        System.out.println("5--" + b.show(b));
        System.out.println("6--" + b.show(c));
        System.out.println("7--" + b.show(d));
    }
}

运行结果：

1--A and A
2--A and A
3--B and A
4--A and D
5--B and B
6--B and B
7--A and D

也许输出结果和您想的不同，我们来分析一下：
父类 A 有方法 show(d) 和 show(a),子类 B 有方法 show(b) 和 show(a),也就是说子类 B 只重写了方法show(a)，而没有重写方法 show(d)，并且，方法 show(b) 是子类 B 独有的方法。

1. a1.show(b)，a1 没有 show(b) 方法 – > 开始寻找 super.show(b)，由于 a1 没有父类 –> 开始寻找 this.show((super)b)，由于 b 有父类 a，所以执行 a1.show(a)，输出 A and A。
2. a1.show(c)，与 1 同理。
3. a2.show(b)，这个比较关键，a2 是引用变量，为 A 类型，它引用的是 B 对象，因此按照上面那句话的意思是说由 B 来决定调用谁的方法,所以 a2.show(b) 应该要调用 B 中的 show(B obj)，结果应该是“B and B”，但为什么没有这样呢，因为方法 show(b) 是子类 B 独有的方法，不是重写父类的，所以不能使用 –> 开始寻找 super.show(b)，由于 a1 没有父类–> 开始寻找 this.show((super)b），由于 b 有父类 a，并且 b 重写了 a 的 show(a) 方法，所以执行 b. show(a)，输出 B and A。
4. a2.show(d)，b 没有重写好的方法 show(d) –> a.show(d)，输出 A and D。
5. b.show(b)，毫无疑问。
6. b.show(c)，b 没有方法 show(c) –> ,c 有父类 b，使用 b.show(b)，输出 B and B。
7. b.show(d)，b 没有方法 show(d)，巴特，b 的父类 a 有，所以使用 a.show(d)，输出 A and D，我们都知道，子类使用父类的方法是理所当然的。