Chapitre 18 - Héritage
======================

Rappel - composition
---------------------

Dans le chapitre 13 on a parlé de *composition* qui décrit une relation entre deux classes.

Pour rappel::


    class Chat:
        def __init__(self, nom):
            self.nom = nom

        def ronronne(self):
            print(self.nom, 'fait: "prrrrr"')

        def caresse(self):
            self.ronronne()


    class Enfant:
        def __init__(self, prénom, chat):
            self.chat = chat

        def console(self):
            self.chat.caresse()



Vocabulaire
-----------

Ici on va parler d'héritage, qui décrit une autre relation entre classes, appelée parfois un peu abusivement "partage de code".

Pour indiquer qu'une classe ``B`` hérite d'une classe ``A``, on écrit ``A`` dans des parenthèses au moment de
déclarer la classe ``B``::

    class A:
       ...

    class B(A):
        ...


Les trois formulations suivantes sont souvent employées:

* A est la classe *parente* de B.
* B *hérite* de A.
* B est une classe *fille* de A.

Utilisation
-----------

Si une méthode n'est pas trouvée dans la classe courante, Python ira la
chercher dans la classe parente::

    class A:
       def méthode_dans_a(self):
           print("dans A")

    class B(A):
       def méthode_dans_b(self):
           print("dans B")


    b = B()
    b.méthode_dans_a()
    # Affiche: 'dans B', comme d'habitude

    b.méthode_dans_a()
    # Affiche: 'dans A'

Ordre de résolution
--------------------

S'il y a plusieurs classes parentes, Python les remonte toutes une à une.
On dit aussi qu'il y a une *hiérarchie* de classes::

    class A:
        def méthode_dans_a(self):
             print("dans A")

    class B(A):
        def méthode_dans_b(self):
             print("dans B")

    class C(B):
        def méthode_dans_c(self):
             print("dans C")

    c = C()
    c.méthode_dans_a()
    # affiche: 'dans A'

Avec \_\_init\_\_
--------------------

La résolution fonctionne pour toutes les méthodes, y compris ``__init__``::

    class A:
        def __init__(self):
             print("initialisation de A")

    class B(A):
        ...

    b = B()
    # affiche: "initialisation de A"

Attributs
----------

Même mécanisme pour les attributs::

    class A:
        def __init__(self):
            self.attribut_de_a = 42

    class B(A):
        ...

    b = B()
    print(b.attribut_de_a)
    # affiche: 42

Surcharge
----------

On peut aussi *surcharger* la méthode de la classe parente dans la classe fille::

    class A:
       def une_méthode(self):
           print("je viens de la classe A")

    class B(A):
        def une_méthode(self):
            print("je viens de la classe B")


    b = B()
    b.une_méthode()
    # affiche: "je viens de la classe B'

super()
-------

On peut utiliser ``super()`` pour chercher *explicitement* une méthode dans la classe parente::


    class A:
       def une_méthode(self):
           print("je viens de la classe A")

    class B(A):
        def une_méthode(self):
            super().une_méthode()
            print("je viens de la classe B")

    b = B()
    b.une_méthode()
    # affiche:
    # je viens de la classe A
    # je viens de la classe B

super() et \_\_init\_\_
------------------------

Erreur très courante::

    class A:
       def __init__(self):
           self.attribut_de_a = "bonjour"

    class B(A):
        def __init__(self):
           self.attribut_de_b = 42

     b = B()
     print(b.attribut_de_b)
     # affiche: 42
     print(b.attribut_de_a)
     # erreur:  AttributeError

On a surchargé ``A.__init__()``, du coup l'initialisation de A n'a jamais
été faite.

La plupart du temps, si ``A`` et ``B`` ont de constructeurs, on appellera
``super().__init__()`` dans le constructeur de la classe fille::

    class A:
       def __init__(self):
           self.attribut_de_a = "bonjour"

    class B(A):
        def __init__(self):
           self.attribut_de_b = 42

     b = B()
     print(b.attribut_de_b)
     # affiche: 42
     print(b.attribut_de_a)
     # affiche:  "bonjour"