看到天天有人说多态，多态是什么？最好有代码例子！

多态，就是可以用多种方式处理传进来的不同问题。
继承，重载，重写。就是多态的体现。

用对象来解释就是：对于同样的一个消息，不同的对象有不同的反应。这主要是通过类的继承、重写实现的。

讲下多态的定义：①操作名称的多态，就是重载：有多个操作（方法）具有相同的名字，但是传入的参数不同。例如-->

1. nihao(){}//1
   
2. nihao(int a ){}//2
   
3. nihao(int a,b){}//3
   
4. nihao(float a){}//4

复制代码

上面四个都是方法，名称相同，但是参数不同。调用他们时：nihao();nihao(2);nihao(2,3);nihao(2.3);

我自己的理解。一个事物有多种体现形式，给你举个例子吧，比如动物这一事物，猫，狗，猪都是动物的体现形式。再比如人这一事物，有学生，工人，老师。诸如此类就是多态了。体现多态的机制：父类对象可以指向子类的引用，例如Person p = new Student();我是这么理解的。

②与继承有关的多态：同一操作被不同类型调用时可能产生不同的行为。
这个在抽象类中或者接口中很常用。例如：

1. class Animal{
   
2.         void cry(){}
   
3. }
   
4. class Dog extends Animal{
   
5.         void cry(){
   
6.                 System.out.println("WangWang...");
   
7.         }
   
8. }
   
9. class Cat extends Animal{
   
10.         void cry(){
    
11.                 System.out.println("miao...");
    
12.         }
    
13. }
    
14. public class Test{
    
15.         public static void main(String args[]){
    
16.                 Animal animal;
    
17.                 animal=new Dog():
    
18.                 animal.cry();
    
19.                 animal=new Cat();
    
20.                 animal.cry();
    
21.         }
    
22. 
    
23. }

复制代码

animal.cry()都是调用哭的方法，但是由于不同对象的上转型对象（这个你看了就应该知道，就是子类引用指向父类对象）。所以产生了不同的行为。这个多态是很有用的，可以实现开闭源。一定要看懂。{:soso_e130:}

多态：指允许不同类的对象对同一消息作出响应。说通俗一点就是父类对象的引用子类对象
如：

1. abstract class Animal//接口  //多态的前提是必须有继承或实现，必须有方法重写或覆盖
   
2. {
   
3.         abstract void eat();
   
4. 
   
5. }
   
6. 
   
7. class Cat extends Animal//实现类
   
8. {
   
9.         public void eat()//覆盖方法
   
10.         {
    
11.                 System.out.println("吃鱼");
    
12.         }
    
13.         public void catchMouse()
    
14.         {
    
15.                 System.out.println("抓老鼠");
    
16.         }
    
17. }
    
18. 
    
19. 
    
20. class Dog extends Animal//实现类
    
21. {
    
22.         public void eat()//覆盖方法        {
    
23.                 System.out.println("吃骨头");
    
24.         }
    
25.         public void kanJia()
    
26.         {
    
27.                 System.out.println("看家");
    
28.         }
    
29. }
    
30. 
    
31. 
    
32. class Pig extends Animal//实现类
    
33. {
    
34.         public void eat()//覆盖方法        {
    
35.                 System.out.println("饲料");
    
36.         }
    
37.         public void gongDi()
    
38.         {
    
39.                 System.out.println("拱地");
    
40.         }
    
41. }
    
42. 
    
43. //-----------------------------------------
    
44. 
    
45. 
    
46. class DuoTaiDemo
    
47. {
    
48.         public static void main(String[] args)
    
49.         {
    
50.                 //Cat c = new Cat();
    
51.                 //c.eat();
    
52. 
    
53.                 //Dog d = new Dog();
    
54.                 //d.eat();
    
55.                 //Cat c = new Cat();
    
56.                 /*
    
57.                 Cat c1 = new Cat();
    
58.                 function(c1);
    
59. 
    
60.                 function(new Dog());
    
61.                 function(new Pig());
    
62.                 */
    
63. 
    
64.                 //Animal c = new Cat();
    
65.                 //c.eat();                               Animal a = new Cat();//多态                Animal a = new Dog();//多态                Animal a = new Pig();//多态               
    
66.                 function(new Cat());
    
67.                 function(new Dog());
    
68.                 function(new Pig());
    
69.                
    
70. 
    
71.                
    
72.         }
    
73.         public static void function(Animal a)//Animal a = new Cat();//多态
    
74.         {
    
75.                 a.eat();
    
76.                 //a.catchMouse();
    
77.         }
    
78.         /*
    
79.         public static void function(Cat c)//
    
80.         {
    
81.                 c.eat();
    
82.         }
    
83.         public static void function(Dog d)
    
84.         {
    
85.                 d.eat();
    
86.         }
    
87. 
    
88.         public static void function(Pig p)
    
89.         {
    
90.                 p.eat();
    
91.         }
    
92.         */
    
93. 
    
94. }

复制代码

多态的好处        多态的出现大大的提高程序的扩展性。多态的弊端：        提高了扩展性，但是只能使用父类的引用访问父类中的成员。