黑马程序员技术交流社区

标题: 什么是多态，求定义 [打印本页]
作者: 萧萧北    时间: 2013-6-2 18:48
标题: 什么是多态，求定义
本帖最后由 萧萧北 于 2013-6-3 22:42 编辑

面向对象的三大核心：封装、继承、多态。

看了视频后学会使用了，可是关于多态的定义，还是说不出来，理解不够深啊，求哪位同学给我详细讲讲多态的定义吧。
作者: 喜欢流浪    时间: 2013-6-2 18:57
简单的说：相同类型的变量、调用同一个方法时候，呈现出多种不同的行为特征，这就是多态呗！
作者: 张龙欢    时间: 2013-6-2 19:09
多态：
        (1)某一类事物的多种存在形态。
                **方法重载(静态多态)
                **方法重写(动态多态,对象多态)
        (2)对象多态的前提
                A：类与类(或接口)要有继承(或实现)关系。
                B：一定要有方法的重写。
                C：一定要有父类或者接口的引用指向子类的对象。Person p = new SuperMan();
                                                                                                                SuperMan sm = (SuperMan)p;
        (3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。
                A：Animal Cat Dog
                        **method(Animal a){a.eat();}
        (4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)
                Fu f = new Zi();
                A：成员变量：编译和运行都看Fu。
                B：非静态方法：编译看Fu，运行看Zi。
                C：静态方法：编译和运行都看Fu。

                举例：        动物的例子：
                        向上转型
                        Animal a = new Cat();
                        a.eat();
                        //a.catchMouse();

                        向下转型
                        Cat c = (Cat)a;
                        c.eat();
                        c.catchMouse();

                        //向上转型
                        Animal a = new Dog();
                        //向下转型 转换异常
                        //Cat c = (Cat)a;
                        Dog d = (Dog)a;

                        超人的例子：
                        person :谈生意();
                        SuperMan:谈生意();fly();

                        Person p = new SuperMan();//超人没变身之前就是普通人一个,只能调用Person里的方法
                        //在运行的时候发现有SuperMan这个子类继承了他,会去看里面是否有和你调用Person里相同的方法
                        //如果有运行就执行子类重写的方法(成员函数的特性,覆盖)
                        p.谈生意();

                        SuperMan sm= (SuperMan)p;//内裤外穿,变身超人
                        sm.谈生意();
                        sm.fly();
                        总结:无论是向上转型还是向下转型,变化的都是子类对象,绝对不能把父类对象强转为子类类型
作者: Jomes    时间: 2013-6-2 19:21
以我个人的理解。主要是是四个方面
一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
以下是一个很经典的例子：
  1. class Father{   
  2.     public void func1(){   
  3.         func2();   
  4.     }   
  5.     //这是父类中的func2()方法，因为下面的子类中重写了该方法   
  6.     //所以在父类类型的引用中调用时，这个方法将不再有效   
  7.     //取而代之的是将调用子类中重写的func2()方法   
  8.     public void func2(){   
  9.         System.out.println("AAA");   
  10.     }   
  11. }   
  12.    
  13. class Child extends Father{   
  14.     //func1(int i)是对func1()方法的一个重载，主要不是重写！  
  15.     //由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用   
  16.     //所以在下面的main方法中child.func1(68)是不对的   
  17.     public void func1(int i){   
  18.         System.out.println("BBB");   
  19.     }   
  20.     //func2()重写了父类Father中的func2()方法   
  21.     //如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法   
  22.     public void func2(){   
  23.         System.out.println("CCC");   
  24.     }   
  25. }   
  26.    
  27. public class PolymorphismTest {   
  28.     public static void main(String[] args) {   
  29.         Father child = new Child();   
  30.         child.func1();//打印结果将会是什么？   
  31.         child.func1(68);  
  32.     }   
  33. }   
复制代码
子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

其输出的结果是很显然是"CCC"。
作者: 王瀛    时间: 2013-6-2 19:44
描述就是：同一类事物的多种体现形态。

代码上就是：父类引用指向子类对象。

多态好处是能够提高代码的后期扩展性，提高了代码的复用性。
作者: 山鹰    时间: 2013-6-2 20:12
本帖最后由 山鹰 于 2013-6-2 20:14 编辑
  1. <p><p>多态有两种体现：1>父类指向子类的对象
  2.                 2>接口指向实现类的对象</p><p> </p><p>继承中多态的体现
  3. public abstract class Animal {
  4.         
  5.         public abstract void eat();
  6.         public  void run(){
  7.                 System.out.println("走步");
  8.         }
  9.         public static void speak(){//静态方法
  10.                 System.out.println("叫");
  11.         }
  12. }
  13. public class Cat extends Animal{

  15.         public void eat(){//重写父类的方法
  16.                 System.out.println("猫吃鱼");
  17.         }
  18.         public void catchMouth(){//子类自己的方法
  19.                 System.out.println("猫捉老鼠");
  20.         }
  21. }
  22. public class Dog extends Animal{

  24.         public void eat(){//重写父类的方法
  25.                 System.out.println("狗啃骨头");
  26.                
  27.         }
  28.         public void run(){//子类自己的方法
  29.                 System.out.println("狗走步");
  30.         }
  31.         public static void speak(){//重写父类静态方法
  32.                 System.out.println("狗叫");
  33.         }
  34. }
  35. public class AnimalDemo {

  37.         public static void main(String[] args) {
  38.                
  39.                 Animal a = new Cat();
  40.                 a.eat();
  41.                 a.run();
  42.                
  43.                
  44.                
  45.                 Animal a1 = new Dog();
  46.                 a1.speak();        //调用静态方法，编译和运行都看左边
  47.                 Dog d = new Dog();
  48.                 d.run();//调用静态方法，编译和运行都看左边
  49.     }
  50. }</p></p>
复制代码
  1. [code]接口中多态的体现
  2. public interface Opertion{
  3.         
  4.         public  void add();
  5.         public  void delet();
  6.         public  void update();
  7.         public  void select();
  8. }
  9. public class JDBC implements Opertion{

  11.         public void add() {
  12.                 System.out.println("添加操作");
  13.                
  14.         }
  15.         public void delet() {
  16.                 System.out.println("删除操作");
  17.         }

  19.         public void select() {
  20.                 System.out.println("修改操作");
  21.         }

  23.         public void update() {
  24.                 System.out.println("查询操作");
  25.         }
  26. }
  27. public class Demo {
  28.         
  29.         public static void main(String[] args) {
  30.                 Opertion o = new JDBC();
  31.                 o.add();
  32.                 o.delet();
  33.                 o.update();
  34.                 o.select();               
  35.         }
  36. }
复制代码
作者: 杨青    时间: 2013-6-2 20:59
多态是面向对象程序设计的又一重要特性。
多态是允许程序中出现重名现象，java语言中有方法重载和成员覆盖两种多态表现形式。
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同（包括个数和类型），完成的功能也不同。
成员覆盖：子类与父类允许拥有相同的变量名称，但数据类型不同，允许使用同样的方法，但是功能不同。
多态的特性使程序的抽象程度和简捷程度更高，有助于程序设计人员对程序的分组协同开发。
作者: 王林涛    时间: 2013-6-3 03:27
都说的那么复杂,让人家怎么理解?
简而言之,多态就是同种事物存在的多种状态
举个例子说,就像电脑主板存在很多接口,接口可以接,鼠标,U盘,无线网卡等等设备,这个时候,我们就可以说主板就属于多态了!
多态的好处就是提高代码的复用性和程序的扩展性.(就像主板,多功能,多实现)
作者: 萧萧北    时间: 2013-6-3 22:35
讲的很详细啦，谢谢大家了
作者: 想、一个人    时间: 2013-6-3 22:37
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。      标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。      他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！        再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。    我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。    这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了
作者: 想、一个人    时间: 2013-6-3 22:37
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。      标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。      他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！        再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。    我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。    这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2