Programmation Orientée Objets

Paradigme
Un paradigme est une manière de voir les choses, une représentation du monde.

En informatique, un paradigme est employé pour exprimer la façon dont un

système a été conçu et pensé dans ses grandes lignes.

On peut classer les langages de programmation par paradigmes de programmation :

La programmation impérative repose sur des notions qui vous sont familières :
●
la séquence d'instructions (les instructions d'un programme s'exécutent l'une après l'autre)
●
l'affectation (on attribue une valeur à une variable, par exemple : a = 5)
●
l'instruction conditionnelle (if / else)
●
la boucle (while et for)

La programmation orientée objets intègre un nouveau type d'entité : l'objet.

Ce dernier intègre les données et les traitements. Les données trouvent ainsi leur place au sein de
brique logicielles facilitant la ré-utilisabilité du code, ...

La programmation fonctionnelle a pour but principal d'éviter les effets de bord.

Pour cela elle se concentre essentiellement sur les fonctions, d'où son appellation : elle s'interdit
toute variable globale pour ne faire appel qu'à des fonctions qui peuvent être imbriquées.

La programmation évènementielle ...

2
Principes de la Programmation Orientée Objets

La programmation orientée objet (POO) consiste en la création et l'interaction de briques

logicielles appelées objets.
Un objet peut représenter à peu près n’importe quoi :
●
un concept,
●
une idée,
●
une personne,
●
un pays,
●
une carte,
●
un jeu...
Il est doté :
●
d’attributs (variables, propriétés)
●
et de méthodes pour agir sur lui-même ou interagir avec d’autres objets.
On modélise ainsi des éléments réels par des objets virtuels.

3
Principes de la Programmation Orientée Objets
Les classes :

Une classe est une structure qui permet de définir différents objets de même type.

Voici la classe Voiture

Dans le monde réel, une voiture est définie par :
●
Sa couleur
●
Son modèle
●
Son année de production
●
Le type de carburant
●
l'état du moteur (arrêt ou démarré)
●
La vitesse
●
...

On va également créer des méthodes permettant

d'interagir avec la voiture :
●
démarrer
●
arrêter
●
accélérer

4
Principes de la Programmation Orientée Objets
une Classe est comme un plan ou un schéma permettant de créer des objets. Il faut
distinguer :
●
le plan d'une voiture est la classe "Voiture"
●
les différentes constructions à partir de ce plan sont les objets.
●
on appelle chaque construction : instance de la classe Voiture.

Objet1
couleur: vert
modele: peugeot 206
annee_production: 2010
type_carburant: SP95
etat_moteur: arrêt
vitesse : 0 (0 km/h)

Objet2
couleur: jaune
modele: Renault Clio
annee_production: 2012
type_carburant: Diesel
etat_moteur: démarré
vitesse : 90 (km/h)

Les objets : objet1 et objet2 comprennent les méthodes: demarrer(), arreter(), accelerer() et construire().

5
 Implémentation d'une classe et création d'objets
On déclare une classe en Python à l'aide du mot-clé class .

Pour déterminer et initialiser les attributs d'un objet que l'on crée, on utilise une méthode
particulière appelée constructeur. En Python, son nom est imposé : __init__

__init__ : constructeur.
Obligatoire, appelé implicitement
à la création d’un objet.

class Voiture:
def __init__(self,coul,mod,annee,carburant,etat,vit):
self.couleur = coul
self : désigne l’objet auquel
self.modele = mod
s’applique la méthode.
Initialisation self.annee_production = annee
des attributs. self.type_carburant = carburant
self.etat_moteur=etat
self.vitesse = vit

Création
de l’objet voiture1 voiture1 = Voiture("vert","peugeot 206","2010","SP95","arrêt",0)
de classe Voiture

6
Implémentation d'une classe et création d'objets
class Voiture:
def __init__(self,coul,mod,annee,carburant,etat,vit):
self.couleur = coul
self.modele = mod
self.annee_production = annee
self.type_carburant = carburant
self.etat_moteur=etat
self.vitesse = vit

voiture1 = Voiture("vert","peugeot 206","2010","SP95","arrêt",0)

Pour accéder à l'attribut d'une instance (ou d'un objet), on utilise la syntaxe suivante :
nom_de_l_instance.nom_de_l_attribut

print("Couleur :",voiture1.couleur) Couleur : vert

print("Modèle :",voiture1.modele) Modèle : peugeot 206
print("Année de production",voiture1.annee_production) Année de production 2010
print("Type de carburant :",voiture1.type_carburant) Type de carburant : SP95
print("Etat du moteur :",voiture1.etat_moteur) Etat du moteur : arrêt
print("Vitesse :",voiture1.vitesse,"km/h") Vitesse : 0 km/h

7
Implémentation d'une classe et création d'objets
Modification de la valeur d’un attribut :

nom_de_l_instance.nom_de_l_attribut = Nouvelle valeur

Par exemple, nous pouvons changer la couleur de la voiture

voiture1.couleur = "rouge"
Couleur : rouge
print("Couleur :",voiture1.couleur) Modèle : peugeot 206
print("Modèle :",voiture1.modele)

8
Implémentation d'une classe et création d'objets
Définition des méthodes d’une classe :

Class nom_de_la_classe :
def __init__(self, ……….) : # constructeur de la classe
…

def nom_de_la méthode(self, param1, param2, …) : définition de la méthode

...
class Voiture:
def __init__(self, coul, mod, annee, carburant, etat, vit):
...

def demarrer(self):
if self.vitesse == 0 and self.etat_moteur == "arrêt":
self.etat_moteur = "démarré"
return "voiture démarrée"
else:
return "Impossible"

def arreter(self):
if self.vitesse == 0 and self.etat_moteur == "démarré":
self.etat_moteur = "arrêt"

return "voiture arrêté"

else:
return "Impossible"

def accelerer(self, val):

if self.etat_moteur == "démarré":
self.vitesse = self.vitesse + val

9
Implémentation d'une classe et création d'objets
Utilisation des méthodes d’un objet :
voiture1 = Voiture("vert","peugeot 206","2010","SP95","arrêt",0)

print("Démarrage de la voiture")
voiture1.demarrer() # On démarre la voiture
print("Moteur :",voiture1.etat_moteur) # on peut voir que la voiture a démarré.
print("Vitesse :",voiture1.vitesse) # on peut voir que la voiture ne roule pas.
print("--------------------")

print("Accélération de la voiture de 20 km/h")

voiture1.accelerer(20) # On accelère la voiture
print("Vitese :",voiture1.vitesse) # on peut voir que la voiture roule.
print("--------------------")

Démarrage de la voiture
Moteur : démarré
Vitesse : 0
--------------------------------
Accélération de la voiture de 20 km/h
Moteur : démarré
Vitesse : 20

10
Exercice 1

On souhaite utiliser la programmation orientée-objet afin de créer un classe Plante

caractérisée ainsi :

●
une plante est d’une certaine espèce
●
une plante mesure une certaine taille (un nombre décimal)
●
une plante a un certain âge (nombre entier positif ou nul)
●
une plante a un âge maximal (nombre entier positif ou nul)
●
une plante possède un certain nombre de fleurs (nombre entier positif ou nul)
●
une plante possède un certain nombre de fruit (nombre entier positif ou nul)
●
une plante est capable de pousser (sa taille augmente d’un certain nombre de
centimètres)
●
une plante peut être fanée si son âge dépasse les 90% de son âge maximal

Proposer des attributs et des méthodes permettant de coder la classe Plante.

11
Exercice 2

Écrire en python la classe Cercle ayant les caractéristiques suivantes :

●
un cercle n’a qu’un seul attribut : son rayon. Ce nombre décimal est positif
ou nul
●
on doit pouvoir récupérer ce rayon
●
on doit pouvoir modifier ce rayon
●
on doit pouvoir calculer son périmètre à l’aide d’une méthode
●
on doit pouvoir calculer son aire à l’aide d’une méthode

12
Exercice 3
Dans cet exercice, on étudie une méthode de chiffrement de chaînes de caractères
alphabétiques.

Pour des raisons historiques, cette méthode de chiffrement est appelée "code de César".

On considère que les messages ne contiennent que les lettres capitales de l’alphabet
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" et la méthode de chiffrement utilise un nombre entier
fixé appelé la clé de chiffrement.

Voir Cours.

13
Encapsulation
En définissant la méthode arreter(self) de la classe voiture :

def arreter(self):

if self.vitesse == 0 and self.etat_moteur == "démarré" :

self.etat_moteur = "arrêt"

return "voiture arrêté"

else :
return "Impossible"

on comprend qu'il n'est pas possible que le moteur soit à l'arrêt et que la voiture ait une vitesse
supérieure à 0 km/h.
Pourtant, il est possible de créer cette situation en accédant et modifiant directement les attributs.

voiture2 = Voiture("rouge","renault clio","2011","Diesel","arrêt",0)

voiture2.demarrer()
voiture2.accelerer(100)
voiture2.etat_moteur="arrêt" #On modifie directement l'état du moteur sans passer par la méthode
print("Vitesse :",voiture2.vitesse)
print("Moteur :",voiture2.etat_moteur)

L’accès aux attributs

et méthodes peut
Vitesse : 100 être dangereux.
Moteur : arrêt

14
Encapsulation

L'encapsulation consiste masquer (donc rendre inaccessible du développeur qui

instancie un objet) certains attributs et certaines méthodes.

Pour utiliser ou modifier les attributs, on utilisera alors de préférence des méthodes
dédiées dont le rôle est de faire l'interface entre l'utilisateur de l'objet et la
représentation interne de l'objet (les attributs).

L'encapsulation permet de :
●
simplifier la vie du programmeur qui les utilise les classes,
●
masquer la complexité des classes,
●
permet de modifier celle-ci sans changer le reste du programme,
●
la liste des méthodes devient une sorte de mode d'emploi de la classe.

15
 Encapsulation
En Python pour rendre privé un attribut ou une méthode, il faut préfixer le nom par une paire de `__`.
Comme l'attribut n'est plus accessible de l'extérieur, pour accéder ou modifier sa valeur on utilise deux types
de méthode :
●
Les accesseurs (ou getters) : pour obtenir la valeur d'un attribut. En général, le nom des accesseurs
commence par Get suivi du nom de l'attribut.
●
Les mutateurs (ou setters) : pour modifier la valeur d'un attribut. En général, le nom des mutateur
commence par Set suivi du nom de l'attribut.

Dans l'exemple de la classe `Voiture`, on va rendre privé l'attribut `couleur` et créer un accesseur et un
mutateur pour cet attribut.

def __init__(self, coul, mod, annee, carburant, etat, vit): voiture3 = Voiture("rouge", "renault clio", "2011", "Diesel", "arrêt", 0)
self.__couleur = coul # On change la couleur de la voiture avec le mutateur
self.modele = mod Attribut privé voiture3.SetCouleur("Mauve")
self.vitesse = vit
# On affiche la couleur de la voiture avec l'accesseur
print(voiture3.GetCouleur())
def GetCouleur(self):
"""Accesseur de l'attribut couleur""" # Génère une erreur car l'attribut __couleur est privé donc inaccessible.
return self.__couleur print(voiture3.__couleur)
Accesseur
def SetCouleur(self, coul):
"""Mutateur de l'attribut couleur"""
self.__couleur = coul

…. Mutateur

16
Exercice 4

1. Modifier la classe `Voiture` pour que tous les attributs soient privés. Définir pour
chacun d'eux un accesseur et un mutateur en respectant les règles citées plus haut :
●
pour démarrer la voiture, il faut qu'elle soit à l'arrêt et et que sa vitesse soit nulle. Son
état passe à : "démarré".
●
pour arrêter la voiture, il faut qu'elle soit démarrée et de sa vitesse soit nulle. Elle
passe alors à l'état : "arrêt".
●
pour accélérer la voiture, il faut préciser de combien on accélère la voiture. Une valeur
négative fait ralentir la voiture.

2. Créer une instance de la classe voiture puis modifier certains paramètres et vérifier
que tout fonctionne correctement.

17
Récapitulatif
●
Le type de données avec ses caractéristiques et ses actions possibles s’appelle
classe.
●
Les caractéristiques (ou variables) de la classe s’appellent les attributs.
●
Les actions possibles à effectuer avec la classe s’appellent les méthodes.
●
La classe définit donc les attributs et les actions possibles sur ces attributs, les
méthodes.
●
Constructeur : la manière « normale » de spécifier l’initialisation d’un objet est d’écrire
un constructeur (méthode __init__(self,...)).
●
L’encapsulation désigne le principe de regrouper des données brutes avec un
ensemble de routines (méthodes) permettant de les lire ou de les manipuler.
●
Accesseur ou "getter" : une fonction qui retourne la valeur d’un attribut de l’objet. Par
convention son nom est généralement sous la forme : GetNom_attribut().
●
Un Mutateur ou "setter" : une procédure qui permet de modifier la valeur d’un attribut
d’un objet. Son nom est généralement sous la forme : GetNom_attribut().
●
En Python pour rendre privé une méthode ou un attribut il faut que son nom commence
par la paire de symbole __.

18
Agrégation
Un objet dans la vraie vie, par exemple votre stylo, est composé d’autres objets :
une pointe (ou plume), un réservoir d’encre, éventuellement un capuchon et un
ressort....
Votre stylo est ce qu’on appelle un objet agrégat et son réservoir d’encre est
donc un objet composant.
class Reservoir:
class Stylo:
''' classe permettant de construire un réservoir
''' classe permettant de construire un stylo
d'encre
avec un réservoir d'encre.
pour des stylos toutes marques, toutes dimensions
On ne s'occupe pas de ses autres caractéristiques'''
'''
def __init__(self, couleur):
def __init__(self, couleur):
''' On se contente d'un seul paramètre pour l'exemple
''' On se contente d'un seul paramètre pour
les dimensions ou autres composants ne seront donc
l'exemple
pas inclus dans cette description '''
les dimensions ne seront donc pas incluses dans
self.reservoir = Reservoir(couleur)
cette description '''
# un seul attribut toujours par souci de clarté
# Accesseur du self.couleur de self.reservoir
self.__couleur = couleur
def getCouleur(self):
return self.reservoir.getCouleur()
# Accesseur de self.couleur
def getCouleur(self):
# Mutateur du self.couleur de self.reservoir
return self.__couleur
def setCouleur(self, couleur):
self.reservoir.setCouleur(couleur)
# Mutateur de self.couleur
def setCouleur(self, couleur):
self.__couleur = couleur

19
Agrégation
class Reservoir: class Stylo:
''' classe permettant de construire un réservoir ''' classe permettant de construire un stylo
d'encre avec un réservoir d'encre.
pour des stylos toutes marques, toutes dimensions On ne s'occupe pas de ses autres caractéristiques'''
'''
def __init__(self, couleur):
def __init__(self, couleur): ''' On se contente d'un seul paramètre pour l'exemple
''' On se contente d'un seul paramètre pour les dimensions ou autres composants ne seront donc
l'exemple pas inclus dans cette description '''
les dimensions ne seront donc pas incluses dans self.reservoir = Reservoir(couleur)
cette description '''
# un seul attribut toujours par souci de clarté # Accesseur du self.couleur de self.reservoir
self.__couleur = couleur def getCouleur(self):
return self.reservoir.getCouleur()
# Accesseur de self.couleur
def getCouleur(self): # Mutateur du self.couleur de self.reservoir
return self.__couleur def setCouleur(self, couleur):
self.reservoir.setCouleur(couleur)
# Mutateur de self.couleur
def setCouleur(self, couleur):
self.__couleur = couleur

pen = Stylo("Rouge")
print(pen.getCouleur())

# Changeons la cartouche d'encre

pen.setCouleur("Bleu") Rouge
''' Attention, à éviter absolument même si possible,
Bleu
on casse ici le principe d'encapsulation
mais le résultat est le même à l'affichage'''
print(pen.reservoir.getCouleur())

20
Exercice 5 Application à un jeu de cartes

Voir cours :
●
Partie 1 : définition d’un attribut Figure, ...
●
Partie 2 Agrégation

21