多态性的实际例子

Posted 2023-02-23

【中文标题】多态性的实际例子

【英文标题】：Practical example of Polymorphism

【发布时间】：2011-04-13 01:16:09

【问题描述】：

谁能给我一个真实的？我的教授给我讲了一个关于+ 运算符的老故事。 a+b = c 和 2+2 = 4，所以这是多态性。我真的无法将自己与这样的定义联系起来，因为我已经在很多书中反复阅读过这个定义。

我需要的是一个真实世界的代码示例，我可以真正与之相关联。

例如，这里是一个小例子，以防你想扩展它。

>>> class Person(object):
    def __init__(self, name):
        self.name = name

>>> class Student(Person):
    def __init__(self, name, age):
        super(Student, self).__init__(name)
        self.age = age

【问题讨论】：

您是专门询问运算符多态性（也称为运算符重载）还是一般polymorphism？

一般的多态性。

【参考方案1】：

查看 Wikipedia 示例：它在高层次上非常有帮助：

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.name + ': ' + animal.talk()

# prints the following:
#
# Missy: Meow!
# Mr. Mistoffelees: Meow!
# Lassie: Woof! Woof!

请注意以下几点：所有动物都会“说话”，但说话方式不同。因此，“谈话”行为是多态的，因为它根据动物的不同实现不同。所以，抽象的“动物”概念实际上并不是“说话”，而是具体的动物（如狗和猫）对“说话”的动作有具体的实现。

同样，“加法”运算在许多数学实体中都有定义，但在特定情况下，您根据特定规则“加法”：1+1 = 2，但 (1+2i)+(2-9i)=( 3-7i)。

多态行为允许您在“抽象”级别指定常用方法，并在特定实例中实现它们。

你的例子：

class Person(object):
    def pay_bill(self):
        raise NotImplementedError

class Millionare(Person):
    def pay_bill(self):
        print "Here you go! Keep the change!"

class GradStudent(Person):
    def pay_bill(self):
        print "Can I owe you ten bucks or do the dishes?"

你看，百万富翁和研究生都是人。但是当涉及到支付账单时，他们具体的“支付账单”行动是不同的。

【讨论】：

有一个 abstract 方法 raise NotImplementedError 打破 super。

这与继承有何不同，继承是子类覆盖父类中的方法？

@Pyderman继承是实现多态的手段之一。

在数组中不能有不同类型的静态语言中，多态性是否更有意义？ Python 允许列表包含不同的类型 [Cat(), Dog()] ，而在 Java 中，您必须将这些单独的动物实例定义为动物类型，将它们放在动物数组中并调用 talk() 方法对其进行迭代。我不确定多态性对 Python 有何帮助？

您忘记在您的 pay_bill 方法中写入 self 参数！

【参考方案2】：

上述答案中的多态性 C++ 示例是：

class Animal 
public:
  Animal(const std::string& name) : name_(name) 
  virtual ~Animal() 

  virtual std::string talk() = 0;
  std::string name_;
;

class Dog : public Animal 
public:
  virtual std::string talk()  return "woof!"; 
;  

class Cat : public Animal 
public:
  virtual std::string talk()  return "meow!"; 
;  

void main() 

  Cat c("Miffy");
  Dog d("Spot");

  // This shows typical inheritance and basic polymorphism, as the objects are typed by definition and cannot change types at runtime. 
  printf("%s says %s\n", c.name_.c_str(), c.talk().c_str());
  printf("%s says %s\n", d.name_.c_str(), d.talk().c_str());

  Animal* c2 = new Cat("Miffy"); // polymorph this animal pointer into a cat!
  Animal* d2 = new Dog("Spot");  // or a dog!

  // This shows full polymorphism as the types are only known at runtime,
  //   and the execution of the "talk" function has to be determined by
  //   the runtime type, not by the type definition, and can actually change 
  //   depending on runtime factors (user choice, for example).
  printf("%s says %s\n", c2->name_.c_str(), c2->talk().c_str());
  printf("%s says %s\n", d2->name_.c_str(), d2->talk().c_str());

  // This will not compile as Animal cannot be instanced with an undefined function
  Animal c;
  Animal* c = new Animal("amby");

  // This is fine, however
  Animal* a;  // hasn't been polymorphed yet, so okay.

【参考方案3】：

Python 中一个常见的真实示例是file-like objects。除了实际文件之外，其他几种类型，包括StringIO 和BytesIO，都是类似文件的。充当文件的方法也可以作用于它们，因为它们支持所需的方法（例如read、write）。