‡ Université

LMN

Programmation Orientée Objet

Classes et Objets
Fondements de la Programmation Orientée Objet en Java

Support de cours
Année universitaire 2025 – 2026
Table des matières
1 Introduction à la programmation orientée objet 2

2 La classe 2

3 L’objet 3

4 Différence entre classe et objet 4

5 Les attributs 4

6 Les méthodes 5

7 Les constructeurs 6

8 Création d’objets avec new 7

9 Les références d’objets 7

10 Le mot-clé this 8

11 L’encapsulation 9

12 Les modificateurs d’accès 9

13 Les getters et setters 10

14 La surcharge des constructeurs 12

15 La surcharge des méthodes 13

16 Variables statiques (static) 14

17 Les méthodes statiques 15

18 Les constantes (final) 16

19 Bonnes pratiques 17

20 Erreurs fréquentes des débutants 17

21 Questions de compréhension 18

22 Exercices progressifs 18

1
Programmation Orientée Objet — Java 2 LA CLASSE

1 Introduction à la programmation orientée objet

La programmation orientée objet, souvent abrégée POO, est une manière d’organiser le code
autour de deux notions centrales : les classes et les objets. Plutôt que d’écrire une longue suite
d’instructions qui manipulent des données éparpillées, on regroupe les données et les traitements
qui leur correspondent au sein d’entités cohérentes.

] Définition
La programmation orientée objet est un paradigme de programmation qui consiste à modé-
liser un programme comme un ensemble d’objets qui interagissent entre eux, chaque objet
possédant ses propres données et son propre comportement.

Avant la POO, on utilisait principalement la programmation procédurale : le programme est

une suite de fonctions qui agissent sur des données séparées. Ce modèle devient vite difficile à
maintenir dès que le projet grossit, car rien n’empêche une fonction d’altérer des données qu’elle
ne devrait pas toucher.

 Exemple
Pensez à une bibliothèque universitaire. Chaque livre possède un titre, un auteur, un état
de disponibilité. Chaque étudiant possède un nom, un numéro d’inscription, une liste
d’emprunts. La POO permet de représenter fidèlement ces entités dans le code, avec leurs
propriétés et leurs actions (emprunter, rendre, réserver).

La POO en Java repose sur quatre grands principes, que nous découvrirons progressivement
dans ce cours :

 L’encapsulation : protéger les données d’un objet.

 L’héritage : réutiliser et spécialiser du code existant.

 Le polymorphisme : traiter des objets différents de manière uniforme.

 L’abstraction : ne montrer que l’essentiel d’un objet.

ò Remarque
Ce chapitre se concentre sur les deux briques de base de la POO : la classe et l’objet.
L’héritage et le polymorphisme feront l’objet de chapitres suivants.

2 La classe

] Définition
Une classe est un modèle, un plan de construction qui décrit la structure et le comportement
d’un ensemble d’objets. Elle définit quels attributs (données) et quelles méthodes (actions)
posséderont les objets créés à partir d’elle.

Une classe ne représente rien de concret à elle seule : c’est un moule. On ne « vit » pas dans
le plan d’une maison, on vit dans la maison construite à partir de ce plan. De la même façon,
un programme n’utilise pas directement une classe, mais des objets fabriqués à partir de cette
classe.

2 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 3 L’OBJET

 Exemple
La classe Etudiant décrit ce que possède tout étudiant à l’université : un nom, un numéro
d’étudiant, une filière. Elle décrit aussi ce qu’un étudiant peut faire : s’inscrire à un cours,
consulter ses notes. Chaque étudiant réel de l’université (Lamine, Fatou, Moussa...) sera un
objet fabriqué à partir de ce modèle.

En Java, une classe se déclare avec le mot-clé class :

1 public class Etudiant {

2 // attributs et m t h o d e s seront a j o u t s ici
3 }

Listing 1 – Déclaration minimale d’une classe

ò Remarque
Par convention, le nom d’une classe Java commence toujours par une majuscule et s’écrit en
PascalCase (exemple : CompteBancaire, ProduitBoutique). Le fichier source doit porter
exactement le même nom que la classe publique qu’il contient, avec l’extension .java.

3 L’objet

] Définition
Un objet est une instance concrète d’une classe : il occupe un emplacement réel en mémoire
et possède ses propres valeurs pour chacun des attributs définis par sa classe.

Si la classe est le plan, l’objet est le bâtiment construit. On peut construire plusieurs bâti-
ments différents à partir du même plan : de même, on peut créer plusieurs objets à partir d’une
seule classe, chacun avec ses propres valeurs.

 Exemple

À partir de la classe Livre, la bibliothèque crée un objet pour chaque exemplaire réel :
un objet représentant « Une si longue lettre » de Mariama Bâ, un autre représentant «
Le Ventre de l’Atlantique » de Fatou Diome. Chaque objet a son propre titre, son propre
auteur et son propre statut de disponibilité.

1 public class TestLivre {

2 public static void main ( String [] args ) {
3 Livre livre1 = new Livre () ;
4 Livre livre2 = new Livre () ;
5
6 livre1 . titre = " Une si longue lettre " ;
7 livre2 . titre = " Le Ventre de l ’ Atlantique " ;
8
9 System . out . println ( livre1 . titre ) ;
10 System . out . println ( livre2 . titre ) ;
11 }
12 }

Listing 2 – Deux objets issus de la même classe

3 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 5 LES ATTRIBUTS

_ Résultat
Une si longue lettre
Le Ventre de l’Atlantique

Chaque objet possède sa propre copie des attributs : modifier livre1 n’affecte en rien livre2,
même s’ils proviennent de la même classe Livre.

4 Différence entre classe et objet

Cette distinction est fondamentale et source de confusion chez les débutants. Le tableau suivant
la résume clairement.

bleuprincipal Classe Objet

Modèle abstrait, définition Instance concrète et réelle
N’occupe pas de mémoire Occupe un emplacement en mé-
pour des données moire
Une seule déclaration dans Plusieurs objets peuvent en dé-
le code couler
Exemple : la classe Exemple : le compte de Lamine,
CompteBancaire le compte de Fatou

Astuce
Une bonne façon de retenir la différence : la classe répond à la question « à quoi ressemble
un compte bancaire en général ? », l’objet répond à la question « quel est le solde de ce
compte précis ? ».

. Attention
Un piège classique : écrire du code à l’intérieur d’une classe en pensant manipuler des
données réelles, alors que rien ne se passe tant qu’aucun objet n’a été créé avec new. Nous
verrons ce mot-clé dans la section suivante.

5 Les attributs

] Définition
Un attribut (aussi appelé champ ou variable d’instance) est une donnée qui décrit l’état
d’un objet. Il est déclaré à l’intérieur d’une classe et chaque objet possède sa propre valeur
pour chaque attribut.

Les attributs représentent ce qu’un objet est ou possède, contrairement aux méthodes qui
représentent ce qu’il fait.

 Exemple
Une classe CompteBancaire possède naturellement des attributs comme le numéro de
compte, le solde et le nom du titulaire. Ce sont des informations propres à chaque compte.

4 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 6 LES MÉTHODES

1 public class CompteBancaire {

2 String numeroCompte ;
3 String titulaire ;
4 double solde ;
5 }

Listing 3 – Déclaration des attributs d’une classe

Chaque attribut possède un type (String, double, int, boolean...) et un nom écrit en
camelCase. Tant qu’aucune valeur n’est explicitement affectée, Java initialise les attributs avec
des valeurs par défaut : 0 pour les nombres, false pour les booléens, null pour les objets.

ò Remarque
On distingue les variables d’instance (les attributs classiques, propres à chaque objet)
des variables locales, déclarées à l’intérieur d’une méthode et qui n’existent que pendant
son exécution.

6 Les méthodes

] Définition
Une méthode est un bloc de code défini dans une classe qui décrit un comportement ou une
action que peuvent exécuter les objets de cette classe.

Si les attributs décrivent l’état d’un objet, les méthodes décrivent ses actions possibles.

 Exemple
Pour la classe CompteBancaire, des méthodes naturelles seraient deposer() pour ajouter
de l’argent, retirer() pour en retirer, et afficherSolde() pour consulter le solde actuel.

1 public class CompteBancaire {

2 String numeroCompte ;
3 String titulaire ;
4 double solde ;
5

6 void deposer ( double montant ) {

7 solde = solde + montant ;
8 }
9
10 void retirer ( double montant ) {
11 if ( montant <= solde ) {
12 solde = solde - montant ;
13 } else {
14 System . out . println ( " Solde insuffisant . " ) ;
15 }
16 }
17

18 void afficherSolde () {
19 System . out . println ( " Solde de " + titulaire + " : " + solde +
" FCFA " ) ;
20 }
21 }

5 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 7 LES CONSTRUCTEURS

Listing 4 – Ajout de méthodes à la classe CompteBancaire

Une méthode possède une signature composée d’un type de retour (void si elle ne retourne
rien), d’un nom, et éventuellement de paramètres entre parenthèses. Ici, deposer et retirer
reçoivent un montant en paramètre, tandis que afficherSolde n’en a besoin d’aucun.

7 Les constructeurs

] Définition
Un constructeur est une méthode spéciale, portant le même nom que la classe, exécutée
automatiquement lors de la création d’un objet. Il sert à initialiser les attributs de l’objet
dès sa naissance.

Sans constructeur explicite, Java en fournit un par défaut, vide, qui ne fait qu’allouer l’objet
en mémoire sans initialiser ses attributs de façon particulière.

 Exemple
Lorsqu’un nouvel étudiant s’inscrit à l’université, on veut immédiatement renseigner son
nom et son numéro d’étudiant, plutôt que de créer un objet « vide » puis de le compléter
ligne par ligne.

1 public class Etudiant {

2 String nom ;
3 String numeroEtudiant ;
4 String filiere ;
5
6 public Etudiant ( String nom , String numeroEtudiant , String filiere
) {
7 this . nom = nom ;
8 this . numeroEtudiant = numeroEtudiant ;
9 this . filiere = filiere ;
10 }
11 }

Listing 5 – Constructeur de la classe Etudiant

Un constructeur n’a pas de type de retour, pas même void. Son unique rôle est d’initialiser
l’objet au moment de sa création. Nous reviendrons juste après sur le rôle exact du mot-clé this
utilisé ici.

ò Remarque
Dès qu’une classe définit un constructeur avec paramètres, le constructeur par défaut sans
paramètre disparaît automatiquement, sauf si on le redéfinit soi-même.

8 Création d’objets avec new

6 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 9 LES RÉFÉRENCES D’OBJETS

] Définition
Le mot-clé new déclenche la création d’un objet en mémoire : il réserve l’espace nécessaire
pour ses attributs, puis appelle le constructeur correspondant pour l’initialiser.

1 public class TestEtudiant {

2 public static void main ( String [] args ) {
3 Etudiant e1 = new Etudiant ( " Fatou Ndiaye " , " L2INFO2024 " , "
Informatique " ) ;
4 Etudiant e2 = new Etudiant ( " Moussa Diallo " , " L2INFO2025 " , "
M a t h m a t i q u e s ");
5
6 System . out . println ( e1 . nom + " - " + e1 . filiere ) ;
7 System . out . println ( e2 . nom + " - " + e2 . filiere ) ;
8 }
9 }

Listing 6 – Création d’objets Etudiant avec new

_ Résultat
Fatou Ndiaye - Informatique
Moussa Diallo - Mathématiques

Chaque appel à new Etudiant(...) crée un objet distinct, avec son propre espace mémoire
et ses propres valeurs d’attributs, même si les deux proviennent de la même classe.

Astuce
Retenez la mécanique en trois temps : new réserve la mémoire, le constructeur initialise les
attributs, et la variable (e1, e2) reçoit une référence vers cet objet.

9 Les références d’objets

] Définition
En Java, une variable d’objet ne contient jamais l’objet lui-même : elle contient une réfé-
rence, c’est-à-dire une sorte d’adresse qui pointe vers l’emplacement de l’objet en mémoire.

Cette distinction a une conséquence importante : lorsqu’on affecte une variable objet à une
autre, on ne copie pas l’objet, on copie seulement la référence. Les deux variables pointent alors
vers le même objet.

 Exemple
Imaginez deux étiquettes qui pointent vers le même dossier d’un patient à l’hôpital. Modifier
le dossier via une étiquette modifie ce que voit l’autre étiquette, puisqu’il n’y a qu’un seul
dossier physique.

1 public class TestReference {

2 public static void main ( String [] args ) {
3 Patient p1 = new Patient ( " A s s a t o u Sow " ) ;

7 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 10 LE MOT-CLÉ THIS

4 Patient p2 = p1 ;
5

6 p2 . nom = " A s s a t o u Diagne " ;

7
8 System . out . println ( p1 . nom ) ;
9 System . out . println ( p2 . nom ) ;
10 }
11 }

Listing 7 – Deux références vers le même objet

_ Résultat
Aïssatou Diagne
Aïssatou Diagne

Bien qu’on ait modifié p2, l’affichage de p1 change aussi : les deux variables référencent le
même objet Patient en mémoire.

. Attention
Ne confondez pas ce comportement avec celui des types primitifs (int, double, boolean...) :
ceux-ci sont copiés par valeur, pas par référence. Seuls les objets suivent ce mécanisme de
référence partagée.

10 Le mot-clé this

] Définition
Le mot-clé this désigne l’objet courant, c’est-à-dire l’objet sur lequel la méthode ou le
constructeur en cours d’exécution a été invoqué.

Son usage le plus fréquent consiste à lever une ambiguïté lorsqu’un paramètre porte le même
nom qu’un attribut.

1 public class Produit {

2 String nom ;
3 double prix ;
4
5 public Produit ( String nom , double prix ) {
6 this . nom = nom ; // this . nom : l ’ attribut / nom : le
param tre
7 this . prix = prix ;
8 }
9
10 void augmenterPrix ( double prix ) {
11 this . prix = this . prix + prix ;
12 }
13 }

Listing 8 – Utilité du mot-clé this

Sans [Link], l’instruction nom = nom; n’aurait aucun effet : Java comprendrait qu’on
affecte le paramètre à lui-même, laissant l’attribut de l’objet inchangé.

8 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 12 LES MODIFICATEURS D’ACCÈS

Astuce
this peut aussi servir à appeler un autre constructeur de la même classe grâce à la syntaxe
this(...), ce que nous verrons dans la section sur la surcharge des constructeurs.

11 L’encapsulation

] Définition
L’encapsulation consiste à protéger les attributs d’un objet en les rendant inaccessibles
directement depuis l’extérieur de la classe, et à n’autoriser leur consultation ou leur modi-
fication qu’à travers des méthodes prévues à cet effet.

Sans encapsulation, n’importe quel code extérieur peut modifier librement les attributs d’un
objet, y compris avec des valeurs incohérentes.

 Exemple
Rien n’empêcherait, sans encapsulation, d’écrire [Link] = -50000; directement de-
puis l’extérieur, ce qui n’a aucun sens pour un compte bancaire. L’encapsulation permet
d’imposer des règles : par exemple, interdire un solde négatif.

1 public class CompteBancaire {

2 double solde ; // accessible et modifiable sans c o n t r l e
3 }
4
5 // Ailleurs dans le code :
6 CompteBancaire c = new CompteBancaire () ;
7 c . solde = -50000; // aucune v r i f i c a t i o n possible !

Listing 9 – Sans encapsulation : aucune protection

. Attention
Exposer directement les attributs d’une classe est l’une des erreurs les plus fréquentes
chez les débutants. Cela rend le code fragile : une simple faute de logique ailleurs dans le
programme peut corrompre l’état d’un objet.

L’encapsulation repose sur deux piliers que nous détaillons dans les sections suivantes : les
modificateurs d’accès et les getters/setters.

12 Les modificateurs d’accès

] Définition
Un modificateur d’accès détermine la visibilité d’un attribut, d’une méthode ou d’une classe,
c’est-à-dire depuis quel endroit du programme on peut y accéder.

Java propose trois modificateurs principaux, résumés ci-dessous.

9 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 13 LES GETTERS ET SETTERS

bleuprincipal Modificateur Portée

public Accessible depuis n’importe quelle classe du
programme
private Accessible uniquement à l’intérieur de la
classe qui le déclare
protected Accessible dans la classe, ses sous-classes, et
son package

 Exemple
Dans une classe Employe, le salaire est une information sensible. On le déclare private
pour empêcher toute modification directe depuis l’extérieur, et on expose des méthodes
publiques contrôlées pour le consulter ou le modifier.

1 public class Employe {

2 private String nom ;
3 private double salaire ;
4 }

Listing 10 – Attributs privés dans la classe Employe

ò Remarque
En pratique, la règle courante est simple : les attributs sont presque toujours private, tandis
que les méthodes destinées à être utilisées depuis l’extérieur sont public. Le modificateur
protected est surtout utile dans le cadre de l’héritage, vu dans un chapitre ultérieur.

13 Les getters et setters

] Définition
Un getter est une méthode publique qui permet de lire la valeur d’un attribut privé. Un
setter est une méthode publique qui permet de modifier cette valeur, généralement après
avoir vérifié sa cohérence.

Les getters et setters sont le pont contrôlé entre le monde extérieur et les attributs privés
d’un objet.

1 public class Employe {

2 private String nom ;
3 private double salaire ;
4
5 public Employe ( String nom , double salaire ) {
6 this . nom = nom ;
7 this . salaire = salaire ;
8 }
9
10 // Getter : lecture du nom
11 public String getNom () {
12 return nom ;
13 }

10 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 13 LES GETTERS ET SETTERS

14
15 // Getter : lecture du salaire
16 public double getSalaire () {
17 return salaire ;
18 }
19
20 // Setter : modification c o n t r l e du salaire
21 public void setSalaire ( double nouveauSalaire ) {
22 if ( nouveauSalaire >= 0) {
23 this . salaire = nouveauSalaire ;
24 } else {
25 System . out . println ( " Salaire invalide . " ) ;
26 }
27 }
28 }

Listing 11 – Getters et setters pour la classe Employe

1 public class TestEmploye {

2 public static void main ( String [] args ) {
3 Employe emp = new Employe ( " Cheikh Fall " , 350000) ;
4
5 System . out . println ( " Salaire actuel : " + emp . getSalaire () ) ;
6
7 emp . setSalaire (400000) ;
8 System . out . println ( " Nouveau salaire : " + emp . getSalaire () ) ;
9
10 emp . setSalaire ( -1000) ; // r e j e t par le setter
11 }
12 }

Listing 12 – Utilisation des getters et setters

_ Résultat
Salaire actuel : 350000.0
Nouveau salaire : 400000.0
Salaire invalide.

Par convention, un getter commence par get (ou is pour un booléen, comme isDisponible()),
suivi du nom de l’attribut en PascalCase. Un setter commence par set, suivi du même schéma.

Astuce
Le setter est l’endroit idéal pour valider une donnée avant de l’accepter : format d’un numéro
de téléphone, âge positif, stock non négatif, etc. C’est tout l’intérêt de l’encapsulation par
rapport à un attribut public.

14 La surcharge des constructeurs

11 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 14 LA SURCHARGE DES CONSTRUCTEURS

] Définition
La surcharge de constructeurs consiste à définir plusieurs constructeurs pour une même
classe, chacun ayant une liste de paramètres différente. Java choisit automatiquement le
bon constructeur selon les arguments fournis lors de la création de l’objet.

Cela permet d’offrir plusieurs façons de créer un objet, selon les informations disponibles au
moment de sa création.

 Exemple
Pour la classe ProduitBoutique, on souhaite parfois créer un produit en précisant tout de
suite son stock, et parfois créer un produit avec un stock initial à zéro par défaut.

1 public class ProduitBoutique {

2 private String nom ;
3 private double prix ;
4 private int stock ;
5
6 // Constructeur complet
7 public ProduitBoutique ( String nom , double prix , int stock ) {
8 this . nom = nom ;
9 this . prix = prix ;
10 this . stock = stock ;
11 }
12
13 // Constructeur sans stock : appel du constructeur complet via
this (...)
14 public ProduitBoutique ( String nom , double prix ) {
15 this ( nom , prix , 0) ;
16 }
17
18 public void afficher () {
19 System . out . println ( nom + " - " + prix + " FCFA - Stock : " +
stock ) ;
20 }
21 }

Listing 13 – Constructeurs surchargés dans ProduitBoutique

1 public class TestProduit {

2 public static void main ( String [] args ) {
3 ProduitBoutique p1 = new ProduitBoutique ( " C l USB 32 Go " ,
5000 , 20) ;
4 ProduitBoutique p2 = new ProduitBoutique ( " Souris sans fil " ,
8000) ;
5
6 p1 . afficher () ;
7 p2 . afficher () ;
8 }
9 }

Listing 14 – Utilisation des deux constructeurs

12 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 15 LA SURCHARGE DES MÉTHODES

_ Résultat
Clé USB 32Go - 5000.0 FCFA - Stock : 20
Souris sans fil - 8000.0 FCFA - Stock : 0

L’instruction this(nom, prix, 0); appelle le constructeur à trois paramètres depuis celui
à deux paramètres, évitant de dupliquer les affectations.

ò Remarque
Un appel this(...) doit obligatoirement être la toute première instruction du construc-
teur, sinon Java refuse de compiler.

15 La surcharge des méthodes

] Définition
La surcharge de méthodes (overloading) consiste à définir, dans une même classe, plusieurs
méthodes portant le même nom mais avec des paramètres différents (nombre ou type). Java
sélectionne la bonne méthode selon les arguments fournis lors de l’appel.

 Exemple
Dans une classe Restaurant, on veut pouvoir calculer le prix total d’une commande soit
pour un seul plat, soit pour plusieurs plats à la fois. Une seule méthode calculerTotal
peut couvrir les deux cas grâce à la surcharge.

1 public class Restaurant {

2
3 // Version avec un seul prix
4 public double calculerTotal ( double prixPlat ) {
5 return prixPlat ;
6 }
7
8 // Version avec plusieurs prix
9 public double calculerTotal ( double prixPlat , double prixBoisson )
{
10 return prixPlat + prixBoisson ;
11 }
12
13 // Version avec remise en pourcentage
14 public double calculerTotal ( double prixPlat , double prixBoisson ,
double remisePourcent ) {
15 double total = prixPlat + prixBoisson ;
16 return total - ( total * remisePourcent / 100) ;
17 }
18 }

Listing 15 – Méthodes surchargées dans la classe Restaurant

1 public class TestRestaurant {

2 public static void main ( String [] args ) {
3 Restaurant r = new Restaurant () ;
4

13 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 16 VARIABLES STATIQUES (STATIC)

5 System . out . println ( r . calculerTotal (3500) ) ;

6 System . out . println ( r . calculerTotal (3500 , 1000) ) ;
7 System . out . println ( r . calculerTotal (3500 , 1000 , 10) ) ;
8 }
9 }

Listing 16 – Appels des méthodes surchargées

_ Résultat
3500.0
4500.0
4050.0

. Attention
Deux méthodes ne peuvent pas être surchargées uniquement par leur type de retour : Java
se base sur le nombre et le type des paramètres, pas sur ce que la méthode retourne.

Astuce
Ne confondez pas surcharge (overloading, plusieurs méthodes de même nom dans une classe)
et redéfinition (overriding, une sous-classe qui remplace une méthode héritée). La redéfini-
tion sera étudiée avec l’héritage.

16 Variables statiques (static)

] Définition
Une variable statique est un attribut déclaré avec le mot-clé static. Contrairement à une
variable d’instance, elle n’appartient pas à un objet en particulier mais à la classe elle-
même : tous les objets de cette classe partagent la même valeur.

 Exemple
Dans une classe Universite, chaque étudiant inscrit devrait incrémenter un compteur
global du nombre total d’étudiants. Ce compteur n’a de sens qu’une seule fois pour toute
la classe, pas par étudiant : c’est un cas typique de variable statique.

1 public class Etudiant {

2 private String nom ;
3 static int nombreEtudiants = 0;
4
5 public Etudiant ( String nom ) {
6 this . nom = nom ;
7 nombreEtudiants ++;
8 }
9 }

Listing 17 – Variable statique dans la classe Etudiant

1 public class Te stE tu di an tS tati c {

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

14 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 17 LES MÉTHODES STATIQUES

3 Etudiant e1 = new Etudiant ( " Awa Sarr " ) ;

4 Etudiant e2 = new Etudiant ( " Ibrahima Ba " ) ;
5 Etudiant e3 = new Etudiant ( " Khady Niang " ) ;
6
7 System . out . println ( " Nombre total d ’ tudiants : " + Etudiant .
nombreEtudiants ) ;
8 }
9 }

Listing 18 – Le compteur statique est partagé

_ Résultat
Nombre total d’étudiants : 3

On accède à nombreEtudiants via le nom de la classe ([Link]), et non

via un objet précis, puisqu’elle n’appartient à aucun objet en particulier mais à la classe tout
entière.

17 Les méthodes statiques

] Définition
Une méthode statique est une méthode déclarée avec static. Elle appartient à la classe et
peut être appelée sans créer d’objet au préalable. Elle ne peut accéder directement qu’aux
membres statiques de sa classe.

 Exemple
Une classe utilitaire ConvertisseurDevise n’a pas besoin d’être instanciée : ses méthodes
de conversion fonctionnent indépendamment de tout objet particulier.

1 public class C on v e rt i s se u r Dev i se {

2 static final double TAUX_EURO = 655.957;
3
4 public static double fcfaVersEuro ( double montantFcfa ) {
5 return montantFcfa / TAUX_EURO ;
6 }
7 }

Listing 19 – Méthode statique de conversion

1 public class Te stConv ertis seur {

2 public static void main ( String [] args ) {
3 double montant = C on v e rt i s s eu r D ev i s e . fcfaVersEuro (50000) ;
4 System . out . println ( montant + " euros " ) ;
5 }
6 }

Listing 20 – Appel direct sans instanciation

15 Ú Licence 2 — Informatique
 Programmation Orientée Objet — Java 18 LES CONSTANTES (FINAL)

_ Résultat
76.22... euros

ò Remarque
La méthode main elle-même est toujours déclarée static : c’est ce qui permet à la JVM
de l’exécuter directement, sans avoir besoin de créer un objet de la classe au préalable.

18 Les constantes (final)

] Définition
Le mot-clé final appliqué à un attribut en fait une constante : sa valeur, une fois initialisée,
ne peut plus jamais être modifiée.

 Exemple
Dans une classe Hopital, le nombre maximal de lits disponibles dans un service donné, ou
le taux de TVA appliqué à une facture, sont des valeurs qui ne doivent jamais changer une
fois fixées.

1 public class Facture {

2 static final double TAUX_TVA = 0.18;
3 private double montantHT ;
4
5 public Facture ( double montantHT ) {
6 this . montantHT = montantHT ;
7 }
8

9 public double montantTTC () {

10 return montantHT + ( montantHT * TAUX_TVA ) ;
11 }
12 }

Listing 21 – Constantes dans une classe

Une constante s’écrit par convention en majuscules, avec des mots séparés par des underscores
(TAUX_TVA, NOMBRE_MAX_LITS). On combine généralement static et final pour une constante
partagée par tous les objets de la classe.

. Attention
Toute tentative de réaffecter une valeur à un attribut final après son initialisation provoque
une erreur de compilation. C’est précisément le but : garantir qu’elle reste inchangée.

19 Bonnes pratiques

16 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 20 ERREURS FRÉQUENTES DES DÉBUTANTS

Astuce
Quelques principes qui distinguent un code orienté objet propre d’un code bâclé, à adopter
dès ce chapitre :

¥ Toujours encapsuler : attributs private, accès via getters/setters.

¥ Nommer avec sens : CompteBancaire, calculerSolde() plutôt que Classe1, methode2().

¥ Une classe, une responsabilité : une classe Etudiant gère les données d’un étudiant,
pas l’affichage d’un menu.

¥ Valider les données dans les setters plutôt que de faire confiance au code appelant.

¥ Utiliser final pour toute valeur qui ne doit jamais changer (constantes, taux, plafonds).

¥ Respecter les conventions Java : classes en PascalCase, méthodes et variables en

camelCase.

¥ Éviter les attributs statiques abusifs : static doit rester l’exception, réservé aux
données réellement partagées par tous les objets.

20 Erreurs fréquentes des débutants

. Attention

Confondre classe et objet. Écrire [Link] en pensant accéder à un étudiant précis,

alors que nom est une variable d’instance qui n’existe que pour un objet créé avec new.

. Attention
Oublier this. Dans un constructeur, écrire nom = nom; au lieu de [Link] = nom;
lorsque le paramètre porte le même nom que l’attribut : l’attribut de l’objet reste alors
inchangé.

. Attention
Rendre tous les attributs public. Cela supprime tout contrôle sur les données et va à
l’encontre du principe d’encapsulation.

. Attention
Confondre référence et copie. Croire que Patient p2 = p1; crée un nouveau patient
indépendant, alors que p2 pointe vers le même objet que p1.

. Attention
Abuser du static. Déclarer un attribut static qui devrait en réalité être propre à chaque
objet (par exemple le solde d’un compte bancaire), ce qui ferait partager la même valeur à
tous les comptes.

17 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 22 EXERCICES PROGRESSIFS

. Attention
Multiplier les constructeurs sans this(...). Dupliquer les mêmes affectations dans
chaque constructeur surchargé au lieu de factoriser via un appel this(...).

21 Questions de compréhension
Q1. Quelle est la différence fondamentale entre une classe et un objet ?

Q2. Pourquoi dit-on qu’une variable d’objet contient une référence et non l’objet lui-
même ?

Q3. À quoi sert le mot-clé this dans un constructeur ?

Q4. Pourquoi rend-on généralement les attributs d’une classe private plutôt que public ?

Q5. Quelle est l’utilité concrète d’un setter par rapport à un attribut public modifiable
directement ?

Q6. Quelle est la différence entre la surcharge de constructeurs et la surcharge de mé-

thodes ?

Q7. Dans quel cas déclare-t-on un attribut static plutôt qu’une variable d’instance
classique ?

Q8. Que se passe-t-il si l’on tente de modifier la valeur d’un attribut déclaré final après
son initialisation ?

22 Exercices progressifs

 Exemple — Exercice 1 : Classe simple

Créez une classe Livre avec les attributs titre, auteur et disponible (booléen). Ajoutez
un constructeur qui initialise ces trois attributs, puis créez deux objets Livre différents et
affichez leurs informations.

 Exemple — Exercice 2 : Encapsulation

Reprenez la classe Livre et rendez tous ses attributs private. Ajoutez les getters néces-
saires, ainsi qu’un setter setDisponible qui bascule la disponibilité du livre.

 Exemple — Exercice 3 : Méthodes métier

Créez une classe CompteBancaire avec un solde privé. Ajoutez les méthodes
deposer(double montant) et retirer(double montant), cette dernière refusant tout re-
trait supérieur au solde disponible.

 Exemple — Exercice 4 : Surcharge de constructeurs

Créez une classe ProduitBoutique avec un constructeur complet (nom, prix, quantité) et
un second constructeur qui fixe automatiquement la quantité à 1 en utilisant this(...).

18 Ú Licence 2 — Informatique
Programmation Orientée Objet — Java 22 EXERCICES PROGRESSIFS

 Exemple — Exercice 5 : Surcharge de méthodes

Dans une classe Hopital, écrivez trois versions surchargées d’une méthode
admettrePatient : une avec seulement le nom du patient, une avec le nom et l’âge,
une avec le nom, l’âge et le service d’admission.

 Exemple — Exercice 6 : Static et final

Créez une classe Universite avec une constante static final représentant le nombre
maximal d’étudiants par filière, et une variable static comptant le nombre total d’étudiants
inscrits, incrémentée à chaque création d’objet Etudiant. Affichez ce compteur après avoir
créé plusieurs étudiants.

19 Ú Licence 2 — Informatique