Oop 多态性和duck类型之间有什么区别？

我对这两个术语有点困惑，以下是我所知道的：

多态性是不同类型的对象被一个公共接口处理的能力。duck类型是一种动态类型，允许不同类型的对象响应相同的方法

据我所知，多态性更多的是创建一个可以跨不同类共享的接口。duck类型是松散类型，只要在消息的接收者上找到，就可以调用方法

---

这是正确的吗？我对这两个人很困惑，他们似乎有关联，但我不知道他们的关系是什么。提前多谢

多态性（在面向对象编程的上下文中）意味着子类可以重写基类的方法。这意味着一个类的方法可以在子类中做不同的事情。例如：一个类

Animal

可以有一个方法

talk（）

，而

Animal

的子类

Dog

和

Cat

可以让方法

talk（）

发出不同的声音

鸭式键入意味着代码将只接受具有特定方法的任何对象。假设我们有以下代码：

animal.quack（）

。如果给定的对象

animal

具有我们想要调用的方法，那么我们就可以了（不需要额外的类型要求）。无论是

动物

实际上是一只

鸭子

，还是另一种碰巧也会嘎嘎作响的动物。这就是为什么它被称为duck-typing：如果它看起来像鸭子（例如，它有一个名为

quack（）

的方法，那么我们可以把它当作鸭子）

那么这些是相关的吗？它们只是编程语言可能具有的独立特性。有些编程语言具有多态性，但没有duck类型（如Java）。还有一些语言具有多态性和duck类型（例如Python）。

两种类型的多态性

方法重载（编译时多态性）

方法重写（运行时多态性）

方法重载：-相同的函数名和不同的数据类型称为方法重载

例如：

  int addTwovalues(int a, int b)
  { return (a+b)}

  float addTwovalues(float a, float b)
  { return (a+b)}

  Method overriding :- same function name and same data type but different Class
     is known as       Method overriding.


  class a
 {
  virtual int addtwovalues()
   {  // to do  }
  }
 class b:a
 {
     override int addtwovalues()
   {  // to do  }

  }



  a obj=new a();
  obj.addtwovalues();

  b objb=new a();
  objb.addtwovalues();  //run time Polymorphism 

---

这是Python中多态性的一个示例

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Cat('Mr. Mistoffelees'),
           Dog('Lassie')]

for animal in animals:
    print animal
    print animal.name + ': ' + animal.talk()

class Duck:
    def quack(self):
        print("Quaaaaaack!")
    def feathers(self):
        print("The duck has white and gray feathers.")
    def name(self):
        print("ITS A DUCK NO NAME")


class Person:
    def quack(self):
        print("The person imitates a duck.")
    def feathers(self):
        print("The person takes a feather from the ground and shows it.")
    def name(self):
        print("John Smith")

def in_the_forest(duck):
    duck.quack()
    duck.feathers()
    duck.name()

def game():
    for element in [ Duck() , Person()]:
        in_the_forest(element)

game()

这是Python中duck类型的一个示例

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Cat('Mr. Mistoffelees'),
           Dog('Lassie')]

for animal in animals:
    print animal
    print animal.name + ': ' + animal.talk()

class Duck:
    def quack(self):
        print("Quaaaaaack!")
    def feathers(self):
        print("The duck has white and gray feathers.")
    def name(self):
        print("ITS A DUCK NO NAME")


class Person:
    def quack(self):
        print("The person imitates a duck.")
    def feathers(self):
        print("The person takes a feather from the ground and shows it.")
    def name(self):
        print("John Smith")

def in_the_forest(duck):
    duck.quack()
    duck.feathers()
    duck.name()

def game():
    for element in [ Duck() , Person()]:
        in_the_forest(element)

game()

• 在多态性中，我们看到子类（

  Cat

  和

  Dog

  ）继承自父类（

  Animal

  ）并重写方法Talk
• 在duck类型中，我们不创建子类，而是使用具有相同名称但不同函数的方法创建新类

---

简短回答：

Duck类型是实现多态性的一种方法。 另一种方法是使用静态类型

长答案：

这里涉及两个不同的概念，类型和编程技术

Duck类型是一种类型的类型。键入意味着当传递的对象不是预期的对象时，何时抛出错误。Duck类型化是一种类型化，当程序正在运行且调用的方法不可用时，它会抛出错误。静态类型附带编译时检查，因此如果类型信息不匹配，则在编译代码时会抛出错误。那就是打字

多态性是一种编程技术，允许多种类型的对象履行某些职责。可以通过使用基类型来表示所有子类类型来实现这一点。您可以使用duck类型来表示具有所需方法的所有不同类型。您可以使用接口来表示实现该接口的所有类型

有答案说多态性就是继承，这是不正确的。虽然您可以使用继承来创建多态性行为，通常情况下这就是您要做的，但多态性并不是这样的

首先，您不需要像上面所描述的那样继承多态性

---

其次，术语“多态性”在依赖于抽象的客户机代码上下文中更有意义，而不是在实现代码上下文中。仅仅因为您有一个超类和一些其他继承自它的类并重写了一些方法，并不意味着它是多态性的，要创建多态性，您必须以多态性的方式编写客户端代码来使用这些类。

在java中，您可以使用一些使用接口的duck类型。另外。。。多态性可以改变子类的行为。“多态性意味着子类可以重写基类的方法。”-这不只是继承吗？@mumble：在面向对象编程中，它确实是通过继承完成的。但是多态性也可以在没有类的情况下完成，例如定义一个函数

add（intx，inty）

和一个函数

add（String s，String t）

，它们具有相同的名称，但实际参数决定了实际调用的函数。如果你说的是多态性，那么什么是最重要的呢？第一种情况对我来说似乎是简单的继承。我真的不认为在Python这样的动态类型语言中谈论多态性是有意义的。基本上，这里的第一个案例也是duck类型。在Python中，函数参数没有类型，因此可以将任何内容传递给任何函数。那不是多态性。它只是动态类型。在第一种情况下，它不仅仅是简单的继承，对吗？有一系列的动物，他正在调用talk（）的元素。这就是亚型多态性。简单继承的目标基本上只是类之间的代码共享。这显然不止于此，这是最好的例子