这几天我在重新复习Java语言基础，虽然和团队一起，自己个人都进行了实际项目的开发，但越往上面走越觉得自己应该花点时间看看Java的基础知识，巩固一下基础。今天复习的是多态，同时写下自己的学习心得。
数据抽象、继承和多态是面向对象程序设计语言的三大特性。多态，我觉得它的作用就是用来将接口和实现分离开，改善代码的组织结构，增强代码的可读性。在某些很简单的情况下，或许我们不使用多态也能开发出满足我们需要的程序，但大多数情况，如果没有多态，就会觉得代码极其难以维护。
在Java中，谈论多态就是在讨论方法调用的绑定，绑定就是将一个方法调用同一个方法主体关联起来。在C语言中，方法(在C中称为函数)的绑定是由编译器来实现的，在英文中称为early binding(前期绑定)，因此，大家自然就会想到相对应的late binding(后期绑定)，这在Java中通常叫做run-time binding(运行时绑定)，我个人觉得这样称呼更贴切，运行时绑定的目的就是在代码运行的时候能够判断对象的类型。通过一个简单的例子说明：
/**
* 定义一个基类
*/
public Class Parents {

  public void print() {
    System.out.println(“parents”);
}
}
/**
* 定义两个派生类
*/
public Class Father extends Parents {

  public void print() {
    System.out.println(“father”);
}
}
public Class Mother extends Parents {

  public void print() {
    System.out.println(“mother”);
}
}
/**
* 测试输出结果的类
*/
public Class Test {

  public void find(Parents p) {
    p.print();
}

public static void main(String[] args) {
  Test t = new Test();
  Father f = new Father();
  Mother m = new Mother();
  t.find(f);
  t.find(m);
}
}

最后的输出结果分别是father和mother，将派生类的引用传给基类的引用，然后调用重写方法，基类的引用之所以能够找到应该调用那个派生类的方法，就是因为程序在运行时进行了绑定。
学过Java基础的人都能很容易理解上面的代码和多态的原理，但是仍有一些关键的地方需要注意的，算是自己对多态的一个小结：
1.        Java中除了static和final方法外，其他所有的方法都是运行时绑定的。在我另外一篇文章中说到private方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。
2.        在派生类中，对于基类中的private方法，最好采用不同的名字。
3.        包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。
4.        对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。
5.        在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。
6.        构造方法是被隐式声明为static方法。
7.        用继承表达行为间的差异，用字段表达状态上的变化。

1、多态的体现
父类的引用指向自己的子类对象。
父类的引用页可以接收自己的子类对象。
2、多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。
3多态的好处：
多态的 出现大大的提高了程序的扩展性。
（一）相关类
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){
                return ("B and B");
         }
         public String show(A obj){
                return ("B and A");
         }
}
class C extends B{}
class D extends B{}  

（二）问题：以下输出结果是什么？
     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));   ①
        System.out.println(a1.show(c));   ②
        System.out.println(a1.show(d));   ③
        System.out.println(a2.show(b));   ④
        System.out.println(a2.show(c));   ⑤
        System.out.println(a2.show(d));   ⑥
        System.out.println(b.show(b));     ⑦
        System.out.println(b.show(c));     ⑧
        System.out.println(b.show(d));     ⑨     

（三）答案

          ①   A and A
              ②   A and A
              ③   A and D
              ④   B and A
              ⑤   B and A
              ⑥   A and D
              ⑦   B and B
              ⑧   B and B
              ⑨   A and D

（四）分析

        ①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B and B”呢？！！先来回顾一下多态性。

        运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。

        方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

        当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 （但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

        好了，先温习到这里，言归正传！实际上这里涉及方法调用的优先问题 ，优先级由高到低依次为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。让我们来看看它是怎么工作的。

        比如④，a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

        再比如⑧，b.show(c)，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。

        按照上面的方法，可以正确得到其他的结果。

        问题还要继续，现在我们再来看上面的分析过程是怎么体现出蓝色字体那句话的内涵的。它说：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。还是拿a2.show(b)来说吧。

        a2是一个引用变量，类型为A，它引用的是B的一个对象，因此这句话的意思是由B来决定调用的是哪个方法。因此应该调用B的show(B obj)从而输出"B and B”才对。但是为什么跟前面的分析得到的结果不相符呢？！问题在于我们不要忽略了蓝色字体的后半部分，那里特别指明：这个被调用的方法必须是在超类中定义过的，也就是被子类覆盖的方法。B里面的show(B obj)在超类A中有定义吗？没有！那就更谈不上被覆盖了。实际上这句话隐藏了一条信息：它仍然是按照方法调用的优先级来确定的。它在类A中找到了show(A obj)，如果子类B没有覆盖show(A obj)方法，那么它就调用A的show(A obj)（由于B继承A，虽然没有覆盖这个方法，但从超类A那里继承了这个方法，从某种意义上说，还是由B确定调用的方法，只是方法是在A中实现而已）；现在子类B覆盖了show(A obj)，因此它最终锁定到B的show(A obj)。这就是那句话的意义所在。

另外：如果在父类、子类中添加同样的属性，那么通过父类引用所访问的属性是父类的属性。
    这个跟面向对象的特性之一   多态性关系，这里子类 覆盖了 父类的方法，所以你调用父类的方法会显示子类的方法内容（不能调用子类有但父类没有的方法，因为模板是父类，堆中的对象是子类），但是多态性是有条件的，就是  对象的方法才具有多态性， 其中要注意2点， 1对象 2方法

恩恩，互相学习了。。

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。      标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。      他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！        再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。    我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。    这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了。（当然，覆盖的时候函数名和参数要和父类中完全一样,不然你的方法对父类中的方法就不起任何作用，因为两者是两个函数，毫不关系）
例如多态实现：

1. /**
   
2. * 9、 编程实现：猫和狗都会叫，但猫是喵喵的叫，狗是汪汪的叫？
   
3. * 定义一个动物类，在动物类(animal)中有一个叫的抽象方法。
   
4. * 写两个子类，一个猫一个狗，继承自动物类，并实现相应的抽象方法。
   
5. * @author Sun
   
6. *
   
7. */
   
8. //定义一个动物类
   
9. abstract class Animal {
   
10.         //动物类中叫的抽象方法
    
11.         abstract void cry();
    
12.        
    
13. }
    
14. //动物类子类狗
    
15. class Dogs extends Animal{
    
16.        
    
17.         //重载父类方法
    
18.         public void cry(){
    
19.                 System.out.println("小狗,汪汪！");
    
20.         }
    
21. }
    
22. 
    
23. //动物类子类猫
    
24. class Cats extends Animal{
    
25. //重载父类方法
    
26.         public  void cry(){
    
27.                 System.out.println("小猫，喵喵！");
    
28.         }
    
29. }
    
30. 
    
31. 
    
32. public class Test9{
    
33.         //多态实现动物叫
    
34.         public static void main (String[]args){
    
35.                 Animal dog=new Dogs();
    
36.                 Animal cat=new Cats();
    
37.                 dog.cry();
    
38.                 cat.cry();
    
39.         }
    
40. }

复制代码

二楼很强大，很值得学习，补习一下。