Héritage et polymorphisme orientés objet Python

Le contenu partagé avec vous dans cet article concerne l'héritage et le polymorphisme orientés objet Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer

En programmation POO, lorsque nous définissons Une classe peut. hériter d'une classe existante. La nouvelle classe est appelée une sous-classe (Sous-classe) et la classe héritée est appelée une classe de base, une classe parent ou une super classe (Classe de base, Classe Supper).

Par exemple, nous avons écrit une classe nommée Animal. Il existe une méthode run() qui peut imprimer directement :

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

Lorsque nous avons besoin d'écrire des classes Dog et Cat, nous pouvons Héritez directement de la classe Animal :

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

Pour Dog, Animal est sa classe parent, et pour Animal, Dog est sa sous-classe. Le chat et le chien sont semblables.

Quels sont les avantages de l'héritage ? Le plus gros avantage est que la sous-classe obtient toutes les fonctions de la classe parent. Puisque Animal implémente la méthode run(), Dog et Cat, en tant que sous-classes, ont automatiquement la méthode run() sans rien faire :

dog = Dog()
dog.run()

cat = Cat()
cat.run()

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

Bien sûr, vous pouvez ajouter quelques méthodes aux sous-classes , comme la classe Dog.

Le deuxième avantage de l'héritage nous oblige à apporter une petite amélioration au code. Vous voyez, que ce soit Chien ou Chat, lorsqu'ils exécutent(), ils affichent Animal est en cours d'exécution.... La manière logique est d'afficher Chien est en cours d'exécution... et Chat est en cours d'exécution... respectivement, donc les améliorations aux classes Dog et Cat sont les suivantes :

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...

Lorsque la même méthode run() existe à la fois dans la sous-classe et dans la classe parent, on dit que la méthode run() () de la sous-classe () couvre le run() de la classe parent Lorsque le code est en cours d'exécution, le run() de la sous-classe sera toujours appelé. De cette façon, nous bénéficions d’un autre avantage de l’héritage : le polymorphisme.

Pour comprendre ce qu'est le polymorphisme, nous devons d'abord expliquer un peu plus les types de données. Lorsque nous définissons une classe, nous définissons en fait un type de données. Les types de données que nous définissons ne sont pas différents des types de données fournis avec Python, tels que str, list et dict :

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

b = Animal() #b是Animal类型

c = Dog #c是Dog类型

Pour déterminer si une variable est d'un certain type, vous pouvez utiliser isinstance( ) pour déterminer :

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

Il semble que a, b et c correspondent bien aux trois types de liste, Animal et Chien.

Mais attendez, essayez :

>>> isinstance(c, Animal)
True

Il parait que ce n'est pas que Chien, c'est Animal !

Mais si vous y réfléchissez bien, cela a du sens, car Dog hérite d'Animal Lorsque nous créons une instance c de Dog, nous pensons que le type de données de c est Dog. Mais il n’est pas faux que c’est aussi Animal. Le Chien est à l’origine un type d’Animal !

Ainsi, dans la relation d'héritage, si le type de données d'une instance est une sous-classe, son type de données peut également être considéré comme la classe parent. Cependant, l'inverse n'est pas vrai :

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

Le chien peut être considéré comme un animal, mais l'animal ne peut pas être considéré comme un chien.

Pour comprendre les avantages du polymorphisme, nous devons écrire une autre fonction qui accepte une variable de type Animal :

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

Lorsque nous passons une instance d'Animal, run_twice() affiche :

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

Quand on passe dans l'instance de Dog, run_twice() affiche :

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

Ça n'a pas l'air intéressant, mais réfléchissez bien, si l'on définit un autre type de porc, également dérivé d'Animal :

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

Quand on appelle run_twice(pig())

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

L'avantage du polymorphisme est que quand on a besoin de si nous passons Chien, Chat et Cochon, nous n'avons besoin que de recevoir le type Animal, car Chien, Chat et Cochon sont tous des types Animal, et fonctionnent ensuite selon le type Animal. Puisque le type Animal a une méthode run(), tout type transmis, tant qu'il s'agit d'une classe ou d'une sous-classe Animal, appellera automatiquement la méthode run() du type réel. C'est la signification du polymorphisme :

.

Pour une variable, il suffit de savoir qu'elle est de type Animal, sans connaître exactement son sous-type, on peut appeler en toute sécurité la méthode run(), et si l'appel spécifique de la méthode run() fonctionne sur Animal, Chien, chat ou cochon Sur l'objet, cela est déterminé par le type exact de l'objet au moment de l'exécution. C'est le véritable pouvoir du polymorphisme : l'appelant ne se soucie de l'appel, quels que soient les détails, lorsque nous ajoutons une nouvelle sous-classe. d'Animal, nous devons simplement nous assurer que la méthode run() est écrite correctement, quelle que soit la manière dont le code d'origine est appelé. C'est le fameux principe "ouvert et fermé" :

est fermé à la modification : il n'est pas nécessaire de modifier des fonctions comme run_twice() qui s'appuient sur le type Animal.

L'héritage peut également être hérité niveau par niveau. Toute classe peut finalement être retracée jusqu'à l'objet de classe racine. Ces relations d'héritage ressemblent à un arbre inversé :

Recommandations associées :

Restrictions d'accès orientées objet Python

Classes et exemples orientés objet Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!