面对对象之多态（Java）

多态的概念

多态是指当系统A访问B的服务时，系统B可以通过多种实现方式来提供服务，而这一切对于系统A是透明的。其实就是同一操作作用于不同的对象，不同的对象有不同的解释，从而产生不同的结果。

静态绑定与动态绑定

了解多态，就必须了解动态绑定的概念，因为多态就是通过动态绑定实现的，没有动态绑定就没有多态。

方法绑定：将一个方法的调用同一个方法主体关联起来。

在Java中存在两种绑定方式：静态绑定与动态绑定

• 静态绑定（前期绑定）发生在编译期间，在程序执行前进行绑定。

• 动态绑定（也称后期绑定、运行时绑定）指在运行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

Java中，动态绑定是默认的，除了static方法和final方法之外，其他所有的方法都是动态绑定的。

存在多态的必要条件

1. 要有继承。
2. 继承后，子类要覆盖（重写）父类的方法。
3. 父类引用指向子类对象，也就是向上转型。

多态的作用

多态消除了类型之间的耦合关系，能够改善代码的组织结构和创建可扩展的程序。
通过多态，我们可以只与父类通信，然后从父类中继承出不同的子类，把不同的子类对象都当作父类来看，从而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

例子

public class A {
     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--" + a1.show(d));
            System.out.println("4--" + a2.show(b));
            System.out.println("5--" + a2.show(c));
            System.out.println("6--" + a2.show(d));
            System.out.println("7--" + b.show(b));
            System.out.println("8--" + b.show(c));
            System.out.println("9--" + b.show(d));      
        }

    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){
        return ("B and B");
    }

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

 class C extends B{

}

 class D extends B{

}

运行结果：

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

分析：

1. 引用a1指向了A的实例，调用了类A中的Show()方法，由于类A中并没有方法是接收类型B的参数，这里进行了向上转型，于是匹配了show(A obj)方法，输出1–A and A。

2. 与1类似。

3. 引用a1指向了A的实例，传入了类型D的参数，匹配了类A中的show(D obj)方法，输出3–A and D。

4. 引用a2的类型为类型A。类A中没有接收类型B的参数的Show()方法，于是参数b进行了向上转型，匹配了show(A obj)方法，但是运行时发现引用a2指向的是类型B的实例，而类B中又重写了show(A obj)方法，于是调用的是类B中的show(A obj)方法，输出4–B and A。

5. 与4类似。

6. 引用a2的类型为类型A，类A中有show(D obj)，输出5–B and A。

7. 引用b的类型为类B，而且指向类B的实例，B类型的参数直接匹配show(B obj)方法，输出7–B and B。

8. 类B中并没有接收参数类型为类C的方法，c向上转型为类型B，此时发现匹配了show(B obj)方法，输出8–B and B。

9. 类B继承与类A，于是是类B中便有一个show(D obj)的方法，参数类型为类D直接匹配了该方法，于是输出9–A and D。

于是可以看出在继承树中的方法调用的优先级：

this.show(O) > super.show(O) > this.show((super)O) > super.show((super)O)。