Java 多态性可以做什么，继承可以'；T

想象一下，我们有一个类

动物

，它扩展到另外三个类：

狗

，

猫

，

鸟

这个动物类有一个

talk（）

和

move（）

函数。通话功能输出“动物说话”，移动功能输出“动物移动”

对狗来说，这是“狗动”和“狗吃”。对于

Cat

和

Bird

类，此差异与“Cat moving”等类似

现在，由于多态性，如果我这样做

Animal charlietheBird = new Bird()

然后打电话进来

charlietheBird.talk()

它将输出

鸟语

因为输出是在运行时确定的，因为编译器知道charlie是类

Bird

的

Animal

类型

然而

我能做的很简单

Bird charlietheBird = new Bird();

然后调用

charlietheBird.poop（）将给出相同的输出，因为
继承指的是Java编程的一个特性，它允许您创建从其他类派生的类。基于另一个类的类继承另一个类。继承的类是父类、基类或超类

多态性是指编程语言根据对象的数据类型或类以不同方式处理对象的能力。更具体地说，它是为派生类重新定义方法的能力

继承是指Java编程的一项功能，它允许您创建从其他类派生的类。基于另一个类的类继承另一个类。继承的类是父类、基类或超类

多态性是指编程语言根据对象的数据类型或类以不同方式处理对象的能力。更具体地说，它是为派生类重新定义方法的能力

继承支持多态性，但多态性不依赖于继承

您给出了一个如何通过继承实现多态性的示例

但你可以从不同的角度来看：

移动概念有一个接口：

interface Movable{
  void move();
}

动物可以实现此接口：

class Dog implements Movable {
  @Override
  public void move(){
    // move the animal
  }
}

但一些风机也可以移动：

class SlimeMold implements Movable {
  @Override
  public void move(){
    // move the animal
  }
}

很难找到这两者之间可以通过继承来表达的“是一种”关系，但当两者实现相同的接口时，我们仍然可以对它们应用多态性：

Collection<Movable> movables = new HashSet<>();
movables.add(new Dog());
movables.add(new SlimeMold());
for(Movable movable : movables)
   movable.move();

Collection movables=new HashSet（）；
动产。添加（新狗（））；
添加（新SlimeMold（））；
用于（动产：动产）
可移动的；可移动的；
继承支持多态性，但多态性不依赖于继承

您给出了一个如何通过继承实现多态性的示例

但你可以从不同的角度来看：

移动概念有一个接口：

interface Movable{
  void move();
}

动物可以实现此接口：

class Dog implements Movable {
  @Override
  public void move(){
    // move the animal
  }
}

但一些风机也可以移动：

class SlimeMold implements Movable {
  @Override
  public void move(){
    // move the animal
  }
}

很难找到这两者之间可以通过继承来表达的“是一种”关系，但当两者实现相同的接口时，我们仍然可以对它们应用多态性：

Collection<Movable> movables = new HashSet<>();
movables.add(new Dog());
movables.add(new SlimeMold());
for(Movable movable : movables)
   movable.move();

Collection movables=new HashSet（）；
动产。添加（新狗（））；
添加（新SlimeMold（））；
用于（动产：动产）
可移动的；可移动的；

多态性能做什么继承不能做的

多态性的真正优势可以在运行时而不是编译时看到。多态性允许您将一个实现替换为另一个实现，而无需更改使用它的代码。让我们以
动物
层次结构为例。假设你有一个兽医知道如何对任何动物进行健康检查（是的，他是一个超级兽医）

你现在可以说：

Vet vetWithBird = new Vet(new Bird());
Vet vetWithDog =  new Vet(new Dog());
vetWithBird.performCheckup();
vetWithDog.performCheckup();

请注意，您可以告诉
兽医
对
鸟
或
狗
或任何其他动物进行检查，而无需更改您的
兽医
等级。在运行时，
狗
会在检查时吠叫，
鸟
会在检查时鸣叫。想象一下，如果不是
动物
，而是
兽医
有一只
鸟
参考：

class Vet {
   private Bird bird; 
   public Vet(Bird bird) {
      this.bird = bird;
   }

   public void perfromCheckup() {
      bird.talk();
      bird.poop();
   }
} 

可怜的兽医现在只能和一只鸟一起工作。告诉你的
兽医
与
狗
一起工作，他会立即拒绝

Vet vetWithBird = new Vet(new Bird()); //Works fine. Vet likes birds.
Vet vet = new Vet(new Dog())// compilation error. Sorry I don't like dogs.

总之，多态性允许您替换使用超类引用的子类实例。继承允许您从父类继承代码，并可能在子类中重新定义该行为，以便您的代码可以通过多态性在运行时利用它

多态性能做什么继承不能做的

多态性的真正优势可以在运行时而不是编译时看到。多态性允许您将一个实现替换为另一个实现，而无需更改使用它的代码。让我们以
动物
层次结构为例。假设你有一个兽医知道如何对任何动物进行健康检查（是的，他是一个超级兽医）

你现在可以说：

Vet vetWithBird = new Vet(new Bird());
Vet vetWithDog =  new Vet(new Dog());
vetWithBird.performCheckup();
vetWithDog.performCheckup();

请注意，您可以告诉
兽医
对
鸟
或
狗
或任何其他动物进行检查，而无需更改您的
兽医
等级。在运行时，
狗
会在检查时吠叫，
鸟
会在检查时鸣叫。想象一下，如果不是
动物
，而是
兽医
有一只
鸟
参考：

class Vet {
   private Bird bird; 
   public Vet(Bird bird) {
      this.bird = bird;
   }

   public void perfromCheckup() {
      bird.talk();
      bird.poop();
   }
} 

可怜的兽医现在只能和一只鸟一起工作。告诉你的
兽医
与
狗
一起工作，他会立即拒绝

Vet vetWithBird = new Vet(new Bird()); //Works fine. Vet likes birds.
Vet vet = new Vet(new Dog())// compilation error. Sorry I don't like dogs.

总之，多态性允许您替换超类引用的子类实例