Étendre des classes pour en créer de nouvelles 擴展類以創建新類

Comme vous pouvez l’imaginer, créer une classe pleinement fonctionnelle, susceptible d’être utilisée dans des applications du monde réel, demande beaucoup de temps et de travail, car les classes sont conçues pour effectuer de nombreuses tâches. Fort heureusement, Python supporte une fonctionnalité appelée héritage. Cet héritage vous permet de récupérer les fonctionnalités voulues d’une classe parent lorsque vous créez une classe enfant. Éliminer les fonctions dont vous n’avez pas besoin, et en ajouter d’autres vous permet de créer des classes relativement rapidement et avec moins d’efforts de votre part. De plus, du fait que le code parent a déjà été testé, vous avez moins de soucis à vous faire quant au bon fonctionnement de votre nouvelle classe. Les sections qui suivent vous montrent comment profiter de ce processus d’héritage.

Construire la classe enfant

Les classes parents sont normalement des super-ensembles de quelque chose. Vous pourriez par exemple créer une classe parent appelée Voiture, puis définir des classes enfants représentant divers modèles de véhicules. Dans notre exemple, nous allons plus modestement fabriquer une classe parent appelée Animals, puis nous en servir pour nous intéresser à une classe enfant dédiée à certains gallinacés, Chicken. Bien entendu, vous pourriez facilement ajouter d’autres classes enfants pour d’autres types d’animaux, comme une classe Gorille. Cependant, nous nous contenterons ici d’une classe parent, et d’une classe enfant. Vous les retrouvez dans le Listing, ainsi que dans le fichier téléchargeable Animals.py.

Listing : Construire une classe parent et une classe enfant.

class Animal:
   def __init__(self, Name="", Age=0, Type=""):
      self.Name = Name
      self.Age = Age
      self.Type = Type

   def GetName(self):
      return self.Name

   def SetName(self, Name):
      self.Name = Name

   def GetAge(self):
      return self.Age

   def SetAge(self, Age):
      self.Age = Age

   def GetType(self):
      return self.Type

   def SetType(self, Type):
      self.Type = Type

   def __str__(self):
      return "{0} est un {1} âgé de {2} ans.".format(self.Name,
                                            self.Type,
                                            self.Age)

class Chicken(Animal):
   def __init__(self, Name="", Age=0):
      self.Name = Name
      self.Age = Age
      self.Type = "poulet"

   def SetType(self, Type):
      print("Désolé, {0} sera toujours un {1}."
            .format(self.Name, self.Type))

   def MakeSound(self):
      print("{0} dit Cot, Cot, Cot, Codette !".format(self.Name))

La classe Animal gère trois caractéristiques : le nom (Name), l’âge (Age) et le type (Type). Une véritable application aurait vraisemblablement besoin de davantage de paramètres, mais ceux-ci nous suffiront pour cet exemple. Le code contient également les accesseurs nécessaires pour ces trois caractéristiques. La méthode __str__() complète le tableau en affichant un message simple qui décrit ce qu’est l’animal.

La classe Chicken hérite de la définition de la classe Animal. Remarquez l’emploi de Animal entre parenthèses après le nom de la classe Chicken. Ceci signale à Python que Chicken est un enfant de Animal, et donc qu’il hérite des caractéristiques de celui-ci.

Notez aussi que le constructeur Chicken n’accepte comme entrées que Name et Age. L’utilisateur n’a donc pas besoin de fournir une valeur Type, puisque vous savez déjà que l’animal en question est un poulet. Le nouveau constructeur remplace celui de Animal. Les trois attributs sont toujours en place, mais Type est compris directement dans le constructeur Chicken.

Quelqu’un pourrait être tenté de faire preuve d’originalité en définissant le poulet comme étant un gorille. De ce point de vue, la classe Chicken prend le pas sur le mutateur SetType (). En tentant de changer le type Chicken, l’utilisateur ne fait que recevoir un message. Normalement, ce genre de problème devrait être traité par une exception, mais la solution proposée ici fonctionne mieux, car elle rend le code plus clair.

Finalement, le code de Chicken ajoute une fonctionnalité supplémentaire, MakeSound(). Si quelqu’un veut entendre le cri du poulet, il n’aura pas besoin d’écouteurs, mais il verra du moins le message correspondant s’afficher à l’écran.

Tester la classe dans une application

Tester la classe Chicken signifie tester également la classe Animal, puisque la première est une extension de la seconde. Certaines fonctionnalités sont différentes, mais tout n’a pas besoin d’être utilisé en même temps. La classe Animal est simplement un parent d’un type spécifique d’animaux, en l’occurrence des poulets. Les étapes qui suivent illustrent le fonctionnement de la classe Chicken de manière à montrer comment fonctionne l’héritage. Vous pouvez également retrouver ce code dans le fichier téléchargeable AnimalsTest.py.

1. Ouvrez une fenêtre de fichier Python.
   Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :

   import Animals
   
   MyChicken = Animals.Chicken("Arthur", 2)
   print(MyChicken)
   MyChicken.SetAge(MyChicken.GetAge() + 1)
   print(MyChicken)
   MyChicken.SetType("Gorille")
   print(MyChicken)
   MyChicken.MakeSound()

   La première étape consiste à importer le module Animals. Souvenez-vous que vous importez toujours le nom du fichier, pas la ou les classes qu’il contient. Ici, le fichier Animals.py contient deux classes : Animal et Chicken.
   L’exemple crée un objet « poulet », MyChicken, appelé Arthur, de deux ans d’âge. Il traite ensuite cet objet de différentes manières. Par exemple, Arthur prend un peu d’âge, et donc le code actualise celui-ci. Remarquez comment le code combine l’usage d’un mutateur/setter, SetAge (), avec un accesseur/getter, GetAge (), pour effectuer ce calcul. Après chaque modification, le code affiche les objets résultants. L’étape finale demande à Arthur de prononcer quelques mots.
3. Choisissez la commande Run Module dans le menu Run.
   Une fenêtre Python en mode Shell va s’ouvrir. Vous y voyez les étapes utilisées pour travailler avec MyChicken comme l’illustre la Figure. Comme vous pouvez le constater, l’héritage simplifie grandement la création de nouvelles classes lors que celles-ci possèdent suffisamment de points communs pour qu’il soit intéressant de construire une classe parent qui contiendra l’essentiel du code.
   Figure : Arthur prononce quelques mots après son anniversaire.

   Arthur est un poulet âgé de 2 ans.
   Arthur est un poulet âgé de 3 ans.
   Désolé, Arthur sera toujours un poulet.
   Arthur est un poulet âgé de 3 ans.
   Arthur dit Cot, Cot, Cot, Codette !