Poo2 1

POO
Initiation à la programmation orientée objet
A. GUEDDES
Université de Sousse
ISITCom
Sousse 2023/2024
A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 1 / 159

Contenu
Objectifs : Cet enseignement est conçu pour les étudiants qui n’ont pas encore eu
l’occasion d’explorer la Programmation Orientée Objet. Il vise à introduire les
concepts fondamentaux de ce paradigme de programmation et à illustrer leur mise
en pratique en utilisant le langage Java.
Contenus abordés :
Introduction aux concepts fondamentaux : modularité, réutilisation, langages
orientés objet.
Compréhension des notions d’objet et de classe : création d’instances,
utilisation ; utilisation des constructeurs et destructeurs ; gestion des attributs
et des méthodes, surcharge des méthodes ; copie et comparaison d’objets.
Exploration des concepts d’encapsulation, de droits d’accès, de paquetages ;
approfondissement de la composition et de l’héritage.
Premiers pas dans l’apprentissage du langage Java POO.
Langages utilisés : Java

Introduction
Introduction

Introduction Problématique du développement logiciel
Problématique du développement logiciel
L’élaboration d’un logiciel devient complexe lorsqu’elle nécessite la mobilisation de

diverses ressources, à savoir :
1 Ressources humaines.
2 Ressources matérielles.
3 Ressources technologiques.

Introduction Problématique du développement logiciel
Problématique du développement logiciel
1. Un processus clairement défini : le cycle de vie d’un logiciel

Prévoir et planifier les étapes de développement.
Coordonner les activités de conception, de production et de validation.
S’adapter aux évolutions des objectifs.
2. Une méthodologie rigoureuse basée sur des modèles
Utilisation de représentations sémantiques simplifiées du système pour une
meilleure analyse et compréhension, facilitant ainsi la phase de conception.

Introduction Cycle de vie d’un logiciel
Cycle de vie d’un logiciel
1 L’expression des besoins

Identification des fonctionnalités du système à étudier.
Détermination de la manière d’utiliser ce système.
2 Les spécifications du système
Élimination des ambiguïtés et des redondances du cahier des charges.
3 L’analyse
Définition du système en dehors de toute considération technique et
informatique, en se concentrant sur le ”quoi”.
4 La conception
Prise en compte de l’environnement technique pour déterminer la manière de
résoudre le problème posé, en se mettant d’accord sur le ”comment”.

Introduction Cycle de vie d’un logiciel
Cycle de vie d’un logiciel
5 L’implémentation
Traduction de la conception en code dans un langage de programmation, en
une base de données, etc.
6 Les tests
Vérification de la correctitude de l’implémentation.
7 La validation
Vérification que le système correspond aux besoins.
8 La maintenance et l’évolution pendant la phase d’exploitation

L’approche orientée objet
L’approche orientée objet

L’approche orientée objet La qualité d’un logiciel
La qualité d’un logiciel
La qualité d’un logiciel peut être évaluée en fonction des critères suivants :
1 Exactitude : la capacité d’un programme à produire les résultats souhaités
conformément aux spécifications.
2 Robustesse : la capacité à maintenir un comportement adéquat même lorsque
l’utilisateur s’éloigne des conditions d’utilisation normales.
3 Extensibilité : la facilité avec laquelle un programme peut être adapté pour
répondre à l’évolution des spécifications.
4 Réutilisabilité : la possibilité d’utiliser des parties du logiciel pour résoudre
d’autres problèmes similaires.
5 Portabilité : la facilité avec laquelle le logiciel peut être déployé et utilisé dans
différentes configurations.
6 Efficacité : la mesure du temps d’exécution et de la consommation des
ressources.

La qualité d’un logiciel
La programmation structurée a apporté des améliorations significatives dans les

domaines suivants :
1 La robustesse.
2 L’exactitude.
Important
Lors de l’extension et de la réutilisation du code, des modifications peuvent être
nécessaires ⇒ peut potentiellement perturber les modules existants.

Les limites de l’approche fonctionnelle
Décomposition hiérarchique en fonctions.

Hiérarchie statique imposée par le découpage.
Complexité des modifications lors de l’évolution.
Un seul état partagé (mémoire) et sa conséquence sur la réutilisabilité du
code.

L’approche objet
On considère ce que le système doit faire, mais aussi ce qu’il est :

Ce que le système est : décomposition en objets (représentation du monde
réel).
Ce que le système fait : les objets communiquent entre eux par appels de
fonctions (méthodes) ; envoi dynamique des messages.
Avantage
=⇒ L’évolution du système ne remet en cause que l’aspect dynamique, sans
affecter la structure des objets.

Programmation Procédurale VS Orientée Objet
1 En programmation procédurale :
Décomposition des tâches en sous-tâches.
2 En programmation orientée objet :
Identification des acteurs (les entités comportementales) du problème.
Détermination de la façon dont ces acteurs doivent interagir pour résoudre le
problème.

Composants Fondamentaux d’un Objet
Définition
Objet = Etat + Comportement [+ Identité]
1 Etat : Les valeurs des attributs (données) d’un objet.

2 Comportement : Les opérations possibles sur un objet, déclenchées par des
stimulations externes telles que les appels de méthodes ou les messages
envoyés par d’autres objets.
3 Identité : Chaque objet possède une existence propre, occupant une place en
mémoire qui lui est propre, et il est différencié des autres objets par son nom.

Embarquement de l’État dans un Objet
On embarque dans une entité (un objet) son état (mémoire).
Une Voiture Une Personne
- BMW - Foulen
- iX3 Etat - Foulani Etat
- 51 Km/H - 25 ans
… …

Pour résumé
Pour résumé
Un objet est une entité autonome regroupant un état et les fonctions
permettant de manipuler cet état.
Un attribut est l’une des variables de l’état d’un objet.

L’approche orientée objet Les classes
Regroupement en Classes
Pour réduire la complexité d’un système complexe, on regroupe des objets

en classes.
Une classe est une description d’un ensemble d’objets partageant une
structure de données commune (attributs) et disposant des mêmes
méthodes.
En d’autres termes, une classe = type.

L’approche orientée objet Les classes
Classe et Instance
Définition
Une classe définit un ensemble d’objets ayant des propriétés communes. Les
objets d’une même classe partagent des attributs et des méthodes.
Une classe peut être considérée comme un modèle d’objet.
Une instance d’une classe est l’un des objets représentant la classe.
Nom de la classe
- Attribut1 : type
- Attribut2 : type
- Attribut3 : type
Représentation gra-
…
phique d’une classe
+ Mèthode1(...) : type
…

L’approche orientée objet Identification des Objets, Attributs et de Méthodes
Identification des Objets en POO
1 À partir d’un cahier des charges, commencez par établir une liste de
mots-clés. Chaque mot-clé peut potentiellement être une classe.
2 Réduisez la liste en supprimant les synonymes et les classes non
pertinentes pour votre application.
3 Gardez à l’esprit que les classes peuvent évoluer au fur et à mesure de
l’implémentation. Vous pouvez ajouter de nouvelles classes au besoin pour
affiner votre liste de classes.

L’approche orientée objet Identification des Objets, Attributs et de Méthodes
Ajout d’Attributs et de Méthodes en POO

1 Les mots-clés non utilisés peuvent souvent être définis comme des attributs
des classes.
2 Parfois, il est difficile de choisir entre une classe et un attribut :
Un attribut est caractérisé par sa valeur.
Un attribut d’une classe peut être un objet =⇒ agrégation de classes.
3 Les services qu’une classe doit rendre sont définis par ses méthodes, ce sont
les opérations qu’elle peut effectuer.
Exemple :
Les Administrateurs doivent pouvoir créer un nouvel emploi du temps en
spécifiant un nom (par exemple, ”Semestre 1”, ”Semaine de travail”, etc.). Ils
doivent également pouvoir définir la période de validité de l’emploi du temps
(dates de début et de fin). L’utilisateur peut choisir les jours de la semaine
pour lesquels l’emploi du temps sera valable (par exemple, du lundi au vendredi).
Les utilisateurs doivent avoir la possibilité d’exporter leur emploi du temps sous
forme de fichier (par exemple, format CSV ou JSON) pour sauvegarde.

POO & Java
POO & Java

POO & Java Caractéristiques Essentielles de Java
Caractéristiques Essentielles de Java
Java a été conçu par les concepteurs James Gosling et Bill Joy de Sun
Microsystems avec les caractéristiques suivantes :
1 Indépendant de la machine et du système d’exploitation sous-jacent (Portable).
2 Complet :
Programmation réseau avancée.
Programmation d’interface utilisateur graphique.
...
3 Simple :
Orienté objet (syntaxe proche du C/C++).
La gestion de la mémoire n’est pas à la charge de l’utilisateur.

POO & Java Caractéristiques Essentielles de Java
La Machine Virtuelle Java (JVM)
La JVM (Java Virtual Machine) est au cœur de l’exécution des programmes

Java.
Voici le processus de base :
1 Les fichiers sources Java (.java) contiennent le code source du programme.
2 Compilation avec le compilateur Java (javac) pour produire du code
exécutable.
3 Le code exécutable est stocké dans des fichiers .class, sous forme de byte-code.
4 Les bibliothèques externes sont également compilées en byte-code (.class).
5 La JVM, indépendante du système d’exploitation (OS), est responsable de
l’exécution du byte-code Java.

POO & Java La Machine Virtuelle Java (JVM)
La Machine Virtuelle Java (JVM)
Fichiers
sources (.java)
Compilation
(javac)
OS (Mac OS,
Code exécutable Java Virtual
Windows,
(byte-code) (.class) Machine
Linux, ...)
Librairies externes
(byte-code) (.class)
Figure – Diagramme de la Machine Virtuelle Java (JVM)

POO & Java La Machine Virtuelle Java (JVM)
Premier Programme Java : HelloWorld.java
p u b l i c c l a s s HelloWorld { Étapes :
p u b l i c s t a t i c v o i d main ( 1 Code source : HelloWorld.java
String [ ] args ) {
System . out . p r i n t l n ( ”
2 Compilation : javac
H e l l o World ” ) ; HelloWorld.java produisant le
} fichier HelloWorld.class
} 3 Exécution (interprétation) : java
HelloWorld

POO & Java La syntaxe et les éléments de bases de Java
Types de Base en Java
Java est un langage fortement typé et propose plusieurs types de base,

notamment :
1 boolean : peut être true ou false.
2 char : représente un caractère sur 16 bits en Unicode.
3 byte : représente un entier signé sur 8 bits.
4 short : représente un entier signé sur 16 bits.
5 int : représente un entier signé sur 32 bits.
6 long : représente un entier signé sur 64 bits.
7 float : représente un nombre flottant sur 32 bits.
8 double : représente un nombre flottant sur 64 bits.

Instructions Conditionnelles en Java
Java offre des instructions conditionnelles pour prendre des décisions dans un
programme :
if ... else : Permet d’exécuter un bloc de code si une condition est vraie,
sinon un autre bloc est exécuté.
switch : Utilisé pour gérer des situations où une variable peut avoir plusieurs
valeurs possibles et exécuter différentes actions en fonction de la valeur de la
variable.

Instruction d’Affectation et Répétition en Java
En Java, l’instruction d’affectation (=) est utilisée pour attribuer une valeur à une
variable.
Les instructions de répétition permettent d’itérer à travers un bloc de code
plusieurs fois :
for : Utilisé pour exécuter un bloc de code un nombre spécifique de fois.
while : Permet de répéter un bloc de code tant qu’une condition est vraie.
do...while : Similaire à while, mais garantit au moins une exécution du
bloc de code avant de vérifier la condition.

Instructions Arithmétiques et Logiques en Java
Les instructions arithmétiques et logiques en Java sont similaires à celles du

langage C :
Arithmétiques : Vous pouvez effectuer des opérations mathématiques telles
que l’addition, la soustraction, la multiplication et la division avec des
opérateurs comme +, -, *, /.
Logiques : Les opérateurs logiques tels que && (ET logique), || (OU logique),
et ! (NON logique) sont utilisés pour évaluer les conditions logiques.

Initialisation des Variables en Java
En Java, toute variable locale à une méthode doit être initialisée avant d’être
utilisée. Voici un exemple :
void illustration () {
int i, j;
i++; // Erreur de compilation : i n'est pas initialisée
j = 0;
if (j == 1) i = 0;
i++; // Erreur : i n'est toujours pas initialisée
}
Dans cet exemple, la variable ‘i‘ n’est pas initialisée avant son utilisation, ce qui
provoque des erreurs de compilation. Il est essentiel d’initialiser correctement les
variables locales en Java pour éviter de tels problèmes.

Les Tableaux en Java

En Java, les tableaux permettent de stocker un ensemble d’éléments de même
type. Voici les étapes de base pour travailler avec des tableaux :
1 Déclaration d’un tableau à une dimension :
type nom [];
2 Dimensionnement d’un tableau (utilisation de l’opérateur new) :

nom = new type[taille ];
3 Construction des éléments d’un tableau avec une boucle :

for (int i = 0; i < taille; i++) {
nom[i] = new type (); // Utilisation du constructeur
}
4 Obtenir la longueur d’un tableau :

int longueur = nom.length;

Exemple : Utilisation de Tableaux en Java

Supposons que nous voulions stocker les notes de cinq étudiants dans un tableau
en Java.
int[] notes;// Déclaration d'un tableau d'entiers pour stocker les
notes
notes = new int [5]; // Dimensionnement du tableau pour stocker 5 notes
// Initialisation des notes avec des valeurs
notes [0] = 85; notes [1] = 92;
notes [2] = 78; notes [3] = 95; notes [4] = 88;
// Calcul de la moyenne des notes
int somme = 0;
for (int i = 0; i < notes.length; i++) {
somme += notes[i];
}
double moyenne = somme / notes.length;
// Affichage de la moyenne
System.out.println("Moyenne des notes : " + moyenne);
Dans cet exemple, nous avons déclaré un tableau d’entiers ‘notes‘, dimensionné le
tableau pour contenir 5 notes (Allocation de la mémoire), initialisé les notes avec
des valeurs, calculé la moyenne, et affiché le résultat.
Les Chaînes de Caractères en Java

En Java, les chaînes de caractères sont largement utilisées pour manipuler du
texte. Voici les opérations de base sur les chaînes :
1 Déclaration d’une chaîne de caractères :
String chaine;
2 Affectation d’une chaîne de caractères :

chaine = "2 IOT";
3 Concaténation de chaînes :
chaine = chaine + " ISITCom";
4 Obtention de la longueur d’une chaîne :

int longueur = chaine.length ();
Les chaînes de caractères en Java sont des objets de type ‘String‘ qui offrent de
nombreuses méthodes pour la manipulation de texte.
Les Classes en Java

Une classe est un modèle pour créer des objets. Exemple de classe ‘Point‘ :
class Point {
// Attributs de la classe
int abscisse;
int ordonnee;
String label;
// Méthode d'initialisation
void Initialisation(int x, int y, String l) {
abscisse = x;
ordonnee = y;
label = l;
}
// Méthode de translation
void translation(int xd , int yd) {
abscisse += xd;
ordonnee += yd;
}
}
Nous avons dans cette classe ???? attributs (‘abscisse‘, ‘ordonnee‘, ‘label‘) et
???? méthodes (‘Initialisation‘ et ‘translation‘) pour manipuler ses objets.
Les Classes en Java
Les Classes en Java

Les Classes en Java Les Classes en Java
Les Classes en Java

Une classe est un modèle pour créer des objets. Exemple de classe ‘Point‘ :
class Point {
int abscisse;
int ordonnee;
String label;
// Méthode d'initialisation
void Initialisation(int x, int y, String l) {
abscisse = x;
ordonnee = y;
label = l;
}
// Méthode de translation
void translation(int xd , int yd) {
abscisse += xd;
ordonnee += yd;
}
}
Nous avons dans cette classe trois attributs (‘abscisse‘, ‘ordonnee‘, ‘label‘) et
deux méthodes (‘Initialisation‘ et ‘translation‘) pour manipuler ses objets.
Les Classes en Java Création et manipulation d’un Objet en Java
Création d’un Objet en Java
En Java, la création d’un objet implique les étapes suivantes :

1 Déclaration d’un objet (instance d’une classe) :
Point a;
2 Allocation de l’espace mémoire de l’objet ‘a‘ :

a = new Point ();
Dans cette séquence, nous déclarons d’abord un objet ‘a‘ de type ‘Point‘, puis
nous allouons l’espace mémoire nécessaire à cet objet en utilisant l’opérateur new.

Manipulation d’un Objet en Java
Pour manipuler un objet en Java, vous pouvez effectuer les actions suivantes :
1 Accès à un attribut :
Pour accéder à un attribut d’un objet, utilisez le nom de l’objet suivi du nom
de l’attribut.
Exemple :a.abscisse;
2 Appel d’une méthode :
Pour appeler une méthode d’un objet, utilisez le nom de l’objet suivi du nom
de la méthode, suivi éventuellement des arguments entre parenthèses.
Exemple : a.translation(1, 5);
=⇒ Manipuler les objets et d’interagir avec leurs attributs et méthodes.

Comparaison entre C et Java 1/2

Code C : Code Java :
typedef struct { class Compte {
int solde; int solde;
int numero; int numero;
char *proprietaire; String proprietaire;
} Compte;
void creation(int num , String
void creation(Compte *c, int num , prop) {
char *prop) { solde = 0;
c->solde = 0; numero = num;
c->numero = num; proprietaire = prop;
c->proprietaire = prop; }
}
void depot(Compte *c, int montant) void depot(int montant) {
{ solde = solde + montant;
c->solde = c->solde + montant; }
}
void retrait(Compte *c, int montant void retrait(int montant) {
) { solde = solde - montant;
c->solde = c->solde - montant; }
} }

Comparaison entre C et Java 2/2
Code C : Code Java :

Compte* unCompte; Compte unCompte = new Compte ();
unCompte = (Compte *) malloc(sizeof( unCompte.creation (1234 , "Flen
Compte)); Flouleni");
creation(unCompte , 1234, "Flen unCompte.depot (1000);
Flouleni"); unCompte.retrait (450);
depot(unCompte , 1000); System.out.println("Il reste " +
retrait(unCompte , 450); unCompte.solde +
printf("Il reste %d a %s\n", " a " + unCompte
unCompte ->solde , .proprietaire);
unCompte ->proprietaire);

Les Classes en Java Exercice : Écrire une Classe Java
Exercice : Écrire une Classe Java
Exercice : Écrivez une classe Java nommée ‘Rectangle‘ qui a les attributs
suivants :
Longueur (‘longueur‘) de type double.
Largeur (‘largeur‘) de type double.
La classe doit avoir une méthode ‘initialiser‘ qui prend deux paramètres
(‘longueur‘ et ‘largeur‘) pour initialiser les attributs.
Ensuite, elle doit avoir une méthode ‘calculerAire‘ qui calcule et renvoie l’aire du
rectangle en multipliant la longueur par la largeur.
// Pour afficher un message à l'écran
System.out.println("L'aire du rectangle est : " + aire);

Correction de l’Exercice 1/2
class Rectangle {
double longueur;
double largeur;
// Méthode pour initialiser les attributs
public void initialiser(double a, double b) {
longueur = a;
largeur = b;
}
// Méthode pour calculer l'aire
public double calculerAire ()
{return longueur * largeur ;}
}

Correction de l’Exercice 2/2
// Exemple d'utilisation de la classe

public class Main {
public static void main(String [] args) {
Rectangle monRectangle = new Rectangle ();
monRectangle.initialiser (5.0, 3.0);
double aire = monRectangle.calculerAire ();
System.out.println("L'aire du rectangle est : " + aire); }
}

Les Classes en Java Surcharge et constructeurs
Signature d’une Méthode en Java

En Java, la signature d’une méthode est une caractéristique essentielle pour la
distinguer des autres méthodes. La signature d’une méthode est composée des
éléments suivants :
Le nom de la méthode.
La liste ordonnée des paramètres qu’elle accepte en entrée.
Les éléments suivants ne font pas partie de la signature d’une méthode :
Le modificateur de visibilité.
Le type de retour.
Le modificateur static.
La clause throws.
Remarque
Une classe ne peut pas avoir deux méthodes qui possèdent la même signature. ⇒
Il n’est pas possible d’avoir dans une classe deux méthodes portant le même nom
et prenant les mêmes paramètres, mais ayant des types de retour différents.

Surcharge des Méthodes en Java
En Java, plusieurs méthodes peuvent avoir le même nom, mais elles doivent se
différencier par la liste de leurs arguments. Ce concept est appelé la surcharge
de méthodes.
Exemple :
void methode(int i, int j) {...};
void methode(int i, char j) {...};
Le choix de la méthode à appeler se fait au moment de la compilation. La
méthode qui correspond le mieux à l’appel spécifique est choisie.

Constructeurs en Java
Définition
Un constructeur est une méthode particulière qui porte le même nom que
la classe qui la contient. Le constructeur est appelé automatiquement lors de
la création de l’objet à l’aide de la méthode new.
La syntaxe d’un constructeur est la même que celle d’une méthode ordinaire,
mais il n’indique aucun type de paramètre de retour.
Exemple :
class Exemple {
// Constructeur
Exemple () {
// Initialisation de l'objet
}
}

Constructeurs en Java
Un constructeur est utile pour initialiser les attributs de l’objet qu’il crée. Il
permet de configurer l’objet dès sa création.
Exemple :
Dans la classe ‘Point‘, nous pouvons avoir un constructeur comme suit :
class Point {
int abscisse;
int cordonnee;
String label;
// Constructeur
Point(int x, int y, String l) {
abscisse = x;
cordonnee = y;
label = l;
}
}
Vous pouvez créer un objet ‘Point‘ et l’initialiser en utilisant le constructeur :

Point c = new Point(5, 10, "c");

Caractéristiques des Constructeurs en Java
En Java, les constructeurs ont certaines caractéristiques importantes :

Un constructeur ne peut pas être déclaré ‘abstract‘, ‘synchronized‘, ou ‘final‘.
Il peut y avoir plusieurs constructeurs dans une classe, et ils se différencient
par la liste de leurs paramètres.
Un constructeur ne peut pas être appelé explicitement par le nom de la
méthode.
À toute classe est associé un constructeur par défaut, qui est sans paramètres
et n’effectue aucune opération spécifique.
Les constructeurs sont essentiels pour initialiser les objets lors de leur création.

Appel de Constructeur en Java avec ‘this‘

Un constructeur peut appeler un autre constructeur de la même classe en utilisant
le mot clé this pour l’auto-référencement.
public class Voiture {
int nbPortes;
String marque;
Voiture(String marque , int nbPortes) {
// Utilisation de this pour distinguer les attributs des
paramètres
this.marque = marque;
this.nbPortes = nbPortes;
}
Voiture(String marque) {
// Appel d'un autre constructeur avec this
this(marque , 5);
}
}
this est utilisé pour distinguer les attributs de la classe des paramètres
passés.
Voiture(String marque) appelle le premier constructeur (this(marque, 5)) pour
initialiser une voiture avec une marque et un nombre de portes par défaut.
Initialisation par Défaut des Attributs
En Java, les attributs d’un objet sont toujours initialisés par défaut selon les règles
suivantes :
Les attributs de type numérique (comme ‘int‘, ‘float‘, ‘double‘, etc.) sont
initialisés à 0 par défaut.
Les attributs de type référence (comme les objets) sont initialisés à null par
défaut.
Vous pouvez également effectuer une initialisation explicite de la valeur d’un
attribut lors de sa déclaration, comme suit :
int abscisse = 5;
Cela assigne la valeur 5 à l’attribut ‘abscisse‘ lors de sa déclaration.

Destruction d’Objets en Java
En Java, la libération des ressources mémoire acquises avec l’opérateur ‘new‘ est
automatique grâce au ramasse-miettes (garbage collector). Cela signifie que la
mémoire d’un objet qui n’est plus référencé peut être récupérée à tout moment.
Exemple :
Voiture citroen = new Voiture ();
Voiture peugeot = new Voiture ();
citroen = null; // La première voiture n'est plus référencée
Dans cet exemple, lorsque ‘citroen‘ est défini à ‘null‘, la première voiture n’est
plus référencée, ce qui signifie que le ramasse-miettes peut récupérer la mémoire
associée à cet objet.

Destruction d’Objets en Java
Lorsqu’il est nécessaire de détruire un objet en Java, on peut faire appel à la

méthode void finalize(), si celle-ci est définie dans la classe Object.
Cette méthode permet d’effectuer des opérations de nettoyage avant la
destruction de l’objet.
Il est important de noter que les ressources non Java, telles que les fichiers,
doivent être libérées explicitement.

La Classe Object en Java

En Java, toutes les classes héritent de la classe ‘Object‘.
‘Object‘ est la classe de base pour toutes les classes Java.
Elle définit des méthodes et des comportements de base que toutes les
classes peuvent utiliser.
Méthodes Principales
‘equals(Object obj)‘ : Compare deux objets pour l’égalité.
‘hashCode()‘ : Renvoie le code de hachage de l’objet.
‘toString()‘ : Renvoie une représentation sous forme de chaîne de caractères
de l’objet.
‘getClass()‘ : Renvoie la classe de l’objet.
‘finalize()‘ : Méthode appelée avant que l’objet ne soit détruit par le
ramasse-miettes (garbage collector).
Vous pouvez redéfinir ces méthodes dans vos propres classes pour
personnaliser leur comportement.
Par exemple, redéfinir ‘toString()‘ pour fournir une description personnalisée
de votre objet.
Éléments Statiques en Java

Éléments Statiques en Java Les membres statiques
Un élément statique est attaché à la classe plutôt qu’à une de ses instances.
Il peut exister, être référencé et s’exécuter même si aucune instance de cette
classe n’existe.
Les éléments statiques ne peuvent pas référencer ‘this‘.
Il existe quatre types d’éléments statiques :
Attributs statiques : La valeur de ce champ est la même pour tous les objets
instances de la classe.
Méthodes statiques : Des méthodes qui peuvent être appelées sur la classe
elle-même, indépendamment de toute instance.
Blocs statiques : Des blocs de code qui s’exécutent lors du chargement de la
classe, souvent utilisés pour initialiser des champs statiques.
Classes membres statiques : Des classes définies à l’intérieur d’une autre
classe, mais qui sont indépendantes de toute instance de la classe externe.

Éléments Statiques en Java Attributs statiques
Membres Statiques en Java 1/4
Par défaut, chaque instance de chaque classe occupe son propre espace mémoire.
Deux objets instances d’une même classe occupent donc deux espaces mémoire
qui ne se recouvrent pas.
Membres Statiques :
Lorsque l’on déclare un membre statique (static), il est placé dans un espace
mémoire commun à tous les objets de la classe. Si l’un des objets modifie la
valeur d’un champ statique, tous les objets verront la valeur de ce champ modifiée.
Utilisation de Membres Statiques :

Il est une bonne pratique d’appeler les membres statiques d’une classe de manière
”statique”, c’est-à-dire en utilisant le nom de la classe plutôt qu’une de ses
instances.
Il est même possible d’invoquer un élément statique d’une classe sans que celle-ci
n’ait jamais été instanciée.

Soit l’exemple suivant

public class Compteur {
int val;
public Compteur(int j) {
val = j; Compteur C1
}
val = 1
public static void main(String
[] args) {
Compteur C1 = new Compteur
(1); Compteur C2
Compteur C2 = new Compteur
(2); val = 2
}
}
⇒ L’utilisateur doit ajouter la valeur manuellement (ce qui peut ne pas être
pratique pour les systèmes complexes).

Membres Statiques :
La déclaration d’un membre en tant que static permet de le partager entre
toutes les instances d’une classe.
public class Compteur { public class Compteur {

static int cpt = 0; int val;
int val;
public Compteur () { public Compteur(int j) {
cpt ++; val = j;
val = cpt; }
}
public static void main(String public static void main(String
[] args) { [] args) {
Compteur C1 = new Compteur (); Compteur C1 = new Compteur
Compteur C2 = new Compteur (); (1);
System.out.println("Compteur : Compteur C2 = new Compteur
" + Compteur.cpt); (2);
} }
} }


Exemple :

// ... Suite de code précédent
Compteur C1 = new Compteur ();
Compteur C2 = new Compteur ();
Compteur C3 = null ;
// affiche 2
System.out.println("Nombre de Compteurs = " + Compteur.cpt) ;
// affiche 2, méthode non recommandée

System.out.println("Nombre de Compteurs = " + C2.cpt) ;
// affiche 2, bien que marin2 soit null

System.out.println("Nombre de Compteurs = " + C3.cpt) ;
}
}

Constantes en Java
La bonne pratique pour définir une constante en Java est de la déclarer dans un
champ public static final .
public class Math {
public static final double PI = 3.14159265358979323846;
}
Vous pouvez ainsi utiliser la constante Math.PI dans n’importe quel programme
Java.
Évolution de la gestion des constantes :
La gestion des constantes a évolué entre Java 1.4 et Java 5. Dans Java 5, une
nouvelle notion appelée ”import statique” a été introduite : import static
MaClasse.MaConstante .

Éléments Statiques en Java Bloc statique
Blocs Statiques en Java
Définition
En Java, les blocs statiques sont des ensembles d’instructions exécutés lors du
chargement de la classe, avant la création d’objets.
Ils sont déclarés avec la syntaxe suivante :

static
{
System.out.println("Le bloc statique est exécuté.");
valeurStatique = 42;
}
Les blocs statiques peuvent affecter la testabilité du code(Effets globaux non

isolables, Difficulté à réinitialiser l’état, Couplage fort, Difficulté à substituer des
dépendances), donc leur utilisation doit être prudente.

Éléments Statiques en Java Méthodes Statiques
Méthodes Statiques en Java

static int cpt = 0;
En Java, les méthodes statiques
public Compteur () { sont des méthodes associées à une
cpt ++; classe plutôt qu’à une instance
} d’objet. Elles sont définies avec le
static int combien () {
return cpt; mot-clé static. Par exemple, la
} méthode ‘combien‘ dans la classe
public void finalize () { ‘Compteur‘ est statique.
cpt --;
} Autre exemple : Math.sqrt(a) est
une méthode statique de la classe
public static void main(String prédéfinie Math.
[] args) {
Compteur c1 = new Compteur Les méthodes statiques sont
(); communes à toutes les instances de
System.out.println(Compteur la classe. Elles peuvent être
.combien ());
} appelées par le nom de la classe et
} ne peuvent accéder qu'aux
données membres statiques.

Éléments Statiques en Java Exercice
Exercice : Classe Voiture
Définir une classe Voiture avec les attributs suivants : Id, Marque, Vitesse,
Puissance.
Écrire un constructeur permettant d’initialiser les attributs d’un objet voiture
par des valeurs passées en paramètre. Notez que Id doit être auto-incrémenté.
Créer une méthode getCptMax qui retourne le numéro du dernier objet créé.
Écrire la méthode toString() permettant d’afficher les informations d’une
voiture.
Fournir la représentation graphique de la classe Voiture.
Écrire un programme de test pour la classe Voiture avec les données
suivantes :
id=1, marque=BMW, vitesse=220.0, puissance=8
id=2, marque=Ford, vitesse=200.0, puissance=6
id=3, marque=Audi, vitesse=240.0, puissance=8
Afficher le nombre de voitures créées à la fin du programme.

Éléments Statiques en Java Exercice
Correction : Classe Voiture

public class Voiture {
public class TestVoiture {
private static int cpt = 0;
public static void main(String
private int id; private
[] args) {
String marque;
Voiture v1 = new Voiture("
private double vitesse;
BMW", 220.0 , 8);
private int puissance;
public Voiture(String marque ,
Ford", 200.0 , 6);
double vitesse , int puissance)
{
Audi", 240.0 , 8);
this.id = ++cpt;
this.marque = marque;
System.out.println(v1.
this.vitesse = vitesse;
toString ());
this.puissance = puissance
;}
toString ());
public static int getCptMax () {
return cpt;}
toString ());
@Override
public String toString () {
System.out.println("Le
return "id=" + id + ",
nombre de voitures est : " +
marque=" + marque + ", vitesse=
Voiture.getCptMax ());
" + vitesse + ", puissance=" +
}
puissance; }}
}
Les Relations Entre les Classes - Agrégation

Agrégation
L’agrégation est une relation de type ”composé/composant”.
Elle exprime que l’un des objets est composé des autres objets.
C’est une relation du type ”est partie de” ou ”est composé de”.
L’agrégation implique un couplage fort entre les classes.
La durée de vie des composants est liée à celle de l’agrégat.
Exemple : Une classe ”Équipe” est composée de plusieurs objets ”Joueur”.

Les joueurs font partie de l’équipe, et lorsque l’équipe est dissoute, les joueurs
le sont aussi.

Agrégation entre Moteur et Voiture
Exemple de Code en Java
public class Moteur {

// Attributs et méthodes du moteur Relation d’Agrégation (UML)
} La classe Voiture contient
public class Voiture { un attribut de type Moteur.
private Moteur moteur; L’agrégation est représentée
par un losange creux du
public Voiture () {
moteur = new Moteur (); côté de Voiture.
} La voiture ”a” un moteur.
// Autres attributs et méthodes de la La durée de vie du moteur
voiture est liée à celle de la voiture.
}

Exercice Java - Agrégation, Attribut Statique, Surcharge

Vous devez créer une application de gestion de bibliothèque. Pour cela, vous allez
concevoir deux classes : ‘Livre‘ et ‘Bibliotheque‘.
La classe ‘Livre‘ doit avoir les attributs suivants : - Titre - Auteur - ISBN (un
numéro d’identification unique) - Nombre de pages
La classe ‘Bibliotheque‘ doit avoir un attribut statique ‘nbLivres‘ pour suivre
le nombre total de livreset un tableau pour stocker ses Livres.
Définissez des constructeurs pour les deux classes, permettant d’initialiser les
attributs. Le constricteur ’Bibliotheque’ prend en paramètre le nombre
maximum des livre (pour initialiser le tableau).
Implémentez une méthode ‘ajouterLivre‘ dans la classe ‘Bibliotheque‘, qui
permet d’ajouter un livre à la bibliothèque. Cette méthode incrémente
également le compteur ‘nbLivres‘.
Redéfinissez la méthode toString()‘de la classe ‘Livre‘ pour affiche les
informations du livre.
Créez quelques livres et une bibliothèque, ajoutez des livres à la bibliothèque
et affichez le nombre total de livres ainsi que les informations de chaque livre.
Correction de l’Exercice Java - Partie 1

Exercice : Gestion d’une Bibliothèque
// Classe Livre (Partie 1)
public class Livre {
private String titre;
private String auteur;
private String isbn;
private int nbPages;
public Livre(String titre , String auteur , String isbn , int
nbPages) {
this.titre = titre;
this.auteur = auteur;
this.isbn = isbn;
this.nbPages = nbPages;
}
// Méthode toString pour afficher les informations d'un livre
@Override
public String toString () {
return "Titre : " + titre + "\nAuteur : " + auteur + "\nISBN
: " + isbn + "\nNombre de pages : " + nbPages;
}
}


// Classe Bibliotheque (Partie 2)
public class Bibliotheque {
private static int nbLivres = 0;
private Livre [] livres; // Tableau pour stocker les livres
public Bibliotheque(int tailleMax)
{livres = new Livre[tailleMax ];}
// Méthode pour ajouter un livre
public void ajouterLivre(Livre livre) {
if (nbLivres < livres.length) {
livres[nbLivres] = livre;
nbLivres ++;
} else {System.out.println("La bibliothèque est pleine"); }
}
// Méthode pour obtenir le nombre total de livres
public static int getNbLivres () { return nbLivres; }
// Méthode pour afficher les informations de tous les livres
public void afficherLivres () {
System.out.println("Livres dans la bibliothèque :");
for (int i = 0; i < nbLivres; i++) {
System.out.println("Livre " + (i + 1) + ":" + livres[i]);
} }
}


Correction (Partie 3) :
// Exemple d'utilisation
Bibliotheque bibliotheque = new Bibliotheque (10); // Bibliothèque
avec une capacité de 10 livres
// Création de quelques livres

Livre livre1 = new Livre("Titre 1", "Auteur 1", "ISBN1", 200);
Livre livre2 = new Livre("Titre 2", "Auteur 2", "ISBN2", 250);
// Ajout des livres à la bibliothèque

bibliotheque.ajouterLivre(livre1);
bibliotheque.ajouterLivre(livre2);
// Affichage du nombre total de livres

System.out.println("Nombre total de livres dans la bibliothèque :
" + bibliotheque.getNbLivres ());
// Affichage des informations de tous les livres

bibliotheque.afficherLivres ();
}

Paquetage
Paquetage

Paquetage
La Structuration des Classes en Paquetages
Les Paquetages en Java :

En Java, les classes sont organisées en paquetages.
Les paquetages regroupent des classes sous un nom spécifique.
Ces paquetages sont organisés hiérarchiquement sous forme d’arborescence.
Pour référencer un paquetage, on utilise une notation pointée, par exemple,
java.awt.geom.
Les paquetages en Java suivent une arborescence logique.
Cette arborescence logique correspond à l’arborescence physique des
répertoires stockant les fichiers *.class des paquetages.
Par exemple, les classes du paquetage java.awt.geom sont stockées dans le
répertoire java/awt/geom à partir du répertoire racine des paquetages.

Paquetage
Inclure des Classes d’un Paquetage
Pour inclure les classes d’un fichier source dans un paquetage :

Placez la commande package MonPaquetage; en tête du fichier.
Les fichiers *.class créés sont stockés dans le répertoire MonPaquetage.
Pour utiliser les classes d’un paquetage, vous avez trois options :
1 Explicitez le paquetage de la classe en préfixant le nom de la classe par son
nom de paquetage : MonPaquetage.A a = new A() ;
2 Utilisez en tête du fichier l’instruction import suivie du nom du paquetage et
de la classe : import MonPaquetage.A ;. On n’a alors plus besoin de préfixer
le nom de la classe dans le reste du fichier : A a = new A() ;.
3 Importez toutes les classes d’un paquetage : import Monpaquetage.* ;. Plus
besoin de préfixer aucun nom de classe du paquetage.

Paquetage
Résumé des Paquetages en Java

En résumé :
Un package (paquetage) est un ensemble de classes.
Les classes d’un même package sont compilées dans un répertoire portant le
nom du package.
Le mot-clé package doit apparaître en premier dans un fichier source.
Pour compiler et organiser les fichiers .class dans des répertoires
correspondant aux paquetages, utilisez la commande :
javac -d Distributeur.java
Résultat : Dans le répertoire courant, vous avez Distributeur.java, et dans le
répertoire banque, vous avez Distributeur.class.
package MonProjet.banque;
public class Distributeur {

// ... le contenu de la classe Distributeur ...
}

Paquetage
Résumé d’utilisation des Packages en Java
package banque; package banque;
public class Distributeur { public class Banque {

int solde = 1000; public static void main(String []
} argv) {
Distributeur d = new
Distributeur ();
d.solde += 100;
}
}
Notes :
Par défaut, un membre est accessible depuis des classes sauvegardées dans
des fichiers différents du même package.
Les champs sans modificateur de visibilité (public, private, protected) ne sont
pas accessibles depuis un autre package. ⇒ Utilisation d’un package : import.

Encapsulation
Encapsulation

Encapsulation
Principe de l’Encapsulation
Définition
L’encapsulation est un concept clé en programmation orientée objet qui consiste à
masquer le plus possible les détails d’implémentation et le fonctionnement interne
des objets.
Principe : masquer les détails d’implémentation.

Effet : découpler les classes constituant un programme, de sorte que la
modification de la structure interne de l’une n’oblige pas à modifier l’autre.
Les avantages de l’encapsulation :
Simplification de la maintenance.
Meilleure organisation du code.
Protection des données en contrôlant l’accès aux attributs.

Encapsulation
Niveaux d’accès en Java
En Java, il est possible de restreindre l’accès aux classes, aux méthodes et aux
attributs. Cette restriction empêche leur référencement en dehors de leurs niveaux
d’accès.
Concernant les membres (méthodes et attributs) des classes, il existe 4 niveaux
d’accès :
Public : Accessible de n’importe où.
Private : Accessible uniquement à l’intérieur de la classe.
Protected : Accessible à l’intérieur de la classe, des sous-classes et du même
paquetage.
Default (privé paquetage) : pas de mot-clé, accessible uniquement à
l’intérieur du même paquetage.
En définissant les niveaux d’accès appropriés, on peut contrôler la visibilité et
l’accessibilité des éléments d’une classe, ce qui contribue à l’encapsulation et à la
sécurité du code.

Encapsulation
Niveaux d’accès des Classes en Java
Les classes peuvent avoir deux niveaux d’accès : public ou paquetage

(package-private).
Public : Une classe publique est accessible depuis n’importe où. Il peut y
avoir au maximum une classe publique par fichier source Java. Si une classe
contient la méthode de classe ‘main‘, elle doit être déclarée publique.
Paquetage (Package-Private) : Une classe avec un niveau d’accès
paquetage est accessible uniquement à l’intérieur du même paquetage. Cela
signifie qu’elle n’est pas visible en dehors du paquetage auquel elle appartient.

Encapsulation
Restrictions des Accès en Java
Le principe de base est de rendre tout le moins accessible possible.

Par défaut, tous les attributs et les méthodes sont privés au paquetage.
Il est essentiel de maintenir des restrictions d’accès appropriées pour garantir
l’encapsulation et la sécurité de votre code.
Toute levée de restriction d’accès doit être motivée et justifiée.

Encapsulation
En Pratique : Restrictions d’Accès en Java
Dans toutes les classes, tous les attributs seront privés.

Par exemple, dans la classe Compte, on rend privé l’accès aux attributs et à
la méthode retrait à un seul paramètre.
Cela empêche qu’un objet extérieur modifie une instance de Compte
n’importe comment.
class Compte {
private int solde , numero;
private String proprietaire;
public Compte(int numero , String prop) {...}
public void depot(int montant) {...}
private void retrait(int montant , String prop) {...}
public void virement(int montant , Compte dest) {...}

}

Encapsulation
Méthodes d’Accès en Java
Remarque : on peut avoir besoin de connaître le solde d’un compte.

Comme on doit interdire de modifier l’attribut solde de l’extérieur de la
classe, on va simplement écrire la méthode :
public int solde () {
return solde;
}
Cette méthode permet d’accéder au solde sans exposer directement l’attribut

solde.

Encapsulation
Méthodes d’Accès
De manière plus générale

lorsque nous avons besoin d’obtenir la valeur d’un attribut ou de la modifier, nous
utilisons des méthodes spéciales appelées méthodes d’accès :
1 Accesseur (Getters) : une méthode qui permet d’obtenir la valeur d’un
attribut : typeAtribut getNomAttribut().
2 Modifieur (Setters) : une méthode qui permet de définir une nouvelle
valeur pour un attribut : void setNomAttribut(typeAtribut nom).

Encapsulation
Pratique à Éviter
Un exemple de pratique à éviter est de déclarer directement des attributs dans une
classe sans utiliser de méthodes d’accès. Par exemple :
class A {
X x;
Y y;
void f(...) {
x = ...
}
int g(...) {
int a = y;
...
}
}
Remareque
Ce genre de pratique peut entraîner des problèmes, car si vous modifiez les
attributs, vous devrez également modifier toutes les classes qui les utilisent.
Encapsulation
Pratiques Recommandées
Pour éviter les problèmes, il est recommandé de déclarer les attributs comme
privés et d’utiliser des méthodes d’accès. Voici un exemple de bonne pratique :
class A {
private X x;
private Y y;
X getX () { return x; }
void setX(X x) { this.x = x; }
Y getY () { return y; }
void setY(Y y) { this.y = y; }
void f(...) {
x = ...}
int g(...) {
int a = y;
...}
}
Remareque
En suivant cette approche, si vous modifiez les attributs, vous n’aurez pas besoin
de changer toutes les méthodes de la classe.
Encapsulation
Bonnes Pratiques
Pour garantir une

textcolormyNewColorBencapsulation efficace et simplifier la maintenance du code,
il est recommandé de déclarer les attributs comme privés et d’utiliser des
méthodes d’accès. Voici une approche optimale :
class A {
private X x;
private Y y;
X getX () { return x; }
void setX(X x) { this.x = x; }
Y getY () { return y; }
void setY(Y y) { this.y = y; }
void f(...) { setX (...); ... }
int g(...) { int a = getY (); ... }
}
En adoptant cette méthode, si vous modifiez les attributs, il vous suffira de mettre
à jour les méthodes d’accès de la classe, ce qui simplifie considérablement la
maintenance.

Généralisation et spécialisation

Généralisation
La généralisation consiste à regrouper les éléments communs à plusieurs classes

(sous-classes) dans une classe plus générale appelée une super-classe. Cela
modélise des relations du type «est un» ou «une sorte de».
Favorise la réutilisation du code.
Modélise les relations hiérarchiques.
Permet de définir des comportements communs.

Exemple UML : Généralisation et Spécialisation
Vehicule
Héritage
Moto Voiture Camion
Héritage
VoitureDiesel VoitureEssence
Généralisation : La classe Vehicule est la classe générale qui regroupe les

caractéristiques communes.
Spécialisation : Les classes Voiture, Moto, et Camion sont des sous-classes
spécialisées de Vehicule, héritant de ses attributs et méthodes.

L’Héritage en Programmation Orientée Objet
L’héritage est une technique de la programmation orientée objet qui permet

de réaliser la généralisation.
Son objectif est de créer facilement de nouvelles classes à partir de classes
existantes.
Pixel
Héritage
PixelCouleur
**Exemple :** La classe PixelCouleur hérite de la classe Pixel.

Relations d’Héritage et Spécialisation
Pixel est la classe de base.

PixelCouleur est la classe dérivée.
Pixel est la super-classe (classe mère) de PixelCouleur.
PixelCouleur est la sous-classe (classe fille) de Pixel.
Pixel
Héritage
PixelCouleur

Héritage en Java
// Déclaration de la classe Fille comme dérivée de Mere

class Fille extends Mere {
// Attributs et méthodes supplémentaires peuvent être ajoutés ici
}
La classe Fille étend (extends) la classe Mere.

La classe Fille hérite de tous les attributs et méthodes de la classe Mere.
Des attributs et méthodes supplémentaires peuvent être ajoutés à la classe
Fille.

Héritage en Java
Exemple :
class Vehicule {
String marque;
int annee;
void demarrer () {
System.out.println("Le véhicule démarre.");
}
}
class Voiture extends Vehicule {

int nombrePortes;
}
Ici, ‘Voiture‘ généralise les attributs et méthodes communs à tous les véhicules.

Exemple d’héritage en Java

public class Pixel {
private int x, y;
public Pixel(int a, int b) {...}
public void affiche () {...}
}
public class PixelCouleur extends Pixel {

private int couleur;
public PixelCouleur(int c) {...}
public static void main(String [] argv) {

PixelCouleur p = new PixelCouleur (3);
p.affiche ();
}
}
La classe PixelCouleur étend la classe Pixel.

Elle hérite de la méthode affiche() de la classe Pixel.
Le programme principal (main) crée une instance de PixelCouleur et
appelle sa méthode affiche().
Accès aux données membres de la classe de base

public class PixelCouleur
extends Pixel {
public PixelCouleur(int c)
{...} public class Pixel {
private int x, y;
public void deplacer(int dx , public Pixel(int a, int b)
int dy) { {...}
x = x + dx; // Erreur de public void affiche () {...}
compilation }
y = y + dy; // x et y
inaccessibles
}
}
La classe PixelCouleur hérite de la classe Pixel.

Tentative d’accéder aux membres x et y de la classe Pixel dans la méthode
deplacer.
Erreur de compilation car les membres x et y sont déclarés comme privés
dans la classe Pixel.
Accès aux données membres de la classe de base
Inaccessible
(Privée)
Pixel PixelCouleur
Publique
Les membres privés de la classe de base (Pixel) sont inaccessibles dans la

classe dérivée (PixelCouleur).
Les membres publics de la classe de base sont accessibles dans la classe
dérivée.

Diagramme des niveaux d’accès entre PixelCouleur et Pixel

(avec membres protégés)
PixelCouleur
Pixel
public void deplacer(int dx , int dy
protected int x, y; ) {
public Pixel(int a, int b) {...} x = x + dx;
public void affiche () {...} y = y + dy;
}
Pixel PixelCouleur Accès

Public accessible, Public
Protected accessible, Protected
Private Inaccessible
Protégée : Les membres protégés de Pixel sont accessibles depuis

PixelCouleur quels que soient les packages.

Accès aux données membres de la classe de base (avec

membres protégés)
À retenir
Les membres privés de la classe de base sont inaccessibles dans la classe
dérivée .
Les membres publics de la classe de base sont accessibles dans la classe
dérivée.
Un membre avec accès par défaut (sans modificateur) est accessible dans les
classes du même package.
Un membre protégé (protected) est accessible dans une classe fille du
même package ou d’un package différent(avec import).

Modificateurs d’accès en Java
Modificateur Dans le Sous-classe Sous-classe Non-sous-

d’accès même (même pa- (package classe
package ckage) différent) (package
différent)
‘public‘ Oui Oui Oui Oui
‘protected‘ Oui Oui Oui Non
‘default‘ Oui Oui Non Non
‘private‘ Non Non Non Non

Redéfinition de méthode en Java
En Java, la redéfinition de méthode se produit lorsqu’une méthode dans une classe

dérivée a la même signature qu’une méthode dans sa classe de base.
Exemple :
public class Animal { Appels de méthode :
public void faireDuBruit () {
System.out.println("L'animal Animal animal = new Animal ();
fait du bruit"); animal.faireDuBruit (); // "L'
}} animal fait du bruit"
public class Chien extends Animal {
public void faireDuBruit () { Chien chien = new Chien ();
System.out.println("Le chien chien.faireDuBruit (); // "Le
aboie"); chien aboie"
}}
La méthode faireDuBruit() dans la classe dérivée Chien redéfinit la

méthode dans la classe de base Animal.
L’appel de méthode dépend du type réel de l’objet.

Redéfinition des fonctions membres

Classe PixelCouleur (dérivée de
Pixel)
Classe Pixel
public void distance () {...}
Appel dans main()
Appel dans main() PixelCouleur pc = new PixelCouleur
();
Pixel p = new Pixel (); pc.distance (); // Appel de la
p.affiche (); méthode de Pixel
pc.affiche (); // Appel de la
méthode redéfinie
La classe PixelCouleur redéfinit la méthode affiche() de la classe Pixel.

Lorsqu’on appelle pc.affiche(), c’est la version redéfinie dans
PixelCouleur qui est exécutée.
La méthode distance() de la classe Pixel est accessible directement dans
PixelCouleur.
Quelques Points sur la Redéfinition en Java

1 Le mot-clé protected restreint l’accès à un membre à un même paquetage ou
à ses sous-classes.
2 L’ordre de visibilité : private < privé-paquetage < protected <
public.
3 Lors de la redéfinition d’une méthode, on peut seulement augmenter son
niveau d’accessibilité, pas le diminuer.
4 En utilisant le mot-clé final devant la déclaration d’une méthode, on interdit
la redéfinition de cette méthode dans ses sous-classes.
5 En utilisant le mot-clé final devant la déclaration d’une classe, on interdit sa
dérivation.
@Override
protected String toString () { // Erreur: Cannot reduce the visibility
of the inherited method from Object
return .....;
}

Utilisation du mot-clé super en Java
Pour référencer un attribut ou une méthode masqué de la superclasse depuis

une sous-classe, on utilise le mot-clé super.
Processus de recherche :
1 Recherche d’abord dans la classe de l’instance où l’appel est effectué.
2 Si non trouvé, recherche dans la superclasse.
3 Répéter le processus jusqu’à ce que l’élément soit trouvé ou que la recherche
atteigne la classe Object (classe racine de toutes les classes en Java).
Exemple d’utilisation :
super.nomAttribut : référence à un attribut de la superclasse.
super.nomMethode() : appel d’une méthode de la superclasse.

Constructeurs et super en Java
En Java, lorsqu’une classe dérivée possède un constructeur ayant la même

signature que celui de sa superclasse, ce dernier est remplacé.
Appel au constructeur de la superclasse :
Utilisation de super suivi des paramètres du constructeur de la superclasse.
L’appel doit se faire en début de la définition du constructeur de la classe
dérivée.
Si aucun appel explicite n’est fait, un appel implicite à super() est effectué.
Utilisation standard d’un constructeur :
Appel à un constructeur de la superclasse pour l’initialisation des attributs
de la superclasse.
Initialisation des attributs déclarés dans la classe dérivée.

Exemple : Constructeur et super en Java
public class Pixel { public class PixelCouleur extends

private int x, y; Pixel {
public Pixel(int a, int b) {
x = a; public PixelCouleur(int a, int b,
y = b; int c) {
} super(a, b); // Appel au
constructeur de la superclasse
public void affiche () { couleur = c;
System.out.println("Pixel : (" }
+ x + ", " + y + ")");
} @Override
} public void affiche () {
super.affiche (); // Appel à la
méthode de la superclasse
System.out.println("Couleur : "
+ couleur);
}
}

Généralisation et spécialisation Exercice Score
Classe Score
Créez une classe Score représentant le score d’un joueur.

Gérez trois données : le nom du joueur, son score (sonScore), et le score
maximal (scoreMax).
Écrivez une méthode afficher() qui affiche le nom et le score du joueur.
Ajoutez un constructeur avec des valeurs par défaut : nom ”inconnu”, score
initial 0, score maximal 100.
Ajoutez un second constructeur qui fixe le nom du joueur, éliminant la
redondance de code.
Ajoutez les méthodes lireScore(), modifierScore(int sco), et
ajouter(int points) pour gérer le score avec ses limites (0 <= sonScore
<= scoreMax).

Classe ScoreEssai
Créez la classe dérivée ScoreEssai de la classe Score.

Ajoutez deux constructeurs en utilisant le mot-clé super.
Redéfinissez la méthode modifierScore(int sco) en utilisant super pour
augmenter le nombre d’essais.
Ajoutez une méthode lireNbEssais() pour retourner le contenu de
l’attribut nbEssai.

Classe Jeu
Écrivez la classe principale Jeu simulant un jeu de lancer de dé jusqu’à

atteindre un total de 21 points.
Affichez le nombre d’essais.
Utilisez une boucle while avec la syntaxe : while (condition) { ... }.
Utilisez Double pour générer un objet aléatoire entre 1 et 6.99 avec
6*Math.random()+1.

Classe Score
class Score { public void ecrireScore(int sco

String nom; ) {
int sonScore; if (sco >scoreMax)
int scoreMax; sonScore=scoreMax;
void affiche () { else if (sco <0)
System.out.println(nom+" : sonScore =0;
"+sonScore); else
} sonScore=sco;
Score () }
{ public void ajoute(int points)
this("inconnu");// pour {
éliminer la redondance de codes ecrireScore(sonScore+points
} );
Score(String nom) { }
this.nom=nom; }
sonScore =0;
scoreMax =100;
}
public int lireScore () {
return sonScore;
}

Classe ScoreEssai et Jeu
class ScoreEssai extends Score { class Jeu {

int nbEssais; public static void main(String
ScoreEssai () { args []) {
super (); Double d;
nbEssais =0; int tirage;
} ScoreEssai ahmed = new
ScoreEssai(String nom) { ScoreEssai("Ahmed");
super(nom);
nbEssais =0; while (ahmed.lireScore ()
} <21) {
public void ecrireScore(int sco d = new Double (6* Math.
) { random ()+1);
super.ecrireScore(sco); tirage = d.intValue ();
nbEssais ++; ahmed.ajoute(tirage);
} ahmed.affiche ();
int lireNbEssais () { }
return nbEssais; System.out.println("Ahmed a
} gagné en "+ ahmed.lireNbEssais
} ()+" coups.");
}
}

Le polymorphisme
Le polymorphisme

Le polymorphisme
Le polymorphisme
Définition
Le polymorphisme signifie que le même message adressé à deux objets
différents peut produire des résultats différents.
Par exemple, dire ”Bonne nuit” à un enfant signifie ”Commence à te préparer
pour le lit.”
Dire ”Bonne nuit” à un parent signifie ”Lis une histoire avant de dormir.”
En Java, cela signifie que la même méthode est implémentée différemment
par différentes classes.
En substance : Le polymorphisme consiste à changer le comportement d’une
classe grâce à l’héritage, en adaptant le comportement des objets, tout en
continuant à l’utiliser comme une classe de base.

Le polymorphisme
Le polymorphisme
public class Pixel{
//...
public Pixel (){ ... }
// ...
}
public class PixelCouleur extends Pixel{

//...
private int couleur ;
public PixelCouleur () {...}
//...
}
Pixel p = new Pixel () ;

p.affiche () ; // appel de affiche () de Pixel
PixelCouleur pc = new PixelCouleur () ;
p = pc ;
p.affiche (); // appel de affiche () de PixelCouleur

Le polymorphisme
Exemple : Orchestre et Polymorphisme

Considérons un exemple d’orchestre avec différents instruments.
Classe de base : Instrument
public class Instrument {
public void jouer () {
System.out.println("Jouer Instrument");} }
Classes dérivées : Piano, Trompette, Violon

public class Piano extends Instrument {
@Override
System.out.println("Jouer Piano");} }
public class Trompette extends Instrument {
@Override
System.out.println("Jouer Trompette");} }
public class Violon extends Instrument {
@Override
System.out.println("Jouer Violon");} }

Le polymorphisme
Exemple : Orchestre et Polymorphisme (Suite)
Utilisons ces classes dans un tableau polymorphique.

Instrument [] orchestre = new Instrument [3];
orchestre [0] = new Piano ();
orchestre [1] = new Trompette ();
orchestre [2] = new Violon ();
for (Instrument instrument : orchestre) {

instrument.jouer ();
}
Résultat attendu :
Jouer Piano
Jouer Trompette
Jouer Violon

Le polymorphisme
Polymorphisme en Java
Le polymorphisme est la capacité d’un objet de changer dynamiquement son

type.
// Polymorphisme
A a = new B(); // a peut référencer un objet de type B
Un objet de la classe dérivée (B) peut être référencé par un objet de la classe
de base (A).
Le type de référence (a) est devenu dynamiquement le type de l’objet
référencé (B).

Le polymorphisme
Polymorphisme - Appel de Méthodes
Il est possible d’appeler des méthodes définies dans B sur a

Si la méthode est définie dans la classe mère (A), elle est appelée.
Si la méthode est redéfinie dans la classe fille (B), celle de la classe fille est
appelée.
Si la méthode n’est définie que dans la classe fille (B), une erreur de compilation
survient.
A a = new B();
a.maMethode (); // Appel de la méthode de la classe mère ou erreur si
non définie dans A
Pour appeler une méthode spécifique de la classe fille (B), il faut effectuer un
downcast :
((B)a).maMethode (); // Downcast pour appeler la méthode de B

Le polymorphisme
Polymorphisme - Exemple
Pixel p = new Pixel ();

PixelCouleur pc = new PixelCouleur ();
p.changePosition (2,5); // Appel de la méthode de Pixel

p.affiche (); // Appel de la méthode de Pixel
// Ligne suivante générera une erreur de compilation

// pc = p;
p = pc; // p référence maintenant un objet de type PixelCouleur

p.changePosition (3,6); // Appel de la méthode de Pixel
// Ligne suivante générera une erreur de compilation
// p.changeCouleur (3);
(( PixelCouleur)p).changeCouleur (3); // Appel de la méthode de

PixelCouleur
p.affiche (); // Appel de la méthode redéfinie de PixelCouleur

Le polymorphisme
Compatibilité entre objets dérivés et objets de la classe de

base
PixelCouleur pc = new PixelCouleur ();

Pixel p = pc; // Conversion type dérivé vers type de base (upcast)
// pc = p; // Erreur de compilation , impossible de convertir
directement de la classe de base vers la classe dérivée
pc = (PixelCouleur) p; // Conversion avec transtypage (downcast)

Le polymorphisme Upcast et Downcast
Upcasting en Java
Upcasting : Conversion d’une référence d’une classe dérivée vers une référence de
la classe de base.
// Upcasting
Instrument piano = new Piano ();
Utilisation d’un objet de la classe dérivée comme s’il s’agissait de la classe de

base.
Les méthodes appelées seront celles de la classe dérivée si elles sont redéfinies.

Le polymorphisme Upcast et Downcast
Downcasting en Java
Downcasting : Conversion d’une référence de la classe de base vers une référence

de la classe dérivée.
// Downcasting
Piano piano = (Piano) instrument;
Nécessite une explicitation avec l’opérateur de cast.

Risque de ClassCastException si l’objet n’est pas du type attendu.

Les classes abstraites

Les classes abstraites sont des classes qui ne peuvent pas être
instanciées. Elles déclarent souvent des signatures de méthodes (méthodes
sans corps), appelées méthodes abstraites.
Les classes héritantes définiront concrètement les méthodes abstraites
public abstract class Forme {
abstract void dessiner (); // Méthode abstraite sans corps
}
public class Cercle extends Forme {

void dessiner () {
// Implémentation concrète de la méthode dessiner pour la classe
Cercle
}
}

Les classes abstraites en Java
En Java, la signature d’une méthode abstraite est préfixée par le mot-clé abstract.
De même, la signature d’une classe abstraite est préfixée par le mot-clé abstract.
Toute classe contenant une méthode abstraite est également abstraite, mais il
n’est pas nécessaire qu’une classe ait une méthode abstraite pour être déclarée
abstraite.
public abstract class Forme {
abstract void dessiner (); // Méthode abstraite sans corps
}
public class Cercle extends Forme {

void dessiner () {
// Implémentation concrète de la méthode dessiner pour la classe
Cercle
}
}

Classes abstraites en Java (suite)

Toute classe qui hérite d’une classe abstraite est également abstraite, et elle doit
être explicitement déclarée abstraite, sauf si toutes les méthodes abstraites de la
classe mère sont redéfinies dans la classe fille.
abstract class Animal {
abstract void faireDuBruit ();
}
class Chien extends Animal {

void faireDuBruit () {
System.out.println("Le chien aboie.");
}
}
public class TestAnimal {

Animal monChien = new Chien ();
monChien.faireDuBruit (); // Le chien aboie
}
}

Utilisation des classes abstraites

Les classes abstraites servent à modéliser des types d’objets qui n’ont pas une
réalité concrète. Si dans une application, on a besoin de modéliser des objets
dont les comportements sont voisins, il peut être utile de créer une super-classe
abstraite qui caractérise et factorise ce qui est commun.
abstract class Forme {
// Méthode concrète
void deplacer () {
System.out.println("La forme se déplace.");
}
abstract void dessiner ();// Méthode abstraite à définir dans les
sous -classes
}
class Cercle extends Forme {
void dessiner () {
System.out.println("Le cercle se dessine.");
}
}
class Carre extends Forme {
void dessiner () {
System.out.println("Le carré se dessine.");
}
}
exercice : Programme de Gestion de Collection
Une grand-mère a besoin d’un programme Java pour gérer sa collection

d’ustensiles de cuisine anciens, plus précisément des assiettes (rondes ou
carrées) et des cuillères. Vous trouverez ci-dessous une version incomplète de
son programme Collection. Les 5 objets créés sont stockés dans le tableau us
qui est de type Ustensile[].
Il vous est demandé de compléter le programme selon les indications dans les
quatre questions ci-après. Pensez à profiter au maximum des possibilités
offertes par Java pour éviter la duplication inutile d’instructions dans les
classes et les méthodes.

Programme de Gestion de Collection - Exercice
class Collection { s t a t i c v o i d a f f i c h e r S u r f a c e A s s i e t t e s ( U s t e n s i l e [ ] us ) {
do ub le somme = 0 ;
public static v o i d main ( S t r i n g [ ] a r g s ) { f o r ( i n t i = 0 ; i < us . l e n g t h ; i ++) {
Ustensile [ ] us = new U s t e n s i l e [ 5 ] ; // A c o m p l é t e r
us [ 0 ] = new A s s i e t t e R o n d e (1926 , 8 . 4 ) ; }
us [ 1 ] = new C u i l l e r e (1881 , 7 . 3 ) ; System . out . p r i n t l n ( ” S u r f a c e t o t a l e des a s s i e t t e s : ”
us [ 2 ] = new A s s i e t t e C a r r e e (1935 , 5 . 6 ) ; + somme) ;
us [ 3 ] = new C u i l l e r e (1917 , 8 . 8 ) ; }
us [ 4 ] = new A s s i e t t e R o n d e (1837 , 5 . 4 ) ;
s t a t i c v o i d a f f i c h e r V a l e u r T o t a l e ( U s t e n s i l e [ ] us ) {
a f f i c h e r C u i l l e r e s ( us ) ; do ub le somme = 0 ;
a f f i c h e r S u r f a c e A s s i e t t e s ( us ) ; f o r ( i n t i = 0 ; i < us . l e n g t h ; i ++) {
a f f i c h e r V a l e u r T o t a l e ( us ) ; // A c o m p l é t e r
} }
System . out . p r i n t l n ( ” V a l e u r t o t a l e de l a c o l l e c t i o n :
s t a t i c v o i d a f f i c h e r C u i l l e r e s ( U s t e n s i l e [ ] us ) { ” + somme) ;
int nbCuilleres = 0 ; }
f o r ( i n t i = 0 ; i < us . l e n g t h ; i ++) { }
// A c o m p l é t e r
}
System . out . p r i n t l n ( ” I l y a ” + n b C u i l l e r e s + ”
c u i l l è r e s . ”) ;
}

exercice : Programme de Gestion de Collection
Hiérarchie de classes
Il convient de modéliser les objets de la collection avec une hiérarchie de 5 classes
comme indiqué dans la liste ci-dessous. Ecrivez le code de cette hiérarchie de
classes, y compris les variables d’instance et les constructeurs.
Evitez de dupliquer inutilement des instructions. La méthode main du programme
Collection ci-dessus vous montre la façon d’appeler les constructeurs des classes
qui sont instanciables.
1 Chaque Ustensile a une année de fabrication qui est une valeur int. Un
Ustensile est soit une Assiette, soit une Cuillère. Il n’est pas possible
d’instance la classe Ustensile.
2 Une Assiette est soit une AssietteRonde, soit une AssietteCarree. Il n’est pas
possible d’instancier la classe Assiette.
3 Chaque AssietteRonde à un rayon qui est une valeur double.
4 Chaque AssietteCarree à un cote qui est une valeur double.
5 Chaque Cuillere à une longueur qui est une valeur double.

Diagramme de Classe
Ustensile
- annee : int
Assiette Cuillere
- longueur : double
+ calculerSurface() : double + toString() : String
AssietteRonde AssietteCarree
- rayon : double - cote : double
+ calculerSurface() : double + calculerSurface() : double

Gestion de Collection d’Ustensiles
class Collection { s t a t i c void a f f i c h e r S u r f a c e A s s i e t t e s (

p r i v a t e f i n a l s t a t i c i n t CURRENT_YEAR = 2024 ; U s t e n s i l e [ ] us ) {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { f o r ( i n t i = 0 ; i < us . l e n g t h ; i ++) {
U s t e n s i l e [ ] us = new U s t e n s i l e [ 5 ] ; i f ( us [ i ] i n s t a n c e o f A s s i e t t e ) {
us [ 0 ] = new A s s i e t t e R o n d e (1926 , 8 . 4 ) ; somme = somme + ( ( A s s i e t t e ) us [ i
us [ 1 ] = new C u i l l e r e (1881 , 7 . 3 ) ; ]) . calculerSurface () ;
us [ 2 ] = new A s s i e t t e C a r r e e (1935 , 5 . 6 ) ; }
us [ 3 ] = new C u i l l e r e (1917 , 8 . 8 ) ; }
us [ 4 ] = new A s s i e t t e R o n d e (1837 , 5 . 4 ) ; System . out . p r i n t l n ( ” S u r f a c e t o t a l e des
a s s i e t t e s : ” + somme) ;
a f f i c h e r C u i l l e r e s ( us ) ; }
a f f i c h e r S u r f a c e A s s i e t t e s ( us ) ;
a f f i c h e r V a l e u r T o t a l e ( us ) ; s t a t i c void afficherValeurTotale ( Ustensile [ ]
} us ) {
s t a t i c v o i d a f f i c h e r C u i l l e r e s ( U s t e n s i l e [ ] us ) f o r ( i n t i = 0 ; i < us . l e n g t h ; i ++) {
{ somme = somme + us [ i ] . c a l c u l e r V a l e u r (
int nbCuilleres = 0 ; CURRENT_YEAR) ;
f o r ( i n t i = 0 ; i < us . l e n g t h ; i ++) { }
i f ( us [ i ] i n s t a n c e o f C u i l l e r e ) { System . out . p r i n t l n ( ” V a l e u r t o t a l e de l a
n b C u i l l e r e s++; c o l l e c t i o n : ” + somme) ;
} }
} }
System . out . p r i n t l n ( ” I l y a ” + n b C u i l l e r e s
+ ” c u i l l è r e s . ”) ;
}

Classes Ustensile, Assiette et Cuillere
abstract class Ustensile { c l a s s AssietteRonde extends A s s i e t t e {

p r i v a t e i n t annee ; p r i v a t e do ub le rayon ;
p u b l i c U s t e n s i l e ( i n t annee ) { p u b l i c A s s i e t t e R o n d e ( i n t annee , do ub le rayon )

t h i s . annee = annee ; {
} s u p e r ( annee ) ;
t h i s . rayon = rayon ;
p u b l i c do ub le c a l c u l e r V a l e u r ( i n t }
anneeActuelle ) {
i n t age = ( a n n e e A c t u e l l e − getAnnee ( ) ) ; p u b l i c do ub le c a l c u l e r S u r f a c e ( ) {
do uble v a l e u r = 0 ; r e t u r n ( 3 . 1 4 ∗ getRayon ( ) ∗ getRayon ( ) ) ;
i f ( age > 50) { }
v a l e u r = age − 50 ;
} p u b l i c do ub le getRayon ( ) {
return valeur ; r e t u r n rayon ;
} }
}
p u b l i c i n t getAnnee ( ) {
r e t u r n annee ; c l a s s AssietteCarree extends A s s i e t t e {
} p r i v a t e do ub le c o t e ;
}
p u b l i c A s s i e t t e C a r r e e ( i n t annee , do ub le c o t e )
abstract c l a s s A s s i e t t e extends U s t e n s i l e { {
p u b l i c A s s i e t t e ( i n t annee ) { s u p e r ( annee ) ;
s u p e r ( annee ) ; t h i s . cote = cote ;
} }
p u b l i c a b s t r a c t do uble c a l c u l e r S u r f a c e ( ) ;

Classes Ustensile, Assiette et Cuillere (suite)
p u b l i c do ub le c a l c u l e r S u r f a c e ( ) {
r e t u r n ( getCote ( ) ∗ getCote ( ) ) ;
}
p u b l i c do ub le c a l c u l e r V a l e u r ( i n t a n n e e A c t u e l l e ) {
do ub le v a l e u r = 5 ∗ s u p e r . c a l c u l e r V a l e u r (
anneeActuelle ) ;
return valeur ;
}
p u b l i c do ub le getCote ( ) {
return cote ;
}
}
c l a s s C u i l l e r e extends U s t e n s i l e {
p r i v a t e do ub le l o n g u e u r ;
p u b l i c C u i l l e r e ( i n t annee , do ub le l o n g u e u r ) {
s u p e r ( annee ) ;
t h i s . longueur = longueur ;
}
p u b l i c do ub le getLongueur ( ) {
return longueur ;
}
}

Les Interfaces
Les Interfaces

Les Interfaces
Interfaces en Java
Les interfaces sont des classes abstraites particulières :

Tous les attributs sont implicitement ‘static‘ et ‘final‘.
Toutes les méthodes sont implicitement abstraites.
On les déclare comme des classes, mais en remplaçant le mot-clé ‘class‘ par
‘interface‘.
interface I {
int constante = 10;
void f(int x);
}

Les Interfaces
Interfaces et Classes Abstraites en Java
Écrire une interface équivaut presque à écrire une classe abstraite ne déclarant que
des méthodes abstraites, sauf qu’une classe peut hériter de plusieurs interfaces.
interface I {
void f();
int g(float x);
}
Équivalent en utilisant une classe abstraite :

abstract class I {
abstract void f();
abstract int g(float x);
}

Les Interfaces
Interface et Héritage en Java

Contrairement à une classe standard, une interface peut hériter de plusieurs
interfaces. On utilise le mot-clé extends en indiquant la suite des interfaces
séparées par des virgules. Une classe peut également hériter de plusieurs
interfaces, en utilisant le mot-clé implements. Enfin, une classe peut hériter
d’une autre classe et de plusieurs interfaces.
interface I1 {
v o i d method1 ( ) ;
}
interface I2 {
}
i n t e r f a c e I 3 e x t e n d s I1 , I 2 {
}
c l a s s MyClass implements I 3 {
p u b l i c v o i d method1 ( ) {
// I m p le m e nt a t i o n
}
}
}
}

Les Interfaces
Interface et Utilisation en Java
Une interface sert de relais entre une classe qui implémente et une classe qui
l’utilise. Une interface indique les méthodes qu’une classe met à la disposition des
autres classes sans indiquer son implémentation ni sa structure interne. Lorsqu’une
application nécessite de définir de nombreuses classes qui vont interagir et qui
seront écrites par des programmeurs différents, chaque programmeur n’a besoin de
connaître que les interfaces des autres classes.
interface Calcul {
int addition ( in t a , in t b) ;
int soustraction ( int a , int b) ;
}
c l a s s C a l c u l a t r i c e implements C a l c u l {
public int addition ( int a , int b) {
return a + b ;
}
public in t soustraction ( in t a , in t b) {
return a − b ;
}
}

Les Interfaces
Utilisation des Interfaces en Java

// I n t e r f a c e IA
p u b l i c i n t e r f a c e IA {
v o i d fA ( ) ;
}
// C l a s s e A implémentant l ’ i n t e r f a c e IA
p u b l i c c l a s s A implements IA {
v o i d fA ( ) {
// Im p lé m e nt a t i o n de fA
// . . .
}
}
// C l a s s e B u t i l i s a n t l ’ i n t e r f a c e IA
public class B {
p r i v a t e IA i a ;
// C o n s t r u c t e u r p r e n a n t un o b j e t IA ( polymorphisme )
p u b l i c B( IA i a ) {
this . ia = ia ;
}
// Méthode de B u t i l i s a n t l a méthode fA de l ’ i n t e r f a c e ( polymorphisme )
p u b l i c v o i d fB ( ) {
i a . fA ( ) ;
}
}
IA définit une interface avec la méthode fA.

A implémente cette interface en fournissant une implémentation de fA.
B utilise l’interface IA dans son implémentation, ce qui permet de manipuler
différents objets conformes à IA.
Les Interfaces
public interface StorageService { p u b l i c c l a s s D a t a Pr o c e s s o r {

v o i d s t o r e D a t a ( S t r i n g data ) ; private StorageService storageService ;
String retrieveData () ; p u b l i c DataProcessor ( StorageService
} storageService ) {
this . storageService = storageService ;
}
p u b l i c v o i d p r o c e s s D a t a ( S t r i n g data ) {
p u b l i c c l a s s L o c a l S t o r a g e implements s t o r a g e S e r v i c e . s t o r e D a t a ( data ) ;
StorageService { String retrievedData = storageService .
p r i v a t e St r i n g storedData ; retrieveData () ;
p u b l i c v o i d s t o r e D a t a ( S t r i n g data ) { // A u t r e s o p é r a t i o n s . . .
t h i s . s t o r e d D a t a = data ; }
} }
public String retrieveData () {
return storedData ;
}
}
L’interface ‘StorageService‘ définit un contrat pour le stockage.

‘LocalStorage‘ implémente cet interface, offrant une implémentation locale.
‘DataProcessor‘ utilise le service de stockage, ce qui permet de changer
facilement d’implémentation en fournissant un autre objet qui implémente
‘StorageService‘.

Les Interfaces
Les interfaces en Java offrent un moyen puissant de définir un contrat commun

que plusieurs classes peuvent implémenter. Voici quelques raisons pour lesquelles
l’utilisation d’interfaces est bénéfique, illustrées par un exemple :
1 Abstraction et Encapsulation : Les interfaces permettent de définir des
méthodes sans spécifier leur implémentation, fournissant une abstraction des
détails internes. Cela encourage l’encapsulation en masquant les détails
d’implémentation.
2 Flexibilité : Les interfaces favorisent le polymorphisme. Une classe peut
implémenter plusieurs interfaces, permettant une grande flexibilité dans la
conception.
3 Modularité : Les interfaces facilitent la séparation des préoccupations en
permettant la définition de contrats clairs. Chaque classe peut alors se
concentrer sur une fonctionnalité spécifique.

Les Interfaces
4 Réutilisation du Code : Les interfaces permettent de définir des

fonctionnalités communes réutilisables par différentes classes, favorisant ainsi
la réutilisation du code.
5 Intégration Facile : L’utilisation d’interfaces permet l’intégration facile de
nouvelles fonctionnalités dans un système existant, car il suffit d’implémenter
les interfaces nécessaires.
6 Exemple : Une interface ‘Imprimable‘ pourrait définir une méthode
‘imprimer()‘. Différentes classes comme ‘Document‘, ‘Image‘ peuvent
implémenter cette interface, permettant à un gestionnaire d’impression d’agir
sur n’importe quel objet ‘Imprimable‘.

Les Interfaces
Exemple d’Interface en Java
// I n t e r f a c e // Deuxième c l a s s e
public i n t e r f a c e Vehicule { p u b l i c c l a s s Moto implements V e h i c u l e {
v o i d demarrer ( ) ; @Override
void a r r e t e r () ; p u b l i c v o i d demarrer ( ) {
} System . out . p r i n t l n ( ”La moto démarre . ” ) ;
}
// Première c l a s s e
p u b l i c c l a s s V o i t u r e implements V e h i c u l e { @Override
@Override public void a r r e t e r () {
p u b l i c v o i d demarrer ( ) { System . out . p r i n t l n ( ”La moto s ’ a r r ê t e . ” ) ;
System . out . p r i n t l n ( ”La v o i t u r e démarre . ” ) }
; }
}
// U t i l i s a t i o n
@Override public c l a s s TestVehicules {
public void a r r e t e r () { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . out . p r i n t l n ( ”La v o i t u r e s ’ a r r ê t e . ” V e h i c u l e v o i t u r e = new V o i t u r e ( ) ;
); V e h i c u l e moto = new Moto ( ) ;
}
} // Appels des méthodes
v o i t u r e . demarrer ( ) ;
voiture . arreter () ;
moto . demarrer ( ) ;
moto . a r r e t e r ( ) ;
}
}

Les exceptions
Les exceptions

Les exceptions
Qu’est-ce qu’une exception en Java ?
Définition
Une exception est un événement qui se produit lors de l’exécution d’un
programme, interrompant le flux normal des instructions.
L’objet Exception :
Lorsqu’une erreur survient, une méthode crée un objet Exception.
Contient des informations sur l’erreur, telles que le type de l’erreur (objet
null, dépassement de tableau, etc.).
La trace d’exécution du programme est également incluse (la stack trace).
L’action de créer un objet Exception et de le passer au système d’exécution est
appelée lever/lancer une exception (throwing an exception).

Les exceptions
Introduction aux Exceptions
En Java, une exception est un événement se produisant pendant l’exécution

d’un programme, interrompant le flux normal des instructions.
Les exceptions fournissent un mécanisme pour gérer les erreurs et les
situations exceptionnelles de manière propre.
Lorsqu’une erreur survient, un objet de type Exception est créé, contenant
des informations sur l’erreur, telles que le type de l’erreur et la trace
d’exécution.
Lever une exception signifie signaler une erreur et transférer le contrôle à un
gestionnaire approprié.

Les exceptions
Mécanisme des Exceptions en Java
Les exceptions sont gérées par le mécanisme de gestion des erreurs intégré
dans Java.
Lorsqu’une exception survient, le programme cherche le gestionnaire
d’exceptions approprié.
La trace d’exécution (stack trace) fournit des informations sur la séquence
d’appels de méthodes menant à l’exception.
Les exceptions peuvent être levées explicitement (throw) ou détectées
implicitement lors de l’exécution.

Les exceptions
Gestion des Exceptions : try-catch
Le bloc try est utilisé pour encadrer le code susceptible de lever une
exception.
Le bloc catch spécifie le type d’exception à intercepter et le code à exécuter
en cas d’exception.
On peut avoir plusieurs blocs catch pour traiter différents types d’exceptions.
Utiliser finally pour spécifier du code qui doit être exécuté, que l’exception
soit levée ou non.

Les exceptions
Exemple de Code : throws
// Méthode qui peut lancer une exception mais ne la gère pas

localement
public void lancerException () throws CustomException {
// Code susceptible de lever l'exception
if (condition) {
throw new CustomException("Message d'erreur");
}
}
// Appel de la méthode
try {
lancerException ();
} catch (CustomException e) {
// Gestion de l'exception
System.out.println("Erreur personnalisée: " + e.getMessage ());
}

Les exceptions
Gestion des Exceptions : throws
Le mot-clé throws est utilisé pour indiquer que la méthode peut lancer
certaines exceptions, mais qu’elles ne sont pas traitées à cet endroit.
Les exceptions doivent être gérées par le code appelant la méthode ou par
des blocs try-catch ultérieurs.
Utile pour les méthodes qui ne peuvent pas gérer l’exception localement, mais
doivent informer les appelants potentiels de la possibilité d’une exception.

Les exceptions
Exemple de Code : try-catch
try {
// Code susceptible de lever une exception
int resultat = diviser (10, 0);
System.out.println("Résultat: " + resultat);
} catch ( ArithmeticException e) {
System.out.println("Erreur: Division par zéro");
} finally {
// Code exécuté quels que soient les résultats
System.out.println("Fin du programme");
}

Les exceptions
Gestion des Exceptions : finally
Le bloc finally contient du code qui sera exécuté quels que soient les
résultats des blocs try et catch.
Utile pour libérer des ressources (comme la fermeture de fichiers ou de
connexions) ou exécuter un code de nettoyage.
Le bloc finally est facultatif.

Les exceptions
Types d’Exceptions en Java
Java offre une variété d’exceptions prédéfinies pour gérer différents types
d’erreurs.
Exemples : NullPointerException, ArrayIndexOutOfBoundsException,
ArithmeticException, etc.
Vous pouvez définir vos propres exceptions personnalisées en étendant la
classe Exception.

Les exceptions
Exemple de Code : Types d’Exceptions
try {
// Code susceptible de lever une exception
String chaine = null;
int longueur = chaine.length (); // NullPointerException
} catch ( NullPointerException e) {
System.out.println("Erreur: " + e.getMessage ());
}

Les exceptions
Meilleures Pratiques pour la Gestion des Exceptions
Toujours capturer les exceptions appropriées et traiter en conséquence.

Ne pas attraper des exceptions génériques sauf si nécessaire.
Éviter d’utiliser des exceptions pour le contrôle du flux normal.
Fermer correctement les ressources dans le bloc finally.
Logguer les exceptions pour un débogage efficace.
Documenter les exceptions pouvant être levées par les méthodes.

Conclusion

Conclusion
Conclusion

Conclusion
Conclusion

Acknowledgement
Thank you !

Poo2 1

Transféré par

Droits d'auteur :

Formats disponibles

Poo2 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poo2 1

Transféré par

Droits d'auteur :

Formats disponibles

POO

Initiation à la programmation orientée objet

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 1 / 159

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 2 / 159

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 3 / 159

Problématique du développement logiciel

L’élaboration d’un logiciel devient complexe lorsqu’elle nécessite la mobilisation de

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 4 / 159

Problématique du développement logiciel

1. Un processus clairement défini : le cycle de vie d’un logiciel

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 5 / 159

Cycle de vie d’un logiciel

1 L’expression des besoins

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 6 / 159

Cycle de vie d’un logiciel

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 7 / 159

L’approche orientée objet

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 8 / 159

La qualité d’un logiciel

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 9 / 159

La qualité d’un logiciel

La programmation structurée a apporté des améliorations significatives dans les

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 10 / 159

Les limites de l’approche fonctionnelle

Décomposition hiérarchique en fonctions.

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 11 / 159

On considère ce que le système doit faire, mais aussi ce qu’il est :

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 12 / 159

Programmation Procédurale VS Orientée Objet

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 13 / 159

Composants Fondamentaux d’un Objet

1 Etat : Les valeurs des attributs (données) d’un objet.

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 14 / 159

Embarquement de l’État dans un Objet

On embarque dans une entité (un objet) son état (mémoire).

Une Voiture Une Personne

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 15 / 159

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 16 / 159

Pour réduire la complexité d’un système complexe, on regroupe des objets

En d’autres termes, une classe = type.

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 17 / 159

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 18 / 159

Identification des Objets en POO

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 19 / 159

Ajout d’Attributs et de Méthodes en POO

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 20 / 159

POO & Java

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 21 / 159

Caractéristiques Essentielles de Java

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 22 / 159

La Machine Virtuelle Java (JVM)

La JVM (Java Virtual Machine) est au cœur de l’exécution des programmes

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 23 / 159

La Machine Virtuelle Java (JVM)

Figure – Diagramme de la Machine Virtuelle Java (JVM)

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 24 / 159

Premier Programme Java : HelloWorld.java

A. GUEDDES (abdelwaheb.gueddes@isitc.u-sousse.tn) POO 23/24 25 / 159

Types de Base en Java