黑马程序员技术交流社区

标题: 看到天天有人说多态，多态是什么？ [打印本页]
作者: 陈善奔    时间: 2013-12-26 13:26
标题: 看到天天有人说多态，多态是什么？
本帖最后由 陈善奔 于 2013-12-26 20:43 编辑

看到天天有人说多态，多态是什么？最好有代码例子！
作者: FFF    时间: 2013-12-26 13:32
多态，就是可以用多种方式处理传进来的不同问题。
继承，重载，重写。就是多态的体现。
作者: 静心远行    时间: 2013-12-26 13:55
用对象来解释就是：对于同样的一个消息，不同的对象有不同的反应。这主要是通过类的继承、重写实现的。
作者: 刘旭升    时间: 2013-12-26 14:06
讲下多态的定义：①操作名称的多态，就是重载：有多个操作（方法）具有相同的名字，但是传入的参数不同。例如-->
  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);
作者: 路国强    时间: 2013-12-26 14:07
我自己的理解。一个事物有多种体现形式，给你举个例子吧，比如动物这一事物，猫，狗，猪都是动物的体现形式。再比如人这一事物，有学生，工人，老师。诸如此类就是多态了。体现多态的机制：父类对象可以指向子类的引用，例如Person p = new Student();我是这么理解的。
作者: 刘旭升    时间: 2013-12-26 14:25
②与继承有关的多态：同一操作被不同类型调用时可能产生不同的行为。
这个在抽象类中或者接口中很常用。例如：
  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.         }

  23. }
复制代码

animal.cry()都是调用哭的方法，但是由于不同对象的上转型对象（这个你看了就应该知道，就是子类引用指向父类对象）。所以产生了不同的行为。这个多态是很有用的，可以实现开闭源。一定要看懂。{:soso_e130:}
作者: lichao    时间: 2013-12-26 15:16
多态：指允许不同类的对象对同一消息作出响应。说通俗一点就是父类对象的引用子类对象
如：
  1. abstract class Animal//接口  //多态的前提是必须有继承或实现，必须有方法重写或覆盖
  2. {
  3.         abstract void eat();

  5. }

  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. }


  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. }


  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. }

  43. //-----------------------------------------


  46. class DuoTaiDemo
  47. {
  48.         public static void main(String[] args)
  49.         {
  50.                 //Cat c = new Cat();
  51.                 //c.eat();

  53.                 //Dog d = new Dog();
  54.                 //d.eat();
  55.                 //Cat c = new Cat();
  56.                 /*
  57.                 Cat c1 = new Cat();
  58.                 function(c1);

  60.                 function(new Dog());
  61.                 function(new Pig());
  62.                 */

  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.                

  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.         }

  88.         public static void function(Pig p)
  89.         {
  90.                 p.eat();
  91.         }
  92.         */

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



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