Introduction à la Programmation Orientée Objet

(POO)

Introduction
La programmation orientée objet (POO) est une approche qui organise le code autour
d’objets, combinant données (attributs) et comportements (méthodes). Contrairement à
la programmation procédurale, qui sépare les données (ex. : dictionnaires) des fonctions,
la POO reflète mieux les entités du monde réel, rendant le code plus intuitif, robuste
et maintenable. Ce fascicule présente la POO à travers des études de cas pratiques (bi-
bliothèque, comptes bancaires) et compare ses avantages à l’approche procédurale. Les
exemples sont donnés en Python et Java, avec des exercices pour approfondir.

1 Pourquoi la POO plutôt que la Programmation

Procédurale ?
La programmation orientée objet (POO) organise le code autour d’objets qui
combinent données (attributs) et comportements (méthodes), contrairement à la pro-
grammation procédurale qui sépare les données (ex. : dictionnaires) et les fonctions.
Voici les avantages de la POO illustrés par deux analogies.
Analogie 1 : Les légumes dans une cuisine Imaginez une cuisine où chaque
légume (ex. : une carotte) est un objet avec des caractéristiques (taille, couleur) et des
actions (couper, cuire). En procédural, les légumes sont des dictionnaires (ex. : carotte =
{"taille": 15, "couleur": "orange"}) manipulés par des fonctions comme couper(carotte,
5). Cela sépare les données des actions, rendant le code moins intuitif. En POO, la classe
Legume regroupe la taille et couper(), et [Link](5) est plus naturel.
Analogie 2 : Matériel de menuiserie dans un atelier Dans un atelier, chaque ou-
til (ex. : une scie) est un objet avec des caractéristiques (usure, type) et des actions (scier,
réparer). En procédural, les outils sont des dictionnaires (ex. : scie = {"usure": 20,
"type": "scie à bois"}) manipulés par des fonctions comme scier(scie, "bois").
En POO, la classe Outil regroupe l’usure et scier(), et [Link]("bois") reflète
mieux l’action réelle.
Avantages de la POO :
— Clarté : Les objets regroupent données et comportements, rendant le code intuitif.
Exemple : [Link](5) est plus clair que couper(carotte, 5).
— Contrôle : Les méthodes contrôlent les modifications, empêchant des erreurs
comme compte1["solde"] = -100 ou carotte["taille"] = -5.
— Extensibilité : Ajouter un nouveau type (ex. : compte épargne, tomate, marteau)
se fait via une nouvelle classe, sans modifier le code existant.

1
 — Réutilisabilité : Les classes (ex. : CompteBancaire, Legume, Outil) sont réutilisables
dans d’autres projets.
— Sécurité : Les attributs privés empêchent les modifications non autorisées (ex. :
solde négatif, usure invalide).
— Maintenabilité : Les modifications sont centralisées dans les classes, facilitant
les corrections et ajouts.
Dans les études de cas suivantes, comparez l’approche par objets (POO) à l’approche
par traitement (procédurale) pour voir ces avantages en action.

2 Étude de Cas 1 : Bibliothèque

2.1 Approche Procédurale
Dans une bibliothèque, un livre est représenté par un dictionnaire avec des clés comme
titre, auteur, et disponible. Les opérations (emprunter, retourner) sont des fonctions
qui manipulent ce dictionnaire.
1 livre1 = { " titre " : " Harry Potter " , " auteur " : " J . K . Rowling " , "
disponible " : True }
2

3 def emprunter_livre ( livre ) :

4 if livre [ " disponible " ]:
5 livre [ " disponible " ] = False
6 print ( f " Le livre ’{ livre [ ’ titre ’]} ’ a t e m p r u n t .")
7 else :
8 print ( f " Le livre ’{ livre [ ’ titre ’]} ’ n ’ est pas disponible .
")
9

10 def retourner_livre ( livre ) :

11 livre [ " disponible " ] = True
12 print ( f " Le livre ’{ livre [ ’ titre ’]} ’ a t r e t o u r n .")
13

14 def afficher_livre ( livre ) :

15 etat = " disponible " if livre [ " disponible " ] else " e m p r u n t "
16 print ( f " Titre : { livre [ ’ titre ’]} , Auteur : { livre [ ’ auteur ’]} ,
tat : { etat } " )
17

18 # Utilisation
19 afficher_livre ( livre1 )
20 emprunter_livre ( livre1 )
21 afficher_livre ( livre1 )

2.2 Approche Orientée Objet en Python

En POO, un livre est un objet de la classe Livre, avec des attributs et des méthodes
encapsulées.
1 class Livre :
2 def __init__ ( self , titre , auteur , disponible = True ) :
3 self . titre = titre

2
4 self . auteur = auteur
5 self . disponible = disponible
6

7 def emprunter ( self ) :

8 if self . disponible :
9 self . disponible = False
10 print ( f " Le livre ’{ self . titre } ’ a t e m p r u n t .")
11 else :
12 print ( f " Le livre ’{ self . titre } ’ n ’ est pas disponible .
")
13

14 def retourner ( self ) :

15 self . disponible = True
16 print ( f " Le livre ’{ self . titre } ’ a t r e t o u r n .")
17

18 def afficher ( self ) :

19 etat = " disponible " if self . disponible else " e m p r u n t "
20 print ( f " Titre : { self . titre } , Auteur : { self . auteur } , tat
: { etat } " )
21

22 # Utilisation
23 livre1 = Livre ( " Harry Potter " , " J . K . Rowling " )
24 livre2 = Livre ( " Le Petit Prince " , " Saint - E x u p r y " , False )
25 livre1 . afficher ()
26 livre1 . emprunter ()
27 livre1 . afficher ()
28 livre1 . retourner ()
29 livre2 . afficher ()

2.3 Approche Orientée Objet en Java

En Java, la classe Livre utilise une encapsulation stricte avec des attributs privés.
Les erreurs signalées ([Link]: error: ’{’ expected et [Link]: error:
<identifier> expected) provenaient d’une syntaxe incorrecte (class Livre : et def
i nit ).V oicilaversioncorrigée.

1 public class Livre {

2 private String titre ;
3 private String auteur ;
4 private boolean disponible ;
5

6 public Livre ( String titre , String auteur ) {

7 this ( titre , auteur , true ) ;
8 }
9

10 public Livre ( String titre , String auteur , boolean disponible )

{
11 this . titre = titre ;
12 this . auteur = auteur ;
13 this . disponible = disponible ;
14 }

3
15

16 public void emprunter () {

17 if ( disponible ) {
18 disponible = false ;
19 System . out . println ( " Le livre ’" + titre + " ’ a t
e m p r u n t .");
20 } else {
21 System . out . println ( " Le livre ’" + titre + " ’ n ’ est
pas disponible . " ) ;
22 }
23 }
24

25 public void retourner () {

26 disponible = true ;
27 System . out . println ( " Le livre ’" + titre + " ’ a t
r e t o u r n .");
28 }
29

30 public void afficher () {

31 String etat = disponible ? " disponible " : " e m p r u n t " ;
32 System . out . println ( " Titre : " + titre + " , Auteur : " +
auteur + " , tat : " + etat ) ;
33 }
34

35 public static void main ( String [] args ) {

36 Livre livre1 = new Livre ( " Harry Potter " , " J . K . Rowling " ) ;
37 Livre livre2 = new Livre ( " Le Petit Prince " , " Saint -
E x u p r y " , false ) ;
38 livre1 . afficher () ;
39 livre1 . emprunter () ;
40 livre1 . afficher () ;
41 livre1 . retourner () ;
42 livre2 . afficher () ;
43 }
44 }

Remarques :
| Java exige des types explicites (String, boolean) et utilise private
pour l’encapsulation.
| Les erreurs ’{}’ expected et <identifier> expected sont corrigées en
remplaçant class Livre : par class Livre { et def i nit
parunconstructeur public Livre(...)

2.4 Questions
1. Pourquoi modifier directement livre1["disponible"] = False (procédural)
peut poser problème, comparé à l’utilisation de [Link]() (POO)
?
2. Comment l’approche POO facilite-t-elle l’ajout d’un nouveau type de livre
(ex. : LivreAudio) ?
3. Proposez une méthode prolonger emprunt() pour gérer les durées d’emprunt.

4
 3 Étude de Cas 2 : Comptes Bancaires
3.1 Approche Procédurale
Un compte bancaire est un dictionnaire avec nom et solde. Les opérations
sont des fonctions externes.
1 compte1 = { " nom " : " Alice " , " solde " : 1000}
2

3 def deposer ( compte , montant ) :

4 compte [ " solde " ] += montant
5 print ( f " { montant } d p o s sur le compte de { compte [ ’ nom ’]}.
Solde : { compte [ ’ solde ’]} " )
6

7 def retirer ( compte , montant ) :

8 if compte [ " solde " ] >= montant :
9 compte [ " solde " ] -= montant
10 print ( f " { montant } r e t i r du compte de { compte [ ’ nom ’]}.
Solde : { compte [ ’ solde ’]} " )
11 else :
12 print ( " Fonds insuffisants . " )
13

14 # Utilisation
15 deposer ( compte1 , 200)
16 retirer ( compte1 , 150)

3.2 Approche Orientée Objet en Python

En POO, un compte est un objet avec des attributs protégés et des méthodes
validées.
1 class CompteBancaire :
2 def __init__ ( self , nom , solde_initial =0) :
3 self . nom = nom
4 self . __solde = solde_initial
5

6 @property
7 def solde ( self ) :
8 return self . __solde
9

10 @solde . setter
11 def solde ( self , valeur ) :
12 if valeur >= 0:
13 self . __solde = valeur
14 else :
15 raise ValueError ( " Le solde ne peut pas tre n gatif
.")
16

17 def deposer ( self , montant ) :

18 if montant > 0:
19 self . __solde += montant

5
20 print ( f " { montant } d p o s . Nouveau solde : { self .
__solde } " )
21 else :
22 raise ValueError ( " Le montant doit tre positif . " )
23

24 def retirer ( self , montant ) :

25 if montant > 0 and self . __solde >= montant :
26 self . __solde -= montant
27 print ( f " { montant } r e t i r . Nouveau solde : { self .
__solde } " )
28 else :
29 raise ValueError ( " Fonds insuffisants ou montant
invalide . " )
30

31 # Utilisation
32 compte1 = CompteBancaire ( " Alice " , 1000)
33 compte1 . deposer (200)
34 compte1 . retirer (150)
35 print ( compte1 . solde )

3.3 Approche Orientée Objet en Java

En Java, l’encapsulation est stricte avec des attributs privés et des exceptions.
1 public class CompteBancaire {
2 private String nom ;
3 private double solde ;
4

5 public CompteBancaire ( String nom , double soldeInitial ) {

6 if ( soldeInitial < 0) {
7 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Le solde initial
ne peut pas tre n g a t i f .");
8 }
9 this . nom = nom ;
10 this . solde = soldeInitial ;
11 }
12

13 public void deposer ( double montant ) {

14 if ( montant <= 0) {
15 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Le montant doit
tre positif . " ) ;
16 }
17 solde += montant ;
18 System . out . println ( montant + " d p o s . Nouveau solde :
" + solde ) ;
19 }
20

21 public void retirer ( double montant ) {

22 if ( montant <= 0) {
23 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Le montant doit
tre positif . " ) ;

6
24 }
25 if ( solde < montant ) {
26 throw new I l l e g a l S t a t e E x c e p t i o n ( " Fonds insuffisants . "
);
27 }
28 solde -= montant ;
29 System . out . println ( montant + " r e t i r . Nouveau solde : "
+ solde ) ;
30 }
31

32 public double getSolde () {

33 return solde ;
34 }
35

36 public static void main ( String [] args ) {

37 CompteBancaire compte1 = new CompteBancaire ( " Alice " ,
1000) ;
38 compte1 . deposer (200) ;
39 compte1 . retirer (150) ;
40 System . out . println ( " Solde final : " + compte1 . getSolde () )
;
41 }
42 }

3.4 Questions
1. Pourquoi modifier directement compte1["solde"] = -100 (procédural) peut
poser problème, comparé à [Link]() (POO) ?
2. Comment ajouter un compte épargne avec intér^
ets en POO ?
3. Proposez une méthode transferer() pour transférer de l’argent entre deux
comptes.

4 Exercice Pratique : POO vs Procédural

Pour comprendre les avantages de la POO (clarté, contr^ ole, extensibilité,
réutilisabilité, sécurité, maintenabilité), implémentez les classes suivantes
et comparez-les à une approche procédurale.

4.1 Tâche 1 : Classe Legume (Python)

Créez une classe Legume avec les attributs nom, taille, et propre. Implémentez
:
| laver() : Rend le légume propre.
| couper(reduction) : Réduit la taille si le légume est propre et si la
réduction est valide.
| Utilisez @property pour protéger taille.
Comparez avec une version procédurale utilisant carotte = {"taille": 15, "propre":
False} et couper(carotte, reduction).

7
1 class Legume :
2 def __init__ ( self , nom , taille , couleur ) :
3 self . nom = nom
4 self . _taille = taille
5 self . _couleur = couleur
6 self . _propre = False
7

8 @property
9 def taille ( self ) :
10 return self . _taille
11

12 @taille . setter
13 def taille ( self , valeur ) :
14 if valeur >= 0:
15 self . _taille = valeur
16 else :
17 raise ValueError ( " La taille ne peut pas tre
n g a t i v e .")
18

19 def laver ( self ) :

20 self . _propre = True
21 print ( f " { self . nom } a t l a v .")
22

23 def couper ( self , reduction ) :

24 if not self . _propre :
25 raise ValueError ( f " { self . nom } doit tre lav avant
de couper . " )
26 if reduction <= self . _taille :
27 self . _taille -= reduction
28 print ( f " { self . nom } c o u p . Nouvelle taille : { self .
_taille } cm . " )
29 else :
30 raise ValueError ( " R d u c t i o n trop grande . " )

4.2 Tâche 2 : Classe Outil (Java)

Créez une classe Outil avec les attributs nom, type, et usure (privés).
Implémentez :
| scier(materiau) : Vérifie que l’outil est adapté et augmente l’usure.
| reparer(reduction) : Réduit l’usure, en la limitant entre 0 et 100.
| getUsure() : Getter pour l’usure.
Comparez avec une version procédurale utilisant scie = {"usure": 20, "type":
"scie à bois"} et scier(scie, materiau).
1 public class Outil {
2 private String nom ;
3 private double usure ;
4 private String type ;
5

6 public Outil ( String nom , String type , double usureInitiale ) {

8
7 this . nom = nom ;
8 this . type = type ;
9 if ( usureInitiale < 0 || usureInitiale > 100) {
10 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " L ’ usure doit
tre entre 0 et 100. " ) ;
11 }
12 this . usure = usureInitiale ;
13 }
14

15 public void scier ( String materiau ) {

16 if (! type . equals ( " scie bois " ) || ! materiau . equals ( "
bois " ) ) {
17 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Outil ou
m a t r i a u non a d a p t . " ) ;
18 }
19 if ( usure >= 100) {
20 throw new I l l e g a l S t a t e E x c e p t i o n ( " L ’ outil est trop
u s .");
21 }
22 usure += 10;
23 System . out . println ( nom + " a s c i du " + materiau + " .
Usure : " + usure ) ;
24 }
25

26 public void reparer ( double reduction ) {

27 if ( reduction < 0) {
28 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " La r d u c t i o n d ’
usure doit tre positive . " ) ;
29 }
30 usure = Math . max (0 , usure - reduction ) ;
31 System . out . println ( nom + " r p a r . Nouvelle usure : " +
usure ) ;
32 }
33

34 public double getUsure () {

35 return usure ;
36 }
37 }

4.3 Question de réflexion

Expliquez comment les avantages de la POO (clarté, contr^ ole, extensibilité,
réutilisabilité, sécurité, maintenabilité) se manifestent dans Legume et Outil,
par rapport à leurs versions procédurales. Donnez des exemples spécifiques
pour chaque avantage.