Objectifs d'apprentissage

À la fin de cette section, vous devriez être en mesure de :

• Construire une classe qui hérite de plusieurs superclasses.
• Identifier le problème du diamant au sein de l'héritage multiple.
• Construire une classe mixin pour ajouter des fonctionnalités à une sous-classe.

Notions de base sur l'héritage multiple

L'héritage multiple (multiple inheritance) est un type d'héritage dans lequel une classe hérite de plusieurs classes. Une classe qui hérite de plusieurs classes énumère toutes ses superclasses dans la liste d'héritage de sa définition de classe. Ex. : class SubClass(SuperClass_1, SuperClass_2).

    class A:
      def __init__(self, a_attr=2):
        self.a_attr = a_attr

    class B:
      def __init__(self, b_attr=4):
        self.b_attr = b_attr

    class C(A, B):
      def __init__(self, a_attr=5, b_attr=10, c_attr=20):
        A.__init__(self, a_attr)
        B.__init__(self, b_attr)
        self.c_attr = c_attr

    b_inst = B(2)
    c_inst = C(1, 2)

Le problème du diamant et les classes mixin

L'héritage multiple doit être mis en œuvre avec précaution. Le problème du diamant (diamond problem) survient lorsqu'une classe hérite de plusieurs classes qui partagent une superclasse commune. Ex. : Dessert et BakedGood héritent toutes deux de Food, et ApplePie hérite de Dessert et de BakedGood.

Figure 13.2 Le problème du diamant. Si

Dessert

et

BakedGood

redéfinissent toutes deux une méthode de

Food

, la méthode redéfinie de

Food

dont hérite

ApplePie

est ambiguë. Par conséquent, l'héritage en forme de diamant doit être évité.

Les classes mixin favorisent la modularité et peuvent éliminer le problème du diamant. Une classe mixin :

• N'a pas de superclasse
• Possède des attributs et des méthodes destinés à être ajoutés à une sous-classe
• N'est pas instanciée (Ex. : étant donné une classe MyMixin, my_inst = MyMixin() ne devrait jamais être utilisé.)

Les classes mixin (mixin classes) sont utilisées dans l'héritage multiple pour ajouter des fonctionnalités à une sous-classe sans introduire de complications liées à l'héritage.

    class Plant:
      def photosynth(self):
        print("Photosynthesizing")

      def eat(self):
        print("Eating")

    class Rose(Plant):
      pass

    class Pitcher(Plant):
      pass
    
    class VenusFlyTrap(Plant):
      pass

class Plant:
  def photosynth(self):
    print("Photosynthesizing")

class Rose(Plant):
  pass

class Pitcher(Plant):
  def eat(self):
    print("Eating")

class VenusFlyTrap(Plant)
  def eat(self):
    print("Eating")

class Plant:
  def photosynth(self):
    print("Photosynthesizing")

class X:
  def eat(self):
    print("Eating")

class Rose(Plant):
  pass

class Pitcher(Plant, X):
  pass

class VenusFlyTrap(Plant, X)
  pass