Objektorientierte Vererbung und Polymorphismus in Python

Der Inhalt, der in diesem Artikel mit Ihnen geteilt wird, befasst sich mit der objektorientierten Vererbung und dem Polymorphismus von Python. Er hat einen bestimmten Referenzwert.

In der OOP-Programmierung können wir darauf zurückgreifen Von einer vorhandenen Klasse erben. Die neue Klasse wird als Unterklasse (Subclass) bezeichnet, und die geerbte Klasse wird als Basisklasse, übergeordnete Klasse oder Superklasse (Basisklasse, Supper-Klasse) bezeichnet.

Zum Beispiel haben wir eine Klasse namens Animal geschrieben. Es gibt eine run()-Methode, die direkt drucken kann:

class Animal(object):
    def run(self):
        print('Animal is running...')

Wenn wir Hunde- und Katzenklassen schreiben müssen, können wir das tun Erben Sie direkt von der Animal-Klasse:

class Dog(Animal):
    pass
class Cat(Animal):
    pass

Für Dog ist Animal die übergeordnete Klasse und für Animal ist Dog die Unterklasse. Katze und Hund sind ähnlich.

Was sind die Vorteile einer Erbschaft? Der größte Vorteil besteht darin, dass die Unterklasse alle Funktionen der übergeordneten Klasse erhält. Da Animal die run()-Methode implementiert, verfügen Dog und Cat als ihre Unterklassen automatisch über die run()-Methode, ohne etwas zu tun:

dog = Dog()
dog.run()

cat = Cat()
cat.run()

Animal is running...
Animal is running...

Natürlich können Sie Unterklassen einige Methoden hinzufügen , wie zum Beispiel die Dog-Klasse.

Der zweite Vorteil der Vererbung erfordert, dass wir den Code ein wenig verbessern. Sie sehen, egal, ob es sich um einen Hund oder eine Katze handelt: Wenn sie run() ausführen, wird angezeigt, dass „Tier läuft ...“ angezeigt wird. Der logische Weg besteht darin, jeweils „Hund läuft ...“ und „Katze läuft ...“ anzuzeigen, also die Verbesserungen zu den Klassen „Hund“ und „Katze“ lauten wie folgt:

class Animal(object):
    def run(self):
        print('Animal is running...')class Dog(Animal):
    def run(self):
        print('Dog is haha running...')

    def eat(self):
        print('Eating meat...')
class Cat(Animal):
    def run(self):
        print('Cat is miaomiao running...')

    def eat(self):
        print('Eating fish...')dog = Dog()
dog.run()
dog.eat()

cat = Cat()
cat.run()
cat.eat()

再次运行，结果如下：

Dog is haha running...
Eating meat...
Cat is miaomiao running...
Eating fish...

Wenn die gleiche run()-Methode sowohl in der Unterklasse als auch in der übergeordneten Klasse vorhanden ist, sprechen wir von „run“. ()-Methode der Unterklasse () deckt die run() der übergeordneten Klasse ab. Wenn der Code ausgeführt wird, wird immer die run() der Unterklasse aufgerufen. Auf diese Weise erhalten wir einen weiteren Vorteil der Vererbung: Polymorphismus.

Um zu verstehen, was Polymorphismus ist, müssen wir zunächst etwas mehr über Datentypen erklären. Wenn wir eine Klasse definieren, definieren wir tatsächlich einen Datentyp. Die von uns definierten Datentypen unterscheiden sich nicht von den mit Python gelieferten Datentypen wie str, list und dict:

a = list()#a是list类型#a是list类型

b = Animal() #b是Animal类型

c = Dog #c是Dog类型

Um festzustellen, ob eine Variable einen bestimmten Typ hat, können Sie isinstance( ) um Folgendes zu bestimmen:

>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True

Es scheint, dass a, b und c den drei Listentypen Tier und Hund entsprechen.

Aber warten Sie, versuchen Sie es:

>>> isinstance(c, Animal)
True

Es scheint, dass c nicht nur Hund ist, sondern c Tier!

Aber wenn Sie sorgfältig darüber nachdenken, macht dies Sinn, denn Dog erbt von Animal. Wenn wir eine Instanz c von Dog erstellen, denken wir, dass der Datentyp von c Dog ist. Aber es ist nicht falsch, dass c auch „Tier“ ist und ursprünglich eine Tierart ist.

Wenn also in der Vererbungsbeziehung der Datentyp einer Instanz eine Unterklasse ist, kann ihr Datentyp auch als übergeordnete Klasse betrachtet werden. Das Gegenteil ist jedoch nicht der Fall:

>>> b = Animal()
>>> isinstance(b, Dog)
False

Hund kann als Tier betrachtet werden, aber Tier kann nicht als Hund betrachtet werden.

Um die Vorteile des Polymorphismus zu verstehen, müssen wir eine weitere Funktion schreiben, die eine Variable vom Typ Animal akzeptiert:

def run_twice(animal):
    animal.run()
    animal.run()

Wenn wir eine Instanz von Animal übergeben, wird run_twice( ) ausgegeben :

>>> run_twice(Animal())
Animal is running...
Animal is running...

Wenn wir die Instanz von Dog übergeben, gibt run_twice() Folgendes aus:

>>> run_twice(Dog())
Dog is running...
Dog is running...

Es sieht nicht interessant aus, aber denken Sie sorgfältig darüber nach. Wenn wir einen anderen Schweinetyp definieren, der ebenfalls von Animal abgeleitet ist:

class Pig(Animal):
    def run(self):
        print('Pig is running slowly...')

Wenn wir run_twice(pig()) aufrufen

>>> run_twice(Pig())
Pig is running slowly...
Pig is running slowly...

Der Vorteil des Polymorphismus besteht darin, dass wann Wenn wir müssen Wenn wir Hund, Katze und Schwein übergeben, müssen wir nur den Tiertyp empfangen, da Hund, Katze und Schwein alle Tiertypen sind, und dann entsprechend dem Tiertyp arbeiten. Da der Animal-Typ über eine run()-Methode verfügt, ruft jeder übergebene Typ automatisch die run()-Methode des tatsächlichen Typs auf, sofern es sich um eine Animal-Klasse oder Unterklasse handelt. Dies ist die Bedeutung von Polymorphismus:

Für eine Variable müssen wir nur wissen, dass sie vom Typ Animal ist. Ohne den genauen Subtyp zu kennen, können wir die run()-Methode sicher aufrufen und ob der spezifische Aufruf der run()-Methode für Animal funktioniert. Hund, Katze oder Schwein Auf dem Objekt wird es durch den genauen Typ des Objekts zur Laufzeit bestimmt. Dies ist die wahre Stärke des Polymorphismus: Der Aufrufer kümmert sich nur um den Aufruf, unabhängig von den Details, wenn wir eine neue Unterklasse hinzufügen Bei Animal müssen wir nur sicherstellen, dass die run()-Methode korrekt geschrieben ist, unabhängig davon, wie der Originalcode aufgerufen wird. Dies ist das berühmte „offene und geschlossene“ Prinzip:

ist für Änderungen geschlossen: Es besteht keine Notwendigkeit, Funktionen wie run_twice() zu ändern, die auf dem Typ „Animal“ basieren.

Vererbung kann auch Ebene für Ebene vererbt werden. Jede Klasse kann letztendlich auf das Stammklassenobjekt zurückgeführt werden. Diese Vererbungsbeziehungen sehen aus wie ein umgekehrter Baum:

Verwandte Empfehlungen:

Objektorientierte Python-Zugriffsbeschränkungen

Objektorientierte Python-Klassen und Beispiele

Das obige ist der detaillierte Inhalt vonObjektorientierte Vererbung und Polymorphismus in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!