这几天我在重新复习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.        用继承表达行为间的差异，用字段表达状态上的变化。

恩恩，互相学习了。。

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖首先说重载（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. }

复制代码

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