1. 在java每一个特性的出现都是按需所来的，像抽象类就是把类中相同功能的声明抽取出来，这样用起来比较方便，接口也是为了增添某一类事物的扩展功能，但是多态呢，虽说Animal  a  = new Cat( )是以这种形式存在的，说是父类引用指向子类对象，但是我感觉这话还是太书面了，还是不懂，求秒懂
   
2. 
   
3. abstract class Animal
   
4. {
   
5.         abstract void eat();
   
6. 
   
7. }
   
8. 
   
9. class Cat extends Animal
   
10. {
    
11.         public void eat()
    
12.         {
    
13.                 System.out.println("吃鱼");
    
14.         }
    
15.         public void catchMouse()
    
16.         {
    
17.                 System.out.println("抓老鼠");
    
18.         }
    
19. }
    
20. 
    
21.         public static void function(Animal a)
    
22.         {
    
23.                 a.eat();
    
24.                  
    
25.         }
    

复制代码

多态是面向对象语言的一个重要特征。它是指继承同一父类的不同子类之间（按照某种规则）呈现不同的状态。要想清楚的理解多态的概念，就必须先把前面定义中的“某种规则”搞明白。下面，我就这一规则进行详细分析。
      我先定义一个父类，类名取为A。类A里写一个公共方法f()。然后我再定义两个子类B和C，它们都继承自类A。我再实例化类B为b，类C为c。接着，我先把b赋值给类A的实例a（注1），然后调用a的方法f()，再把c赋值给a，也调用a的方法f()。结果是我们两次调用了类A的方法f()。现在我想，既然类B与类C不同，那么，有没有一种方法，可以使上面对方法f()的调用根据子类的不同而不同？答案是肯定的。我们分别在类B、类C中重新定义方法f()，并且通过一定手段使上面调用方法f()时，调用的实际是子类中的方法f()。这就是所谓的多态。

秒懂啊。。。
class Person｛
  public void Method（）｛
    System.out.println(" i am Person");
｝

｝

class Student extends Person｛
public void Method（）｛
    System.out.println(" i am Person");
｝

public void goToSchool（）｛
System.out.println(" hello teacher");
｝
｝

Person instance=new Student();
父类引用指向子类对象

这个有什么用呢？
当你只想调用Method方法时，可以这样创建
instance.Method();    这个没有问题，在API文档里有些类父类和子类有相同的功能，这时候多态就起作用了
如果想用子类的特有方法，比如上面的goToSchool就老老实实用子类指向子类对象吧
当父类引用指向子类对象时，也可以向下转型，从而调用子类功能。

我只按照我的理解说说吧！！多态就是事物呈现多种形态，比如毕老师举的动物的例子，猫，狗等等都可以成为动物，如果大猫生小猫，你可以说是多了一只猫，同样来说你也可以说多了一只动物吧，这只是简单的理解。至于用途方面，比如，猫，狗，都会吃东西，你如果你分别定义猫和狗的类，那样你就会分别定义一个吃东西的方法，像你列出的例子里面，定义了一个功能调用吃的方法，如果形式参数定义成猫的，就只能调用猫的方法，狗的也一样，既然他们都是动物，就定义成动物型的呗，不管你传一个猫也好，狗也好，都是动物么，调用方法的时候，是谁就调用谁的，岂不更好，所以就有了多态了么。我还是希望你能理解多态，即使我说的不理解，你也想办法理解理解，因为后面用的太多了，比如后面学的新东西，都是接口，定义类型的时候也是用的接口类型，你知道接口是不能创建对象的吧，所以创建对象的时候就用它的子类来创建对象，这里可能又把你搞糊涂了，总之，一句话，多态一定要理解。最后举一个例子，比如人，爷爷，父亲，儿子，孙子，都是人，父亲多了个儿子，不就是爷爷多了个孙子，不就是多了个人么，怎么多都没错吧，这就是多态。

1. /*多态性*
   
2. 多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。下面的例子展示了多态性。
   
3. */
   
4. public class note3
   
5. {
   
6. public static void main(String args[])
   
7. {
   
8. Animal a;
   
9. a=new Dog();
   
10. a.cry();
    
11. a=new Cat();
    
12. a.cry();
    
13. a=new Duck();
    
14. a.cry();
    
15. 
    
16. }
    
17. 
    
18. }
    
19. class Animal
    
20. {
    
21. void cry()
    
22. {
    
23. 
    
24. }
    
25. }
    
26. class Dog extends Animal
    
27. {
    
28. void cry()
    
29. {
    
30. System.out.println("旺旺");
    
31. }
    
32. }
    
33. class Cat extends Animal
    
34. {
    
35. void cry()
    
36. {
    
37. System.out.println("喵喵");
    
38. }
    
39. }
    
40. class Duck extends Animal
    
41. {
    
42. void cry()
    
43. {
    
44. System.out.println("呱呱");
    
45. }
    
46. }
    
47. 
    
48. /*
    
49. 
    
50. 运行结果：
    
51. 旺旺
    
52. 喵喵
    
53. 呱呱
    
54. 
    
55. */
    

复制代码

像楼主你举得例子，抽象类不能实例化，只能通过子类实例化对象，所以采用多态Animal cat = new Cat( );这就是父类引用指向子类对象。

多态简单啊  明了点  你发现你身边的朋友没有或者古代有句话 有其父必有其子 。但是儿子和父亲却是两个人 所以他们即是做同样的事情 也会用不同的方式来做。但是他们做的是同样的事情变现出来的状态是一样的 比方说以前你去乡下的时候是不是看到很多老爷爷在村门口吃饭往那一蹲就开始吃了，但是你不会看到年轻人在那蹲着吃吧。儿子也得吃饭但是他们在家里吃。所以他们有一个共同点就是吃饭。吃饭都要吃就是方法不一样。人们都要吃饭所以就封装起来了啊。在打个比方还是吃饭 ，我们人都要吃饭对不，56个名族都要吃饭。一个名族说我们蔬菜，一个名族说我们吃肉，另一个名族说我们吃面包。。。。等等都是“吃饭动作”吃的东西不一样动作也不一样用的东西也不一样这么多动作是不是很复杂描述起来但是归根到底都是“吃饭动作”所以我们人类聪明啊 就把这个吗多动作封装起来 说管你吃啥用啥吃在哪吃，只要吃食物为了给身体获得能量。都是吃饭。这样是不是很方便了。要不你还得一个一个描述怎么“吃饭动作”，汉族人用筷子把食物放进嘴里，食物是大米白面。蒙古人用手把食物放进嘴里来得到能量，食物是牛羊肉。。。。等等这些都是、食物放进嘴里得到能量，你一个一个描述累不 那就直接说吃饭就得了， 管你吃的是啥在哪吃。反正就是把食物放进嘴里获得能量就是，吃饭。简单了吧。还有就是你要记住多态的条件.
1，必须是类与类之间有继承或者实现。
2，父类能被子类覆盖.（就是父类告诉你必须要吃饭，但是父类不管你怎么吃，吃什么 但是你必须得听父类吃饭）

多态就是包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势。

多态有两种表现形式：重载和覆盖

假如有个方法名叫：“动物的叫声”
那么，当你传递的参数是动物狗，则调用狗叫声，是猫，则调用猫叫声l；这些都是“动物的叫声”
当狗叫，你可以说是动物的叫声，也可以说是狗的叫声，这就是多态性。