我不知道是不是我对多态的理解不到家,要是说狗是狗也是动物,这我能理解,但是要是说重载和覆盖也体现了多态的话,我就有点想不明白了,谁能帮忙解释一些,谢谢了

是指允许不同类的对象对同一消息作出响应。很好的解决了应用程序函数同名的问题。
方法的重写与重载是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载是一个类中多态性的一种表现。如果在子类中定义的某方法与其父类有相同的名称和参数，该方法被重写。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽“了。如果在一个类中定义了多个同名的方法，它们或有不同参数个数或有不同的参数类型，则称为方法的重载。

左耳的鱼 发表于 2013-6-23 00:07
是指允许不同类的对象对同一消息作出响应。很好的解决了应用程序函数同名的问题。
方法的重写与重载是java ...

我是明白重写和重载的定义和区别的,我只是不知道他们怎么就体现了多态而已,在学习这里的知识的时候一般般只会加上一句,重写和重载体现了多态,关键是在哪体现了?要是说道生活中的多态,我很容易理解,可是程序里的多态就.....

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：
   1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
   2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。
   3、重写的方法的返回值必须和被重写的方法的返回一致；
   4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
   5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
   6、静态方法不能被重写为非静态的方法（会编译出错）。

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
   1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
   2、不能通过访问权限、返回类型、抛出的异常进行重载；
   3、方法的异常类型和数目不会对重载造成影响；

多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

我给你说说我的理解、多态就多种形态吧、比如成员函数的重载（Overload）意思就是在一个类内，允许有多个“函数名”相同，但“参数列”不同的成员函数、我给你发一个我的代码、你看看能不能了然哈、

1. class a07
   
2. {               
   
3.         public int getAverage(int value1,int value2) //注意这里的方法类型
   
4.         {
   
5.                 int average;
   
6.                 average = (value1 + value2)/2;                       
   
7.                 return average;
   
8.         }
   
9. 
   
10.         public double getAverage(double value1,double value2) //注意这里的方法类型
    
11.         {
    
12.                 double average;
    
13.                 average = (value1 + value2)/2;       
    
14.                 return average;
    
15.         }
    
16.        
    
17.   public static void main(String[] para)
    
18.   {
    
19.                
    
20.                 a07 aa= new a07();
    
21.                 System.out.println(aa.getAverage(55,90));
    
22.                 System.out.println(aa.getAverage(55.5,92.0));
    
23.                      
    
24.   }
    
25. }

复制代码

这不就实现多态了么

至于覆盖嘛、也差不多吧、成员函数的覆盖就是“子类”内可以定义与“父类”内同名（函数名+参数列）的成员函数，这样是“覆盖”继承
而来的成员函数、不过这个时候要注意的还挺多了、理论我就不给你说了、我也说不明白、这个代码你看看有没有必要研究下吧

1. import java.lang.*;
   
2. import java.lang.reflect.Method;
   
3. 
   
4. class a12
   
5. {         
   
6.         public static void main(String[] para)
   
7.   {               
   
8.     System.out.println("====== A 类之 obj1 对象 ====== ");               
   
9.     Aa obj1 = new Aa();   
   
10.     obj1.fun1();
    
11.     obj1.showAA();
    
12.     obj1.showAA(1111);
    
13.     System.out.println("obj1.aa = " + obj1.aa);   
    
14.    
    
15.     System.out.println("====== B1 类之 obj2 对象 ====== ");                          
    
16.     B1 obj2 = new B1();
    
17.     obj2.fun1();
    
18.     obj2.showAA();
    
19.     obj2.showAA(3333);
    
20.     System.out.println("obj2.aa = " + obj2.aa);
    
21.    
    
22.     System.out.println("====== B2 类之 obj3 对象 ====== ");                    
    
23.     B2 obj3 = new B2();
    
24.     obj3.fun1();
    
25.     obj3.showAA();
    
26.     obj3.showAA(6666);  
    
27.     System.out.println("obj3.aa = " + obj3.aa);
    
28.    
    
29.   }
    
30. }
    
31. 
    
32. class Aa
    
33. {
    
34.   public  int aa = 1000;
    
35.    
    
36.   public  void fun1()
    
37.   {
    
38.           System.out.println("A 类的 fun1() 方法");
    
39.   }
    
40.   
    
41.   public  void fun2()
    
42.   {
    
43.           System.out.println("A 类的 fun2() 方法");
    
44.   }       
    
45.   
    
46.   public  void showAA()
    
47.   {                                 // 存取 A 类内定义的 aa
    
48.           System.out.println("call A class showAA() : aa = " + aa);
    
49.   }
    
50.   
    
51.   public void showAA(int aaValue)
    
52.   {
    
53.           aa = aaValue;
    
54.           System.out.println("call A class showAA(int) : aa = " + aa);
    
55.   }
    
56. }
    
57. 
    
58. class B1 extends Aa
    
59. {
    
60.   public  String aa = "001-aa";
    
61.   
    
62.   public void showAA()
    
63.   {                                 // 存取 B1 类内定义的 aa
    
64.           System.out.println("call B1 class showAA() : aa = " + aa);
    
65.   }
    
66.   
    
67.   public void fun1()
    
68.   {  //返回类型一定要一样才能 override，否则会有 error
    
69.           System.out.println("B1 类的 fun1() 方法");
    
70.   }
    
71. }
    
72. 
    
73. class B2 extends Aa
    
74. {         
    
75.   public String aa = "002-aa";
    
76.   public int bb = 300;
    
77.    
    
78.   public final void fun1()
    
79.   {     //修饰字不同一样也是 override
    
80.     System.out.println("B2 类的 fun1() 方法");  
    
81.     bb = bb + 10;
    
82.     System.out.println("bb = " + bb);
    
83.   }
    
84.   
    
85.   public void fun2(String str)
    
86.   {   //不算 fun2() 的 overload，也不是 override
    
87.           System.out.println(str + "B2 类的 fun2() 方法");
    
88.   }
    
89. }
    
90. 
    

复制代码