Objectifs d'apprentissage

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

• Écrire des méthodes redéfinies pour modifier le comportement des méthodes héritées.
• Utiliser super() pour accéder aux méthodes d'une superclasse.
• Identifier les applications du polymorphisme dans l'utilisation des méthodes et des fonctions.

Redéfinition de méthodes

Parfois, un programmeur souhaite modifier les fonctions dont hérite une sous-classe. Mint est une sous-classe qui possède les mêmes fonctionnalités que Plant, à l'exception d'une seule fonction. Une sous-classe peut redéfinir (override) une méthode de superclasse en définissant une méthode portant le même nom que celle de la superclasse.

class Tax:
  def calc_tax(self):
    print('Calculating tax')

class ContractTax(Tax):
  def calc_tax(self):
    print('Calculating contract tax')

class ContractTaxDE(ContractTax):
  def calc_tax():
    print('Calculating German contract tax')

my_tax = ContractTaxDE()
my_tax.calc_tax()

class Tax:
  def calc_tax(self):
    print('Calculating tax')
    total = 0 # To replace with calculation
    return total

class ContractTax:
  def calc_tax(self):
    print('Calculating contract tax')
    total = 0 # To replace with calculation
    return total

my_tax = ContractTax()
my_tax.calc_tax()

super()

super() est une méthode spéciale qui fournit un objet intermédiaire donnant accès à la superclasse depuis une sous-classe. super() est couramment utilisée pour appeler des méthodes de superclasse depuis une sous-classe. super() est couramment utilisée dans le __init__() d'une sous-classe pour assigner des attributs d'instance hérités. Ex. : super().__init__().

Polymorphisme

Le polymorphisme (polymorphism) est le concept selon lequel une entité peut prendre plusieurs formes. En programmation, un même nom peut être utilisé pour de multiples fonctionnalités. Dans le cadre de l'héritage, le polymorphisme est le fondement de la redéfinition de méthodes, puisque plusieurs méthodes partagent le même nom.

    class Plant:
      def display(self):
        print("I'm a plant")

    class Mint(Plant):
      def display(self):
        print("I'm a mint")

    class Lavender(Mint):
      def display(self):
        print("I'm a lavender")

    mint_1 = Mint()
    mint_1.display()

    lavender_1 = Lavender()
    lavender_1.display()

    I'm a mint
    I'm a lavender

Le polymorphisme peut également être utilisé avec des méthodes de classes sans lien de parenté. Le type de classe de l'objet appelant détermine la méthode exécutée.

    class Tax:
      def __init__(self, value):
        self.value = value
  
      def calc_tax(self):
        print("Calculating tax")
        total = 0.10 * self.value  # To replace with calculation
        return total
  
    class ContractTax:
      def __init__(self, value):
        self.value = value
  
      def calc_tax(self):
          print("Calculating contracts tax")
          total = 0.15 * self.value  # To replace with calculation
          return total
  
    my_tax = ContractTax(value=1000)  # Replace 1000 with any value
    result = my_tax.calc_tax()
    print(f"Total tax: ${result}")

    Calculating contracts tax
    Total tax: $150.00

Le polymorphisme permet d'appeler des méthodes avec différents types de paramètres. De nombreux opérateurs et fonctions intégrées possèdent cette propriété.

    tree_list = ["ash", "hazel", "oak", "yew"]
    tree_1 = tree_list[0]
    print(len(tree_list))
    print(len(tree_1))

    4
    3

class Polygon:
  def print_type(self):
    print("Polygon type")

class Rectangle(Polygon):
  def print_type(self):
    print("Rectangle type")

class Square(Rectangle):
  def print_type(self):
    print("Square type")

sq_1 = Square()
sq_1.print_type()