Signature

numérique de
KAMAL IDRISSI
Hamza
Date : 2022.03.22
14:45:28 +01'00'

Héritage.

1. Héritage simple.
 1. Héritage simple.

Plan de ce chapitre

a. Rappel du concept.
b. Syntaxe générale.
c. La visibilité “protected“.
d. Le constructeur de la classe fille.
e. Transmission des membres.
 1. Héritage simple.

a. Rappel du concept.
Héritage : relation de spécialisation/généralisation entre
deux classes. Elle indique qu’une classe dite classe fille
spécialise une autre classe dite classe mère, i.e. qu’elle
possède les attributs et les méthodes de la classe mère
plus d’autres qui lui sont propres.

On parle aussi de super classe et de sous classe.

 1. Héritage simple.

b. Syntaxe générale.
Syntaxe de la déclaration d’une relation d’héritage :

class classeMère:
“““une classe mère“““
...

class classeFille(classeMère):
“““une classe fille héritant de la
classe mère“““
...
 1. Héritage simple.

b. Syntaxe générale.
Exemple :

class rectangle:
"""gestion de rectangles"""
...

class paveDroit(rectangle):
"""gestion de boîtes à chaussures"""
...
 1. Héritage simple.

c. La visibilité “protected“.
• Pour l’instant nous avons rencontré deux types de visibilité
pour les attributs :

– publique : les attributs sont accessibles de partout.

– privée : les attributs ne sont accessibles qu’au sein de la
classe.

• Il existe une troisième catégorie très utile dans des

relations d’héritage : la visibilité protégée.
 1. Héritage simple.

c. La visibilité “protected“.
Visibilité “protégée“ :

•Un attribut est dit protégé si son utilisation est limitée à la

classe et ses descendantes.
 1. Héritage simple.

c. La visibilité “protected“.
Méthode pour déclarer un attribut “protégé“ :

•Lors de l’implémentation de la méthode “__init__” on

précèdera le nom de l’attribut en question d’un simple
underscore :

def __init__(self,para1,para2,...):
attributPublic = valeur
_attributProtégé = valeur
__attributPrivé = valeur
...
 1. Héritage simple.

c. La visibilité “protected“.
Exemple :

class rectangle:
def __init__(self,x,y):
self._x = x
self._y = y
def surface(self):
return self._x*self._y
 1. Héritage simple.

c. La visibilité “protected“.
Remarque importante :

• En Python, la déclaration d’un attribut avec une visibilité

protégée n’est qu’une indication à l’égard des utilisateurs de
la classe.

• En effet on pourra quand même accéder à l’attribut en

question depuis l’extérieur de la classe.

• Les langages C++ et Java seront plus stricts à ce sujet.

 1. Héritage simple.

c. La visibilité “protected“.
Exemple : une mauvaise pratique qui viole le principe
d’encapsulation.

photo = rectangle(10,15)
print(photo._x)
print(photo._y)
 1. Héritage simple.

d. Le constructeur de la classe fille.

Règle fondamentale :

•Le constructeur de la classe fille doit faire un appel explicite

au constructeur de la classe mère afin d’initialiser les
attributs hérités de celle-ci.
 1. Héritage simple.

d. Le constructeur de la classe fille.

Première syntaxe possible :

class classeFille(classeMère):
“““documentation de la classe fille“““
def __init__(self,para1,para2,...):
classeMère.__init__(self,para1,...)
...
 1. Héritage simple.

d. Le constructeur de la classe fille.

Exemple : une classe “paveDroit” héritant de la classe
rectangle précédente.

class paveDroit(rectangle):
def __init__(self,x,y,z):
rectangle.__init__(self,x,y)
self.__z = z
def volume(self):
return self._x*self._y*self.__z
 1. Héritage simple.

d. Le constructeur de la classe fille.

Exemple (suite) :

photo = rectangle(3,4)
print(photo.surface())
weston = paveDroit(3,4,10)
print(weston.volume())
 1. Héritage simple.

d. Le constructeur de la classe fille.

Seconde syntaxe possible :

class classeFille(classeMère):
“““documentation de la classe fille“““
def __init__(self,para1,para2,...):
super().__init__(para1,...)
...
 1. Héritage simple.

d. Le constructeur de la classe fille.

Exemple :

class paveDroit(rectangle):
def __init__(self,x,y,z):
super().__init__(x,y)
self.__z = z
def volume(self):
return self._x*self._y*self.__z
 1. Héritage simple.

e. Transmission des membres.

Retour (via des exemples) sur la transmission des membres
(attributs et méthodes) selon leur visibilité :

– publique : les membres sont accessibles de partout.

– protégé : les membres ne sont accessible qu’au sein de
la classe et de ses descendantes.
– privée : les attributs ne sont accessibles qu’au sein de la
classe.
 1. Héritage simple.

e. Transmission des membres.

Exemple 1 : utilisation d’une méthode publique de la classe
mère dans la classe fille.

class paveDroit(rectangle):
def __init__(self,x,y,z):
super().__init__(x,y)
self.__z=z
def volume(self):
return super().surface()*self.__z
 1. Héritage simple.

e. Transmission des membres.

Exemple 1 (suite, autre syntaxe) : utilisation d’une méthode
publique de la classe mère dans la classe fille.

class paveDroit(rectangle):
def __init__(self,x,y,z):
super().__init__(x,y)
self.__z=z
def volume(self):
return self.surface()*self.__z
 1. Héritage simple.

e. Transmission des membres.

Exemple 2 : utilisation d’attributs protégés de la classe mère
dans la classe fille.

class paveDroit(rectangle):
def __init__(self,x,y,z):
rectangle.__init__(self,x,y)
self.__z = z
def volume(self):
return self._x*self._y*self.__z
 1. Héritage simple.

e. Transmission des membres.

Exemple 3 : utilisation impossible d’attributs privés de la
classe mère dans la classe fille.

class rectangle:
def __init__(self,x,y):
self.__x = x
self.__y = y
def surface(self):
return self.__x*self.__y
 1. Héritage simple.

e. Transmission des membres.

Exemple 3 (suite) : utilisation impossible d’attributs privés de
la classe mère dans la classe fille.

class paveDroit(rectangle):
def __init__(self,x,y,z):
rectangle.__init__(self,x,y)
self.__z = z
def volume(self):
return self.__x*self.__y*self.__z
 1. Héritage simple.

e. Transmission des membres.

Exemple 3 (fin) : utilisation impossible d’attributs privés de la
classe mère dans la classe fille.

santoni = paveDroit(2,3,4)
print(santoni.volume())
Héritage.

2. Héritage multiple.
 2. Héritage multiple.

Plan de ce chapitre

a. Rappel du concept.
b. Syntaxe générale.
c. Le constructeur de la classe fille.
d. Recherche dans la hiérarchie.
 2. Héritage multiple.

a. Rappel du concept.
Héritage multiple : possibilité pour une classe de posséder
plusieurs classes mères.
 2. Héritage multiple.

a. Rappel du concept.
Remarque :

•Comme pour un héritage simple, la classe fille possède les

attributs et les méthodes de ses classes mères plus d’autres
qui lui sont propres.
 2. Héritage multiple.

b. Syntaxe générale.
Syntaxe de la déclaration d’une relation d’héritage multiple

class mère1:
“““une classe mère“““
...
class mère2:
“““une classe mère“““
...

class classeFille(mère1,mère2,...):
“““une classe fille héritant des
classes mère1 et mère2 “““
...
 2. Héritage multiple.

b. Syntaxe générale.
Exemple :

class carnivore:
"""gestions des carnivores"""
...

class herbivore:
"""gestion des herbivores"""
...

class omnivore(carnivore,herbivore):
"""gestion des omnivores"""
...
 2. Héritage multiple.

c. Le constructeur de la classe fille.

Règle fondamentale :

•Le constructeur de la classe fille doit faire un appel explicite

aux constructeurs des classes mères afin d’initialiser les
attributs hérités de celles-ci.
 2. Héritage multiple.

c. Le constructeur de la classe fille.

Syntaxe du constructeur :

class classeFille(mère1,mère2,...):
“““documentation de la classe fille“““
def __init__(self,para1,para2,...):
mère1.__init__(self,para1,...)
mère2.__init__(self,para1,...)
...
 2. Héritage multiple.

c. Le constructeur de la classe fille.

Exemple :

class carnivore:
def __init__(self,p):
self._poidsViande = p
def devorer(self):
print("Je mange ",self._poidsViande,
"kilogs de steack par jour")
 2. Héritage multiple.

c. Le constructeur de la classe fille.

Exemple (suite) :

class herbivore:
def __init__(self,p):
self._poidsHerbe = p
def brouter(self):
print("Je mange ",self._poidsHerbe,
"kilogs de gazon par jour")
 2. Héritage multiple.

c. Le constructeur de la classe fille.

Exemple (encore) :

class omnivore(carnivore,herbivore):
def __init__(self,pv,ph,h):
carnivore.__init__(self,pv)
herbivore.__init__(self,ph)
self.__humain = h
 2. Héritage multiple.

c. Le constructeur de la classe fille.

Exemple (fin) :

teddy = omnivore(10,5,False)
teddy.devorer()
teddy.brouter()
 2. Héritage multiple.

d. Recherche dans la hiérarchie.

Considérons une relation d’héritage multiple du type :

class fille(mère1,mère2,mère3...):
“““une classe fille héritant des classes mère1,
mère2 “““
...
 2. Héritage multiple.

d. Recherche dans la hiérarchie.

• Si sur un objet de la classe fille on appelle une méthode
qui n’appartient pas à cette classe, la recherche
s’effectuera de gauche à droite dans la liste des classes
mères.

• Cela signifiera que l’on regardera d’abord si la classe

“mère1“ possède la méthode en question :

– Si oui, on applique cette méthode et la recherche est

terminée.
– Si non, on considère la classe “mère2“. Etc.
 2. Héritage multiple.

d. Recherche dans la hiérarchie.

Remarque :

•Si la recherche est infructueuse dans les classes “mère1”,

“mère2”, ... on la continue dans les classes parentes de
celles-ci.

•On procède alors de la même façon que précédemment, en

parcourant la liste de la gauche vers la droite.
 2. Héritage multiple.

d. Recherche dans la hiérarchie.

Exemple : deux classes qui seront nos classes mères

class a:
"""une classe a"""
def exemple(self):
print("je l'ai trouvée dans a")

class b:
"""une classe b"""
def exemple(self):
print("je l'ai trouvée dans b")
 2. Héritage multiple.

d. Recherche dans la hiérarchie.

Exemple (suite) : “c” hérite d’abord de “a” puis de “b”

class c(a,b):
"""une classe c qui hérite de a et b"""

test = c()
test.exemple()
 2. Héritage multiple.

d. Recherche dans la hiérarchie.

Exemple (fin) : “c” hérite d’abord de “b” puis de “a”

class c(b,a):
"""une classe c qui hérite de a et b"""

test = c()
test.exemple()