java 多态有什么体现 求详解……

1. class Person
   
2. {
   
3.         private String name;
   
4.         private int age;
   
5.         public void speak()
   
6.         {
   
7.                 System.out.println("person说话");
   
8.         }
   
9. }
   
10. class Student extends Persion
    
11. {
    
12.         private String sno;
    
13.         private String grade;
    
14.         public void speak()
    
15.         {
    
16.                 System.out.println("Student说话");
    
17.         }
    
18.         private void study()
    
19.         {
    
20.                 System.out.println("学习");
    
21.         }
    
22. }
    
23. public class Test
    
24. {
    
25.         public static void main(String []args)
    
26.         {
    
27.                 Person p=new Student();//这里就是多态，用父类类型的引用指向子类对象
    
28.         //        p.study();              //这里编译是不能通过的，因为父类中没有study()方法
    
29.                 p.speak();              //这里输出的是Student说话
    
30.         }
    
31. }

复制代码

总结：多态是子类可以表现出父类的状态，编译看左边，如果调用了父类中没有的方法编译不能通过。
        运行看右边，如果子类和父类中都有该方法，则调用子类重写的方法。

如果换成实现关系，道理是一样的。这是对象的多态性，多态的表现还有方法的多态，如重载和覆盖。

多态就是用父类的引用创建子类对象。

引用毕老师的一个例子就是 看到一只猫很可爱，你可以说这只动物真可爱。反之则不行

多态：就是指相同的事物的不同状态，比如：水。水可以有三种状态：气体、液体和固体。那么在JAVA中的多态也可以理解成这个意思，就是：将父对象设置成为和一个或多个它的子对象相等的技术，比如Parent=Child； 多态性使得能够利用同一类（父类）引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作。

多态实现包括两种方式：
1.重写:
例如：Animal a = new Tiger();  这是一个老话题了，呵呵……父类引用指向子类对象，Animal类中包含一个eat()方法，而Tiger类继承自Animal类，如果子类重写了父类的eat()方法，则调用的时候，就可以按照子类的形式调用，本质上是父类的方法，但是子类重写之后，就成了另一种方式，这就是多态。
2.重载:
例：计算两个数相加 或者三个数相加  则不需要定义两个方法 而用到重载.

1. class Sum{
   
2.   public int getSum(int x,int y) //两个数相加
   
3. {
   
4.       return  x+y;
   
5. }
   
6. public int getSum(int x,int y,int z) //三个数相加  不需要重新定义新方法 而用到重载
   
7. {
   
8.      getSum(x,y)+z;
   
9. }
   
10. }

复制代码

简单的说就是父类引用指向子类对象。
多态的前提：
必须是类与类之间有关系，要么继承，要么实现。
通常还有一个前提就是：存在覆盖。
多态的好处：
多态的出现提高了程序的扩展性
多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员
还有一点需要注意的，就是当多态是，要使用子类的特有方法时
必须使用强制类型转换，把父类引用强制转换成子类类型。
楼上给的例子不错：Animal a = new Tiger();  
这时就是多态的形式，引用a可以调用Animal的方法，
但是不能调用Tiger的特有方法，如果想调用tiger的特有方法，需要强制将引用a转成tiger类型
转换方法：Animal a = new Tiger();  
               Tiger t= (Tiger) a;
这时t就可以调用tiger的特有方法了

1. class Father
   
2. {
   
3.         String father = "father";
   
4.         public void show(){
   
5.                         System.out.println("Father is show()");
   
6.         }
   
7.         public void show1(){
   
8.                         System.out.println("Father  show1111()");
   
9.         }
   
10. }
    
11. class Son extends Father
    
12. {
    
13.         String father = "son";
    
14.         String son = "子类特有的";
    
15.         //重写了父类方法
    
16.         public void show(){
    
17.                         System.out.println("Son is show()");
    
18.         }
    
19.         //重载父类的方法，但对于父类，是一个新增加的功能
    
20.         public void show(int i){
    
21.                 System.out.println("Son is show() again");
    
22.         }
    
23. }
    
24. //        测试多态性
    
25. class ExtendsDemo
    
26. {
    
27.         public static void main(String []args){
    
28.                        
    
29.                 Father f = new Father();//
    
30.                 Father s = new Son();//创建一个父类引用指向子类对象
    
31.                 Son son = new Son();//
    
32.                 f.show();//父亲访问自己的方法
    
33.                 s.show();//由于父类引用指向了子类对象，子类又对父类的show()方法进行了重写，故访问子类的方法
    
34.                 //s.show(1);//show(int i)由于是子类新增加的功能，父类并不知道，所以不能调用，会编译不过
    
35.                 s.show1();//子类并没有重写父类show1()方法，故会去调用父类的方法show1()
    
36.                 System.out.println("Father f :"+f.father);//调用父类属性
    
37.                 System.out.println("Father s :"+s.father);//调用父类属性
    
38.                 System.out.println("Father s:"+f.son);//为子类Son新增加的属性，父类不能调用，编译不过
    
39.         }
    
40. }
    
41. /*运行结果：
    
42.                 Father is show()
    
43.                 Son is show()
    
44.                 Father  show1111()
    
45.                 Father f :father
    
46.                 Father s :father
    
47. */
    
48.        
    
49. /*
    
50.         多态的三个必要条件：
    
51.                  1.继承   2.重写   3.父类引用指向子类对象。
    
52.         总结：
    
53.        
    
54.                 一、使用父类类型的引用指向子类的对象；
    
55. 
    
56.                 二、该引用只能调用父类中已经定义的方法和变量；
    
57. 
    
58.                 三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
    
59.                                 动态绑定是指”在执行期间（而非编译期间）“判断所引用对象的实际类型，根据实际的类型调用其相应的方法。
    
60. 
    
61.                 四、变量不会被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在调用时，还是会调用父类的变量
    
62.                
    
63. */

复制代码

如果问题未解决，请继续追问，如果问题解决了，请将问题分类改为“已解决”，谢谢

郭登旭 发表于 2013-4-22 11:53
总结：多态是子类可以表现出父类的状态，编译看左边，如果调用了父类中没有的方法编译不能通过。
         ...

多态是子父类相关的么，我一直以为是重载呢

hacket 发表于 2013-4-22 17:46

谢谢，学习了

李大伟 发表于 2013-4-23 09:16
多态是子父类相关的么，我一直以为是重载呢

重载、重写是方法多态的体现，上面所说的是对象多态的体现，而对象的多态前提必须有继承或实现关系，且有方法的重写。