Question

我无法理解以下程序，如何在这个编码中实现多态，请以简单的方式解释...因为我对java的认识不够...

 class Animal
   {
       eat()       //here this class has one method

    }
 class Dog extends Animals
    {}
 class Cat extends Animals
    {}
 class Wolf extends Animals
    {}
 class MyMain
    {
       public static void main(String args[])
       {
       Animals[] A=new Animals[3];
       A[0]=new Dog();         //parent object reference is used to refer child object
       A[1]=new Cat();         
       A[2]=new Wolf();
       for(int i=0;i<3;i++)
         A[i].eat();
       }

请有人解释这一点哪本书我必须学习以提高java的知识？

Answer 1

简单的多态性

多态性意味着＆＃34;许多形式或形状＆＃34;，这是一种现象，其中对象表现不同，尽管它们紧密相关相关。在下面的例子中，我们有猫，狗和狼，它们都是动物因此是相关的，但它们表演＆＃34; makeound＆＃34;不同。在Java中，它们相关的事实由继承表示，行为由方法表示，这种现象称为多态。

使用您的示例的多态性

我会声明makeound（）而不是eat（），因为它清楚地解释了它：

 class Animal
   {
     // This method will be overridden by Dog, Wolf and Cat classes.
     makesound(){
              System.out.println("make sound");  }
  }


 class Dog extends Animals
    {
     makesound()
              {System.out.println("Bau");}
    }

class Cat extends Animals
    {
     makesound(){System.out.println("Miao");}
    }

class Wolf extends Animals
   {
     makesound(){System.out.println("Uuuu");}
   }


class MyMain
  {
     public static void main(String args[])
     {
      /* This is where polymorphism happens, although A[0],A[1],A[2] are all Animals, 
         at run-time we realize that A[0] is infact dog, A[1] is cat and A[2] is wolf
         so when call makesound on these objects, the method behaves differently so the
         name polymorphism.*/ 

     Animals[] A=new Animals[3];
     A[0]=new Dog();         
     A[1]=new Cat();         
     A[2]=new Wolf();
     for(int i=0;i<3;i++)
       A[i].makesound();
     }

在您尝试了解多态性之前的旁注中，请阅读覆盖的方法是什么：http://docs.oracle.com/javase/tutorial/java/IandI/override.html

Answer 2

多态性是给定层次结构的不同成员具有给定方法的不同实现的属性。在这种情况下，为了演示多态，您需要为不同的子类提供eat（或者您添加到基类Animal的其他一些方法）的不同实现。

Answer 3

enter image description here

所有这些类定义：

class Dog extends Animals
{}
class Cat extends Animals
{}
class Wolf extends Animals
{}

定义作为Animals类的子类的新类。

多态性的字典定义是指生物学中的原理，其中生物体或物种可以具有许多不同的形式或阶段。这个原则也可以应用于面向对象的编程和Java语言之类的语言。类的子类可以定义它们自己的唯一行为，但是可以共享父类的一些相同功能。

如上图所示，子类继承了基类的一些特性，在它们内部，您可以访问子类和子类特征（子类可见）。

多态性的一些优点：

可以使用相同的接口来创建具有不同实现的方法
在区分和处理各种物体方面减少工作量
支持构建可扩展系统
可以使用相同的方法签名替换完整的实施

Answer 4

来自Java Tutorial：

多态性的字典定义是指生物学中的原理，其中生物体或物种可以具有许多不同的形式或阶段。这个原则也可以应用于面向对象的编程和Java语言之类的语言。类的子类可以定义它们自己的唯一行为，但是可以共享父类的一些相同功能。

Animals的所有子类将共享方法eat()，然后在声明数组时：

Animals[] A = new Animals[3];

并初始化其元素：

A[0] = new Dog();   
A[1] = new Cat();         
A[2] = new Wolf();

由于多态性， 能够在每个对象上调用方法eat()。

Answer 5

在这种情况下，多态性的一个例子是：

class Dog extends Animals {
    @Override
    void eat() {
        System.out.printf("Dog eats a bone");
    }
}

class Cat extends Animals {
    @Override
    void eat() {
        System.out.printf("Cat eats a mouse");
    }
}

class Wolf extends Animals {
    @Override
    void eat() {
        System.out.printf("Wolf eat a living animal");
    }

}

现在，您只需在.eat() Array Animal上致电{{1}}，即可看到神奇的事。

有关详细信息，请参阅OracleDocs - Polymorphism。

Answer 6

如果使用接口（因为无法实例化），可以更好地解释多态性：

interface Animal {
    void makeSomeNoise();
}

class Cow implements Animal {
    public void makeSomeNoise() {
        System.out.println("Moo!");
    }
}

class Fox implements Animal {
    public void makeSomeNoise() {
        System.out.println("Ring-ding-ding-ding-dingeringeding!");
    }
}

这表明动物不会发出任何噪音，但是牛和狐狸都可以。但他们发出不同的声音。这是生物学中的原理，其中生物体或物种可以具有许多不同的形式或阶段＆＃34;。基本上有一件事可以有很多不同的面孔。

如果您现在声明您的数组：

Animal[] animals = new Animal[2];
animals[0] = new Cow();
animals[1] = new Fox();

然后让他们发出一些声音：

animals[0].makeSomeNoise();
animals[1].makeSomeNoise();

您将获得以下输出：

Moo!
Ring-ding-ding-ding-dingeringeding!

所以你有两只动物，但它们发出不同的声音。

如何在java中实现多态性

6 个答案: