Programmation Orientée Objet avec

Java

Tapamo Kenfack
 Tapamo Kenfack POO avec Java

Table des matières

Chapitre 1 Introduction à la Programmation Orientée Objet Page 4

1.1 Présentation du cours et des objectifs 4
Introduction de l’enseignant et des étudiants — 4 • Aperçu des objectifs du cours — 4 • Méthodologie
et évaluations — 4
1.2 Concepts de base de la POO : objets, classes, attributs, méthodes 5
Définition de la POO — 5 • Comparaison entre la POO et la programmation procédurale — 6 • Exemples
d’objets du monde réel et leur modélisation en classes — 6
1.3 Installation et configuration de l’environnement de développement Java (JDK, IDE) 8
Téléchargement et installation du JDK — 8 • Choix et installation d’un IDE (Eclipse, IntelliJ IDEA,
NetBeans) — 8 • Configuration de l’environnement de développement — 8

Chapitre 2 Premiers Pas avec Java Page 9

2.1 Syntaxe de base de Java 9
Structure d’un programme Java — 9 • Méthode main() : point d’entrée d’un programme Java — 9 •
Instructions de base : déclarations, affectations, instructions de contrôle (if, switch) — 10
2.2 Structure d’un programme Java 12
Types de données de base (int, float, double, char, boolean) — 12 • Variables et constantes — 13 • Saisie
au clavier — 13
2.3 Compilation et exécution d’un programme Java simple 14
Utilisation du compilateur javac — 14 • Exécution de programmes avec java — 14 • Exercices pratiques :
écrire, compiler et exécuter un programme simple — 14

Chapitre 3 Classes et Objets Page 15

3.1 Définition et instanciation de classes et d’objets 15
Définition d’une classe et création d’objets — 15 • Mots-clé new — 16
3.2 Constructeurs 16
Définition et utilisation de constructeurs — 16 • Surcharge de constructeurs — 17
3.3 Mots-clés this et static 17

Chapitre 4 Encapsulation Page 19

4.1 Modificateurs d’accès (private, public, protected) 19
Rôle des modificateurs d’accès — 19 • Exemples et bonnes pratiques — 19
4.2 Accesseurs et mutateurs (getters et setters) 20
Définition et utilisation de getters et setters — 20 • Bonnes pratiques — 21
4.3 Bonnes pratiques d’encapsulation 21
Principes de conception — 21 • Cas pratiques et exercices — 21

UCB 2024 1
 Tapamo Kenfack POO avec Java

Chapitre 5 Héritage Page 22

5.1 Concepts d’héritage 22
Introduction à l’héritage — 22 • Le mécanisme d’héritage — 22 • Avantages de l’héritage en POO —
24 • Héritage et constructeurs — 24 • Rédéfinition des méthodes — 24 • Le transtypage — 24 • Le
polymorphisme — 25
5.2 Exemple 25
Description — 25 • Création de la classe fille — 26 • Création de la classe parent — 26 • Construction
d’un objet enseignant — 27 • Surcharge d’une méthode — 27

Chapitre 6 Polymorphisme Page 29

6.1 Polymorphisme à travers l’héritage 29
Définition du polymorphisme — 29 • Utilisation du polymorphisme dans des classes dérivées — 29
6.2 Redéfinition des méthodes (override) 29
Surcharge et redéfinition de méthodes — 29 • Utilisation de l’annotation @Override — 29
6.3 Utilisation des classes abstraites et des interfaces 29
Introduction aux classes abstraites et interfaces — 29 • Différences entre les deux — 29

Chapitre 7 Interfaces et Classes Abstraites Page 30

7.1 Différences entre interfaces et classes abstraites 30
7.2 Implémentation d’interfaces 30
7.3 Création et utilisation de classes abstraites 30

Chapitre 8 Gestion des Exceptions Page 31

8.1 Concepts de base des exceptions 31
8.2 Try, catch, finally 31
La classe Throwable — 33 • Utilisation de finally — 33
8.3 Création de vos propres exceptions 33
Définition de classes d’exception personnalisées — 33 • Utilisation des exceptions personnalisées dans
les programmes — 33

Chapitre 9 Collections et Génériques Page 34

9.1 Introduction aux collections (List, Set, Map) 34
Présentation des principales interfaces de la collection framework — 34 • Exemples d’utilisation — 34
9.2 Utilisation des collections Java 34
Manipulation des listes, ensembles et maps — 34 • Méthodes courantes des collections — 34
9.3 Concepts de base des génériques 34
Introduction aux génériques — 34 • Utilisation des génériques dans les collections — 34

Chapitre 10 Fichiers et Flux Page 35

10.1 Lecture et écriture de fichiers 35
Classes File, FileReader, FileWriter — 35 • Exemples pratiques de lecture et d’écriture — 35
10.2 Utilisation des classes de flux (InputStream, OutputStream) 35
Introduction aux flux d’entrée et de sortie — 35 • Exemples d’utilisation des flux — 35
10.3 Sérialisation des objets 35
Concepts de base de la sérialisation — 35 • Sérialisation et désérialisation d’objets — 35

UCB 2024 2
 Tapamo Kenfack POO avec Java

Chapitre 11 Bibliothèques et API Java Page 36

11.1 Introduction aux bibliothèques standard Java ([Link], [Link]) 36
Aperçu des bibliothèques standard — 36 • Utilisation des classes utilitaires — 36
11.2 Utilisation des classes et méthodes utiles 36
Méthodes communes des classes utilitaires — 36 • Exemples pratiques — 36
11.3 Introduction aux API externes 36
Aperçu des API populaires — 36 • Comment intégrer et utiliser des API externes — 36

Chapitre 12 Concurrence et Multithreading Page 37

12.1 Concepts de base du multithreading 37
Introduction au multithreading — 37 • Avantages et inconvénients — 37
12.2 Création et gestion de threads 37
Création de threads avec Runnable et Thread — 37 • Gestion des threads et synchronisation — 37
12.3 Synchronisation et gestion des ressources partagées 37
Problèmes de concurrence — 37 • Utilisation des mots-clés synchronized, wait, notify — 37

Chapitre 13 Conception Orientée Objet Page 38

13.1 Principes SOLID 38
Introduction aux principes SOLID — 38 • Importance des principes SOLID dans la conception orientée
objet — 38
13.2 Design patterns classiques (Singleton, Factory, Observer) 38
Présentation des design patterns — 38 • Exemples de mise en œuvre — 38
13.3 Bonnes pratiques de conception 38
Principes de conception robuste — 38 • Études de cas — 38

Chapitre 14 Projets Pratiques Page 39

14.1 Introduction aux projets pratiques 39
Présentation des projets — 39 • Formation de groupes de travail — 39
14.2 Développement d’un projet en petits groupes 39
Travaux pratiques en groupe — 39 • Suivi et assistance par l’enseignant — 39
14.3 Revue de code et feedback 39
Présentation des projets — 39 • Feedback et amélioration — 39

Chapitre 15 Révision et Évaluation Page 40

15.1 Révision des concepts clés 40
Récapitulatif des concepts appris — 40 • Questions-réponses — 40
15.2 Session de questions-réponses 40
Clarification des doutes — 40 • Préparation pour l’évaluation finale — 40
15.3 Évaluation finale (examen pratique et théorique) 40
Examen pratique : implémentation d’un projet ou d’un problème donné — 40 • Examen théorique :
questionnaire sur les concepts étudiés — 40
15.4 Random Examples 40
15.5 Random 43
15.6 Algorithms 44

UCB 2024 3
Tapamo Kenfack POO avec Java

Chapitre 1

Introduction à la Programmation
Orientée Objet

1.1 Présentation du cours et des objectifs

1.1.1 Introduction de l’enseignant et des étudiants
Je suis Tapamo Kenfack, Enseignant-Cherheur en Informatique dans la spécialité Vision Par
Ordinateurs et Traitements d’images. Je travaille plus particulièrement sur images satellites pour
l’étude l’environnement et aussi sur les images médicales pour l’aide aux dignostics. Du point de vue
enseignements, j’enseigne les sciences des données (Bases de données, Entrépots de données, Big
Data) et aussi la programmtion.

1.1.2 Aperçu des objectifs du cours

Les objects de ce cours sont
– Comprendre les concepts fondamentaux de la POO, y compris les classes, objets, héritage, poly-
morphisme, encapsulation et abstraction.
– Apprendre la syntaxe et les structures de base du langage Java.
– Être capable de concevoir, coder, compiler et exécuter des programmes Java.
–

1.1.3 Méthodologie et évaluations

Le cours se déroulera selon les articulations suivantes
– Cours magistraux pour l’introduction des concepts.
– Travaux pratiques et exercices en classe.
– Développement de projets en petits groupes.
– Évaluations régulières pour mesurer la compréhension et les progrès des étudiants.
Quant à l’évaluation, elle sera structurée comme suit
– Exercices et Travaux Pratiques : 40%
– Projets de Groupe : 30%
– Examen Final Théorique : 20%
– Participation et Engagement : 10%

UCB 2024 4
Tapamo Kenfack POO avec Java

1.2 Concepts de base de la POO : objets, classes, attributs, mé-

thodes
1.2.1 Définition de la POO
La programmation orientée objet : une approche pour modéliser le monde réel

Définition 1.2.1: La programmation orientée objet (POO)

C’est un paradigme de programmation qui vise à organiser le code de manière à mieux refléter le
monde réel. Au lieu de penser en termes de fonctions et de procédures, la POO se concentre sur
la création d’objets. Ces objets sont des entités qui possèdent à la fois des données (attributs)
et des comportements (méthodes).

Les concepts clés de la POO

– Objet: Une instance d’une classe. Il représente une entité concrète (par exemple, une voiture, un
utilisateur) avec ses propres propriétés et actions.
– Classe: Un modèle ou un plan qui définit les caractéristiques (attributs) et les comportements
(méthodes) d’un ensemble d’objets.
– Attribut: Une propriété d’un objet. Par exemple, pour une voiture, les attributs pourraient être
la couleur, la marque, le modèle.
– Méthode: Une fonction associée à une classe qui définit le comportement d’un objet. Par exemple,
pour une voiture, les méthodes pourraient être démarrer(), accélérer(), freiner().
– Encapsulation: Le principe de cacher les détails internes d’un objet et d’exposer uniquement les
interfaces nécessaires pour interagir avec lui. Cela améliore la maintenabilité et la sécurité du
code.
– Héritage: Le mécanisme qui permet de créer de nouvelles classes (classes filles) en héritant des
propriétés et des méthodes d’une classe existante (classe mère). Cela favorise la réutilisation de
code et la hiérarchisation des concepts.
– Polymorphisme: La capacité d’une même méthode d’avoir des comportements différents selon
le contexte dans lequel elle est appelée. Cela permet de créer du code plus flexible et adaptable.
Pourquoi utiliser la POO ?
– Modélisation du monde réel: La POO permet de représenter des concepts complexes de manière
plus intuitive et naturelle.
– Réutilisabilité: Le mécanisme d’héritage favorise la réutilisation de code.
– Maintenabilité: L’encapsulation facilite la maintenance du code en isolant les changements.
– Extensibilité: La POO permet d’ajouter de nouvelles fonctionnalités de manière plus facile.
Exemple simple
public class Voiture {
String marque;
String modele;
int annee;

public void demarrer() {

[Link]("La voiture démarre.");
}

public void accelerer() {

[Link]("La voiture accélère.");
}
}

UCB 2024 5
Tapamo Kenfack POO avec Java

1.2.2 Comparaison entre la POO et la programmation procédurale

– Programmation impérative : Ce mode consiste à donner une série d’instructions à l’ordinateur
pour qu’il les exécute dans un ordre spécifique. Les langages courants incluent C, Python, et
JavaScript1.
– Programmation orientée objets (POO) : Ce paradigme organise le code en objets, qui sont des
instances de classes. Chaque objet peut contenir des données et des méthodes. Les langages
populaires incluent Java, C++, et Python1.
– Programmation fonctionnelle : Ce mode se concentre sur l’utilisation de fonctions pures et évite
les états mutables et les effets de bord. Les langages courants incluent Haskell, Lisp, et Scala1.
– Programmation logique : Ce paradigme est basé sur la logique formelle et utilise des déclarations
logiques pour exprimer les relations entre les données. Prolog est un exemple de langage de
programmation logique1.

1.2.3 Exemples d’objets du monde réel et leur modélisation en classes

Une voiture

public class Voiture {

private String marque;
private String modele;
private int annee;
private String couleur;

public Voiture(String marque, String modele, int annee, String couleur) {

[Link] = marque;
[Link] = modele;
[Link] = annee;
[Link] = couleur;
}

public void demarrer() {

[Link]("La " + marque + " " + modele + " démarre.");
}

public void arreter() {

[Link]("La " + marque + " " + modele + s'arrête.");
}
}
Etudiant

public class Etudiant {

private String nom;
private String prenom;
private int age;
private String matricule;

public Etudiant(String nom, String prenom, int age, String matricule) {

[Link] = nom;
[Link] = prenom;
[Link] = age;
[Link] = matricule;
}

public void etudier() {

[Link](prenom + " " + nom + " étudie.");
UCB 2024 6
Tapamo Kenfack POO avec Java

public void passerExamen() {

[Link](prenom + " " + nom + " passe un examen.");
}
}

Livre
public class Livre {
private String titre;
private String auteur;
private int anneePublication;
private String genre;

public Livre(String titre, String auteur, int anneePublication, String genre) {

[Link] = titre;
[Link] = auteur;
[Link] = anneePublication;
[Link] = genre;
}

public void lire() {

[Link]("Vous lisez '" + titre + "' de " + auteur + ".");
}

public void referencer() {

[Link]("Référence : " + auteur + ", '" + titre + "', " + anneePublicat
}
}
Carte bancaire
public class CompteBancaire {
private String numeroCompte;
private String titulaire;
private double solde;

public CompteBancaire(String numeroCompte, String titulaire, double solde) {

[Link] = numeroCompte;
[Link] = titulaire;
[Link] = solde;
}

public void deposer(double montant) {

solde += montant;
[Link](montant + " a été déposé. Nouveau solde : " + solde + ".");
}

public void retirer(double montant) {

if (montant <= solde) {
solde -= montant;
[Link](montant + " a été retiré. Nouveau solde : " + solde + "
} else {
[Link]("Fonds insuffisants.");
}
}
}
UCB 2024 7
Tapamo Kenfack POO avec Java

1.3 Installation et configuration de l’environnement de dévelop-

pement Java (JDK, IDE)
1.3.1 Téléchargement et installation du JDK
1.3.2 Choix et installation d’un IDE (Eclipse, IntelliJ IDEA, NetBeans)
1.3.3 Configuration de l’environnement de développement

UCB 2024 8
Tapamo Kenfack POO avec Java

Chapitre 2

Premiers Pas avec Java

2.1 Syntaxe de base de Java

2.1.1 Structure d’un programme Java
La structure d’un programme Java typique comprend plusieurs éléments clés. Voici une vue
d’ensemble :
– Section de documentation : Cette section est optionnelle et contient des commentaires sur le
programme, comme le nom de l’auteur, la date de création, la version, etc. Les commentaires
peuvent être sur une seule ligne (//), sur plusieurs lignes (/* ... */), ou des commentaires de
documentation (/** ... */).
– Déclaration de package : Si le programme fait partie d’un package, cette déclaration est placée
juste après la section de documentation. Exemple :
package [Link];
– Importations : Les déclarations d’importation permettent d’inclure des classes et des interfaces
d’autres packages. Exemple :
import [Link];
– Déclaration de classe : La définition de la classe est l’élément principal d’un programme Java.
Une classe contient des variables, des méthodes, et éventuellement des constructeurs. Exemple :
– Variables de classe et locales : Les variables peuvent être déclarées au niveau de la classe (va-
riables de classe) ou à l’intérieur des méthodes (variables locales).
– Méthode principale : La méthode main est le point d’entrée d’un programme Java. C’est là que
l’exécution commence. Exemple :
public static void main(String[] args) {
// Code à exécuter
}
– Méthodes et comportements : Les méthodes définissent les comportements de la classe. Elles
peuvent être appelées pour effectuer des actions spécifiques.

2.1.2 Méthode main() : point d’entrée d’un programme Java

La méthode main en Java est essentielle car elle sert de point d’entrée pour l’exécution d’un
programme. Voici les détails clés concernant cette méthode :
Syntaxe de la méthode main
La signature de la méthode main est toujours la suivante :
public static void main(String[] args) {
// code à exécuter
}

UCB 2024 9
Tapamo Kenfack POO avec Java

Composants de la méthode main

– public : Ce modificateur d’accès permet à la Java Runtime Environment (JRE) d’accéder à la
méthode. Si main n’est pas déclaré comme public, le programme ne pourra pas être exécuté
correctement.
– static : Cela signifie que la méthode peut être appelée sans avoir besoin de créer une instance de
la classe. La Java Virtual Machine (JVM) peut appeler la méthode main directement.
– void : Cela indique que la méthode ne renvoie aucune valeur.
– String[] args : C’est un tableau de chaînes qui permet de passer des arguments à la méthode
depuis la ligne de commande. Les arguments peuvent être utilisés pour modifier le comportement
du programme à l’exécution.
Exécution d’un programme Java Lorsqu’un programme Java est lancé, la JVM recherche la méthode
main pour commencer l’exécution. Il est possible d’avoir plusieurs classes dans un programme, cha-
cune pouvant contenir sa propre méthode main, ce qui permet d’avoir plusieurs points d’entrée dans
le même programme.
Exemple de code
public class HelloWorld {
public static void main(String[] args) {
[Link]("Hello, World!");
}
}
Pour exécuter ce programme, vous devez le compiler avec javac [Link] et ensuite l’exécuter
avec java HelloWorld, ce qui affichera Hello, World! dans la console.

2.1.3 Instructions de base : déclarations, affectations, instructions de contrôle

(if, switch)
1. Déclarations de Variables
En Java, une variable doit être déclarée avant d’être utilisée. La déclaration spécifie le type de
la variable et son nom.
Syntaxe de Déclaration type nomVariable;
Examples
int age; // Déclaration d'une variable entière
double salaire; // Déclaration d'une variable de type double
String nom; // Déclaration d'une variable de type String
2. Affectations L’affectation consiste à donner une valeur à une variable. Cela se fait à l’aide
de l’opérateur =.
Exemple

age = 25; // Affectation d'une valeur à la variable age

salaire = 3500.50; // Affectation d'une valeur à la variable salaire
nom = "Alice"; // Affectation d'une valeur à la variable nom
Déclaration et Affectation en Une Seule Ligne Il est également possible de déclarer et d’affecter
une variable en une seule ligne :

int age = 25;

double salaire = 3500.50;
String nom = "Alice";
3. Instructions de Contrôle
Les instructions de contrôle permettent de diriger le flux d’exécution du programme en fonction
de certaines conditions.
3.1 Instruction if L’instruction if permet d’exécuter un bloc de code si une condition est vraie.

UCB 2024 10
Tapamo Kenfack POO avec Java

Syntaxe
if (condition) {
// bloc de code à exécuter si la condition est vraie
}
Exemple
if (age >= 18) {
[Link]("Vous êtes majeur.");
}
3.2 Instruction if-else
L’instruction if-else permet d’exécuter un bloc de code si la condition est vraie, et un autre bloc
si elle est fausse.
Syntaxe

if (age >= 18) {

[Link]("Vous êtes majeur.");
} else {
[Link]("Vous êtes mineur.");
}

3.3 Instruction switch

L’instruction switch est utilisée pour exécuter un bloc de code parmi plusieurs options, en fonc-
tion de la valeur d’une expression.
Syntaxe

switch (expression) {
case valeur1:
// bloc de code pour valeur1
break;
case valeur2:
// bloc de code pour valeur2
break;
// d'autres cas
default:
// bloc de code si aucune des valeurs ne correspond
}

Exemple
int jour = 3;

switch (jour) {
case 1:
[Link]("Lundi");
break;
case 2:
[Link]("Mardi");
break;
case 3:
[Link]("Mercredi");
break;
default:
[Link]("Jour inconnu");
}

UCB 2024 11
Tapamo Kenfack POO avec Java

2.2 Structure d’un programme Java

2.2.1 Types de données de base (int, float, double, char, boolean)
Type booleen
Une variable booléenne est déclarée avec le type boolean. Elle ne prend que 2 valeurs: false et
true.
Type entier
Le type entier permet de représenter de façon exacte une partie des nombres entiers relatifs. Par
défaut: une constante entière est de type int.
Taille Valeur Valeur
Type
(Octets) minimale maximale
-2 147 483 648 2 147 483 647
int 4
Integer.MIN_VALUE Integer.MAX_VALUE
- 9 223 372 036 854 775 808 9 223 372 036 854 775 807
long 8
Long.MIN_VALUE Long.MAX_VALUE
Type réel
Le type réel permet de représenter de façon approchée une partie des nombres réels. Ainsi, pour
tester l’égalité de 2 nombres réels, il est préférable de comparer la valeur absolue de leur différence à
un nombre très petit. Par défaut: une constante réelle est de type double.
Précision Valeur minimale Valeur maximale
Type Taille(Octets)
(chiffres significatifs) (absolue) (absolue)
1.402E-45 3.402E38
float 4 7
Float.MIN_VALUE Float.MAX_VALUE
4.94E-324 1.79E308
double 8 15
Double.MIN_VALUE Double.MAX_VALUE
Le type caractère
Le caractère en Java est représenté en mémoire sur 2 octets en utilisant le code Unicode.
Déclaration d’une variable caractère
char c
Une constante caractère est notée entre apostrophe. Exemple: ’a’
Chaines de caractères
On appelle chaîne toute suite de caractères contiguës, par exemple "bonjour" est une chaîne
de longueur 7 (longueur de la chaîne = nombre de caractères de la chaîne). Une chaîne est peut être
considérée comme une variable du langage Java et est déclarée à l’aide de l’instruction String.

String maChaine = "bonjour" ;

//déclaration d’une chaine de caractère nommée maChaine et de valeur = "bonjour"

Pour concaténer des chaines de caractères, on utilise l’opérateur + :

String auto="auto";
String bus="bus";
public class Essai{
public static void main(String[] args)
if ( [Link]==0) {
[Link]("Bonjour !!! ") ;
}
// Suite du code
}
[Link](auto+ " " +bus); // ce qui affiche "auto bus
Tableaux
Les tableaux sont utilisés pour stocker plusieurs valeurs dans une seule variable, au lieu de
déclarer des variables distinctes pour chaque valeur. Pour déclarer un tableau, définissez le type de
variable suivie de crochets :
String [] mois ; // Déclaration de tableau nommé mois de chaines de caractères
UCB 2024 12
Tapamo Kenfack POO avec Java

Nous pouvons accédez à un élément de tableau en se référant au numéro d’index, par exemple
mois[i]. i représente un index. Les index d’un tableau commencent par 0 : [0] est le premier élément.
[1] est le deuxième élément, etc.
Un tableau multidimensionnel est un tableau contenant un ou plusieurs tableaux. Pour créer un
tableau à deux dimensions, ajoutez chaque tableau dans son propre ensemble d’accolades : int [] [] tab;

2.2.2 Variables et constantes

En Java, les variables et les constantes sont des éléments fondamentaux qui permettent de
stocker et de manipuler des données. Voici une explication détaillée de chacun, ainsi que des exemples
d’utilisation.
Définition 2.2.1: Variable

Une variable est un espace de stockage nommé qui peut contenir des données pouvant changer
au cours de l’exécution d’un programme. Les variables peuvent être de différents types, tels que
int, float, char, etc.

Portée des Variables

La portée d’une variable détermine où elle peut être utilisée dans le code. Les variables peuvent
être :
– Variables locales : Déclarées à l’intérieur d’une méthode et accessibles uniquement à l’intérieur
de cette méthode.
– Variables d’instance : Déclarées à l’intérieur d’une classe mais en dehors de toute méthode,
accessibles par toutes les méthodes de la classe.
– Variables de classe (statiques) : Déclarées avec le mot-clé static, accessibles à toutes les ins-
tances de la classe.
Définition 2.2.2: Constante

Une constante est une variable dont la valeur ne peut pas changer une fois qu’elle a été initia-
lisée. En Java, les constantes sont généralement déclarées avec le mot-clé final.

Pour déclarer une constante, utilisez le mot-clé final suivi du type de données et du nom de la
constante.
final double PI = 3.14159; // Déclaration d'une constante
Il est courant de nommer les constantes en utilisant des lettres majuscules, avec des underscores
pour séparer les mots, par exemple MAX_VALUE, DEFAULT_TIMEOUT, etc.
Il est toujours préférable d’utiliser des constantes symboliques plutôt que des constantes litté-
rales.

2.2.3 Saisie au clavier

Afin de faire interagir l’utilisateur avec son clavier, et de permettre à l’apprenant de faire les essais
sur machine, nous allons expliquer comment récupérer les valeurs saisies au clavier. Le langage Java
est doté d’une classe spéciale nommée Scanner. Pour utiliser cette classe nous devrions :
– Importer le package : import [Link] ;
– Faire une instanciation : Scanner maSaisie = new Scanner([Link]) ;
– Guider l’utilisateur avec un message qui s’affiche à l’écran : [Link]("Tapez votre message
– Récupérer la saisie clavier dans une variable : String maphrase = [Link]() ;
– Afficher le résultat à l’écran : [Link](" vous avez saisie " + maphrase ) ;
exemple
import [Link];
public class Essai {
UCB 2024 13
Tapamo Kenfack POO avec Java

public static void main(String[] args) {

Scanner maSaisie = new Scanner([Link]) ;
[Link]("Tapez votre message : ");
String maphrase = [Link]() ;
[Link](" vous avez saisie " + maphrase
}
}

2.3 Compilation et exécution d’un programme Java simple

2.3.1 Utilisation du compilateur javac
Le compilateur javac est un outil essentiel pour la programmation en Java. Il permet de trans-
former le code source Java en bytecode, qui peut ensuite être exécuté par la Java Virtual Machine
(JVM). Voici comment utiliser javac pour compiler vos programmes Java.

2.3.2 Exécution de programmes avec java

2.3.3 Exercices pratiques : écrire, compiler et exécuter un programme simple

UCB 2024 14
Tapamo Kenfack POO avec Java

Chapitre 3

Classes et Objets

3.1 Définition et instanciation de classes et d’objets

3.1.1 Définition d’une classe et création d’objets
Définition 3.1.1: Classe en Java

En Java, une classe est comme un plan ou un modèle qui décrit les caractéristiques (attri-
buts) et les comportements (méthodes) d’un objet. C’est un peu comme une recette de cuisine :
elle indique les ingrédients (attributs) et les étapes à suivre (méthodes) pour préparer un plat
(l’objet).

Exemple : Imaginons une classe représentant un chien. Elle pourrait contenir :

– Attributs:
- nom (une chaîne de caractères)
- race (une chaîne de caractères)
- age (un entier)
– Méthodes:
+ aboyer() une méthode qui affiche Ouaf !
+ manger() une méthode qui simule l’action de manger

Création d’un objet

Définition 3.1.2: Objet

Un objet est une instance concrète d’une classe. C’est comme si on prenait la recette d’un gâteau
et qu’on le préparait : on obtient un gâteau spécifique avec ses propres caractéristiques (goût,
taille, etc.).

Pour créer un objet en Java, on utilise le mot-clé new suivi du nom de la classe et des arguments
nécessaires pour initialiser les attributs.
Exemple:

class Chien {
String nom;
String race;
int age;

public void aboyer() {

[Link]("Ouaf !");
}
UCB 2024 15
Tapamo Kenfack POO avec Java

public void manger() {

[Link]("Miam miam !");
}
}

public class Main {

public static void main(String[] args) {
// Création d'un objet de type Chien
Chien monChien = new Chien();
[Link] = "Médor";
[Link] = "Berger Allemand";
[Link] = 3;

// Utilisation des méthodes de l'objet

[Link]();
[Link]();
}
}

Explication du code :

– Définition de la classe Chien: On définit les attributs (nom, race, age) et les méthodes (aboyer,
manger) de la classe Chien.
– Création d’un objet: On crée un objet nommé monChien de type Chien en utilisant le mot-clé
new.
– Initialisation des attributs: On attribue des valeurs aux attributs de l’objet monChien.
– Utilisation des méthodes: On appelle les méthodes aboyer et manger de l’objet monChien.

3.1.2 Mots-clé new

Rôle: Le mot-clé new est utilisé pour instancier une classe, c’est-à-dire créer un nouvel objet à
partir de cette classe.
Fonctionnement: Lorsque vous utilisez new suivi du nom de la classe, vous demandez à la
machine virtuelle Java d’allouer de la mémoire pour un nouvel objet de ce type et d’initialiser ses
attributs.

3.2 Constructeurs
3.2.1 Définition et utilisation de constructeurs
Définition 3.2.1: Constructeur

Un constructeur en Java est une méthode spéciale qui est appelée automatiquement lorsqu’un
nouvel objet est créé à partir d’une classe. Il sert à initialiser les attributs de cet objet avec des
valeurs de départ.

Caractéristiques clés d’un constructeur:

– Même nom que la classe: Le nom d’un constructeur est toujours identique au nom de la classe.
– Pas de type de retour: Un constructeur ne retourne aucune valeur, pas même void.
– Peut avoir des paramètres: Un constructeur peut prendre des paramètres pour initialiser les
attributs de l’objet de manière flexible.

UCB 2024 16
Tapamo Kenfack POO avec Java

3.2.2 Surcharge de constructeurs

Définition 3.2.2: Surcharge de constructeur

La surcharge de constructeurs (en anglais, constructor overloading) est un concept en program-

mation orientée objet qui consiste à définir plusieurs constructeurs au sein d’une même classe,
chacun ayant une liste de paramètres différente. Cela permet de créer des objets de cette classe
avec différentes configurations initiales.

Pourquoi utiliser la surcharge de constructeurs ?

– Flexibilité: Vous pouvez offrir différentes façons d’initialiser un objet en fonction des besoins.
– Clarté: Des constructeurs surchargés rendent le code plus lisible en indiquant clairement com-
ment un objet doit être initialisé.
– Évitement de valeurs par défaut non désirées: Vous pouvez éviter d’utiliser des valeurs par
défaut pour les attributs qui doivent toujours être spécifiés lors de la création d’un objet.
Exemple
class Rectangle {
int longueur;
int largeur;

// Constructeur par défaut

public Rectangle() {
longueur = 1;
largeur = 1;
}

// Constructeur avec longueur et largeur spécifiées

public Rectangle(int longueur, int largeur) {
[Link] = longueur;
[Link] = largeur;
}

// Constructeur avec un carré comme paramètre

public Rectangle(int cote) {
longueur = cote;
largeur = cote;
}
}

3.3 Mots-clés this et static

Le mot-clé this en Java fait référence à l’instance courante d’une classe. Il est utilisé pour accéder
aux membres (attributs et méthodes) de l’objet courant.
Utilisations principales:
– Accéder aux attributs d’instance: Lorsque vous avez des noms de variables locaux qui masquent
des attributs d’instance, vous pouvez utiliser this pour accéder à l’attribut de l’instance.
– Appeler des méthodes d’instance: Vous pouvez utiliser this pour appeler d’autres méthodes de
la même instance.
– Passer l’objet courant comme argument: Vous pouvez passer l’objet courant comme argument
à une méthode en utilisant this.

class Personne {
String nom;
int age;
UCB 2024 17
Tapamo Kenfack POO avec Java

public Personne(String nom, int age) {

[Link] = nom; // Utilise this pour différencier
[Link] = age; // le paramètre nom de l'attribut nom
}

public void afficherInfos() {

[Link]("Nom : " + [Link]);
[Link]("Age : " + [Link]);
}
}

Le mot-clé static en Java indique que quelque chose appartient à la classe elle-même plutôt qu’à une
instance de la classe.
Utilisations principales:
– Variables statiques: Les variables statiques sont partagées par toutes les instances d’une classe.
Elles sont déclarées avec le mot-clé static avant le type de la variable.
– Méthodes statiques: Les méthodes statiques peuvent être appelées sans créer d’instance de la
classe. Elles sont déclarées avec le mot-clé static avant le type de retour de la méthode.
– Blocs statiques: Les blocs statiques sont exécutés une seule fois lors du chargement de la classe.
Exemple

class Calculatrice {
static double PI = 3.14159;

public static double calculerAireCercle(double rayon) {

return PI * rayon * rayon;
}
}

Dans cet exemple, PI est une constante statique accessible à partir de n’importe où sans créer
d’instance de Calculatrice. La méthode calculerAireCercle est également statique et peut être appelée
directement sans créer d’instance.

UCB 2024 18
Tapamo Kenfack POO avec Java

Chapitre 4

Encapsulation

4.1 Modificateurs d’accès (private, public, protected)

4.1.1 Rôle des modificateurs d’accès
Les modificateurs d’accès en Java sont des mots-clés qui déterminent le niveau de visibilité d’un
élément (attribut, méthode, ou classe) au sein d’un programme. Ils permettent de contrôler l’accès à
ces éléments et d’encapsuler les données pour une meilleure organisation et sécurité du code.
Les différents modificateurs d’accès
– public:
– Visibilité: Accessible de partout dans le programme.
– Utilisation: Pour les membres qui doivent être accessibles depuis n’importe quelle classe.
– private:
– Visibilité: Accessible uniquement au sein de la classe où il est déclaré.
– Utilisation: Pour encapsuler les données et les méthodes internes d’une classe, en les pro-
tégeant des accès extérieurs.
– protected:
– Visibilité: Accessible au sein de la classe où il est déclaré, dans ses sous-classes et dans les
autres classes du même package.
– Utilisation: Pour permettre l’héritage et la réutilisation de code tout en contrôlant l’accès à
certains membres.
– (Par défaut) :
– Visibilité: Accessible uniquement au sein du même package.
– Utilisation: Par défaut, si aucun modificateur n’est spécifié, un membre est accessible dans
tout le package.

4.1.2 Exemples et bonnes pratiques

class Animal {
private String nom; // Visible uniquement dans la classe Animal
protected int age; // Visible dans Animal, ses sous-classes et le même package
public void crier() { // Visible partout
[Link]("Je crie !");
}
}

class Chien extends Animal {

public void aboyer() {
[Link]("Ouaf !");
// On peut accéder à age car il est protected
UCB 2024 19
Tapamo Kenfack POO avec Java

[Link]("J'ai " + age + " ans.");

// On ne peut pas accéder à nom car il est private
}
}

Les modificateurs d’accès sont des outils essentiels pour structurer et sécuriser votre code Java.
Une utilisation judicieuse de ces modificateurs améliore considérablement la maintenabilité et la réuti-
lisabilité de votre code.
Principes généraux
– Encapsulation: Privilégiez l’utilisation du modificateur private pour les attributs d’une classe.
Cela permet de masquer les détails d’implémentation et de contrôler l’accès aux données via des
méthodes publiques (getters et setters).
– Héritage: Utilisez protected pour les membres (attributs ou méthodes) que vous souhaitez rendre
accessibles aux sous-classes. Cela favorise l’héritage et la réutilisation de code.
– Visibilité minimale: Accordez toujours le niveau de visibilité le plus restrictif possible. Par
exemple, si un membre n’est utilisé qu’à l’intérieur d’une classe, utilisez private.
– Cohésion: Les membres d’une classe doivent être étroitement liés. Évitez de rendre public un
membre qui n’est pas directement lié au rôle de la classe.
– Couplage: Minimisez le couplage entre les classes en réduisant les dépendances. Utilisez des
interfaces et des abstractions pour découpler les composants.
Cas d’utilisation spécifiques
– Attributs:
– Généralement privés: Les attributs sont souvent déclarés comme private pour protéger les
données internes de la classe.
– Exceptions: Les constantes peuvent être déclarées comme public static final pour être acces-
sibles partout.
– Méthodes:
– Méthodes publiques: Les méthodes qui constituent l’interface publique de la classe.
– Méthodes privées: Les méthodes utilitaires internes à la classe.
– Méthodes protégées: Les méthodes destinées à être utilisées par les sous-classes.
– Classes:
– Classes publiques: Les classes principales d’une application.
– Classes privées: Les classes utilitaires internes à une classe.
– Classes internes: Les classes définies à l’intérieur d’une autre classe.

4.2 Accesseurs et mutateurs (getters et setters)

4.2.1 Définition et utilisation de getters et setters
– Accesseur (getter) : Une méthode qui permet de récupérer la valeur d’un attribut d’un objet.
– Mutateur (setter) : Une méthode qui permet de modifier la valeur d’un attribut d’un objet.

Exemple

public class Personne {

private String nom;
private int age;

public String getNom() {

return nom;
}

public void setNom(String nom) {

UCB 2024 20
Tapamo Kenfack POO avec Java

[Link] = nom;
}

public int getAge() {

return age;

public void setAge(int age) {

if (age >= 0) {
[Link] = age;
} else {
throw new IllegalArgumentException("L'âge
doit être positif");
}
}
}

4.2.2 Bonnes pratiques

– Nommage standard: Utiliser les préfixes get et set pour les accesseurs et mutateurs.
– Retourne des copies: Pour les objets immuables, retourner une copie de l’objet plutôt que la
référence originale.
– Validation: Implémenter des validations dans les mutateurs pour garantir l’intégrité des données.
– Éviter les accesseurs et mutateurs pour toutes les propriétés: Utiliser des accesseurs et mutateurs
principalement pour les propriétés qui nécessitent une validation ou une logique supplémentaire.

4.3 Bonnes pratiques d’encapsulation

4.3.1 Principes de conception
4.3.2 Cas pratiques et exercices

UCB 2024 21
Tapamo Kenfack POO avec Java

Chapitre 5

Héritage

5.1 Concepts d’héritage

5.1.1 Introduction à l’héritage
Dans certaines applications, les classes utilisées ont en commun certaines variables, méthodes
de traitement ou même des signatures de méthode. Avec un langage de programmation orient objet,
on peut définir une classe à diffèrent niveaux d’abstraction permettant ainsi de factoriser certains
attributs communs a plusieurs classes. Une classe générale définit alors un ensemble d’attributs qui
sont partages par d’autres classes, dont on dira qu’elles héritent de cette classe générale.
Comme tous les langages orientés objet, JAVA supporte la généralisation spécialisation, le plus
communément appelée héritage dans les langages de programmation. Pour simplifier la mise en
œuvre, JAVA ne permet que l’héritage simple, c’est-à-dire qu’une classe dérive d’une classe et d’une
seule. En outre, JAVA introduit le concept d’interface ; une classe peut implémenter plusieurs inter-
faces. Nous présentons avec plus de détail le concept d’héritage dans ce chapitre.
Il faut retenir que toutes les classes dérivent d’une classe racine appelée "[Link]" .
Cette classe de nit des comportements stéréotypes dont nous reparlerons dans le cours Par exemple,
les classes Carre et Rectangle peuvent partager une méthode surface() renvoyant le résultat du calcul
de la surface de la figure. Plutôt que d’écrire deux fois cette méthode, on peut définir une relation
d’héritage entre les classes Carre et Rectangle. Dans ce cas, seule la classe Rectangle contient le
code de la méthode surface() mais celle-ci est également utilisable sur les objets de la classe Carre si
elle hérite de Rectangle.

5.1.2 Le mécanisme d’héritage

L’idée principale de l’héritage est d’organiser les classes de manière hiérarchique. La relation
d’héritage est unidirectionnelle et, si une classe B hérite d’une classe A, on dira que B est une sous-
classe de A. Cette notion de sous-classe signifie que la classe B est un cas particulier de la classe A
et donc que les objets instanciant la classe B instancient également la classe A.
L’héritage est la transmission de caractéristiques à ses descendants ? L’héritage correspond à
la relation est-un ? Un Etudiant est une Personne ? Un Etudiant est une spécialisation de Personne ?
Une PERSONNE est une généralisation d’un Etudiant
– vision descendante =>la possibilité de reprendre intégralement tout ce qui a déjà et fait et de
pouvoir l’enrichir.
– vision ascendante =>la possibilité de regrouper en un seul endroit ce qui est commun a plusieurs.
Prenons comme exemple des classes Carre, Rectangle et Cercle.
La figure suivante propose une organisation hiérarchique de ces classes telle que chien hérite
de Mammifère qui hérite de Animal qui hérite, ainsi de Etre vivant.

– vers le haut (en analyse O.O.) =>on regroupe dans une classe ce qui est commun a plusieurs
classes. Dans la classe Etre vivant, on regroupe les caractéristiques communes aux autres
classes.
UCB 2024 22
Tapamo Kenfack POO avec Java

Fig. 5.1 – Héritage

– vers le bas (lors de la réutilisabilité) =>la classe de base étant définie, on peut la reprendre intégra-
lement pour construire la classe dérivée. La classe Etre vivant étant définie, on peut la reprendre
intégralement, pour construire la classe Animal.

Une classe dérivée modélise un cas particulier de la classe de base, et est enrichie d’informations
supplémentaires.
La classe dérivée possède les propriétés suivantes :
– contient les données membres de la classe de base,
– peut en posséder de nouvelles,
– possède (a priori) les méthodes de sa classe de base,
– peut redéfinir (masquer) certaines méthodes,
– peut posséder de nouvelles méthodes. Pour signifier qu’une classe fille hérite d’une classe mère,
on utilise le mot clé extends : class Fille extends mère.
Notons que l’héritage en java est simple (une seule mère).

Définition 5.1.1: Héritage

L’héritage est un mécanisme fondamental de la programmation orientée objet qui permet de

créer de nouvelles classes en réutilisant les propriétés et les comportements d’une classe exis-
tante. Cette classe existante est appelée classe parente ou superclasse, tandis que la nouvelle
classe est appelée classe enfant ou sous-classe.

Comment ça marche ?
Une classe enfant hérite de toutes les méthodes et attributs (non privés) de sa classe parente.
La classe enfant peut redéfinir (surcharger) les méthodes héritées pour adapter leur comportement.
La classe enfant peut ajouter de nouveaux attributs et méthodes spécifiques à elle. Représentation
graphique
Exemple

class Animal {
String nom;
public void crier() {
[Link]("Je crie !");
}
}

UCB 2024 23
Tapamo Kenfack POO avec Java

class Chien extends Animal {

public void aboyer() {
[Link]("Ouaf !");
}
}
Dans cet exemple :
Animal est la classe parente. Chien est la classe enfant qui hérite de Animal. Un objet de type
Chien peut utiliser les méthodes crier() et aboyer().

5.1.3 Avantages de l’héritage en POO

– Réutilisation de code: Évitez de réécrire du code en héritant de classes existantes. Hiérarchie
de classes: Organisez votre code en une structure hiérarchique, reflétant les relations entre les
objets.
– Polymorphisme: Permet de traiter des objets de différentes classes de manière uniforme grâce
à un mécanisme appelé polymorphisme.

5.1.4 Héritage et constructeurs

Un objet d’une classe dérivée est un objet de la classe parente plus une partie qui correspond
à la classe dérivée. Il est donc nécessaire d’initialiser la partie provenant de la classe parente lorsque
l’objet est créé.
Le constructeur de la classe dérivée doit donc faire appel au constructeur de la classe parente
pour réaliser cette initialisation. Le plus souvent un constructeur de classe dérivée reçoit un ensemble
de paramètres pour initialiser les attributs de la classe parente. Il utilise ces paramètres pour faire
appel au constructeur de la classe parente.
Remarques
– L’appel au constructeur d’une classe supérieure doit toujours se situer dans un constructeur et
toujours en tant que première instruction ;
– Si aucun appel à un constructeur d’une classe supérieure n’est fait, le constructeur fait appel
implicitement à un constructeur vide de la classe supérieure (comme si la ligne super() était
présente). Si aucun constructeur vide n’est accessible dans la classe supérieure, une erreur se
produit lors de la compilation.

5.1.5 Rédéfinition des méthodes

La redéfinition d’une méthode héritée doit impérativement conserver la déclaration de la méthode
parent (type et nombre de paramètres, la valeur de retour et les exceptions propagées doivent être
identiques).
Si la signature de la méthode change, ce n’est plus une redéfinition mais une surcharge. Cette
nouvelle méthode n’est pas héritée : la classe mère ne possède pas de méthode possédant cette signa-
ture. Lors de la redéfinition d’une méthode, on ne doit pas restreindre sa visibilité.

5.1.6 Le transtypage
Il existe deux types de transtypage :
– Le transtypage ascendant qui sert a un objet à être vu comme du type de sa mère. Ce transty-
page est fait de façon implicite et n’est nécessaire que dans le cas où la classe courante possède
une propriété ayant le même nom que sa classe mère et que l’on cherche a accéder à la propriété
mère.
– Le transtypage descendant- le plus courant - qui sert a forcer une classe de type mère à être
vue comme un type fille. Ce transtypage n’est valide que si l’objet de type mère était de type fille
à son instanciation.

UCB 2024 24
Tapamo Kenfack POO avec Java

Voilà quelques règles à retenir :

– Une classe ne peut hériter que d’une autre classe (héritage simple, l’héritage multiple n’est pas
autorisé en Java).
– Une classe hérite d’une autre par l’utilisation du mot réservé extends.
– Une classe pour laquelle aucune spécialisation n’est explicitée spécialise implicitement la classe
[Link] (qui est la classe mère par défaut).
– Le mot réservé final utilise devant le mot clé class interdit toute spécialisation (héritage) de la
classe sur laquelle il est utilise

5.1.7 Le polymorphisme
Dans le paragraphe précédent, nous avons parlé de superclasses et de sous-classes. Si une
classe hérite d’une méthode de sa superclasse, alors il y a une chance de reformuler la méthode à
condition qu’il ne soit pas marqué final.
L’avantage de la substitution est la capacité de définir un comportement spécifique au type de
sous-classe, ce qui signifie qu’une sous-classe peut implémenter une méthode de classe parent en
fonction de son besoin et ses exigences.
public class Animal {
public void seDeplacer() {
[Link]("Un animal peut se déplacer");
}
}
class Chien extends Animal {
public void seDeplacer() {
[Link]("Un chien peut courir");
}
}
class Oiseau extends Animal {
public void seDeplacer() {
[Link]("Un oiseau peut voler");
}
}
Et pour exécuter le code de cette classe nous aurons besoin d’une autre classe doté d’une méthode
static void main().
public class ExecutionAnimal {
public static void main(String args[]) {
Animal a = new Animal();
Animal b = new Chien();
Animal c= new Oiseau();
[Link]();
[Link]();
[Link]();
Ce qui affiche après exécution :
Un animal peut se déplacer
Un chien peut courir
Un oiseau peut voler

5.2 Exemple
5.2.1 Description
Supposons qu’on veuille créer une classe enseignant : un enseignant est une personne particu-
lière. Il a des attributs qu’une autre personne n’aura pas : la matière qu’il enseigne par exemple. Mais
UCB 2024 25
Tapamo Kenfack POO avec Java

il a aussi les attributs de toute personne : prénom, nom et âge. Un enseignant fait donc pleinement
partie de la classe personne mais a des attributs supplémentaires. Plutôt que d’écrire une classe en-
seignant en partant de rien, on préfèrerait reprendre l’acquis de la classe personne qu’on adapterait
au caractère particulier des enseignants. C’est le concept d’héritage qui nous permet cela.
Pour exprimer que la classe enseignant hérite des propriétés de la classe personne, on écrira :
public class enseignant extends personne
personne est appelée la classe parent (ou mère) et enseignant la classe dérivée (ou fille). Un objet
enseignant a toutes les qualités d’un objet personne : il a les mêmes attributs et les mêmes méthodes.
Ces attributs et méthodes de la classe parent ne sont pas répétées dans la définition de la classe fille :
on se contente d’indiquer les attributs et méthodes rajoutés par la classe fille :

5.2.2 Création de la classe fille

class enseignant extends personne{
// attributs
private int section;
// constructeur
public enseignant(String P, String N, int age,int section){
super(P,N,age);
[Link]=section;
}
}

5.2.3 Création de la classe parent

public class personne{
private String prenom;
private String nom;
private int age;
public personne(String P, String N, int age){
[Link]=P;
[Link]=N;
[Link]=age;
}
public personne(personne P){
[Link]=[Link];
[Link]=[Link];
[Link]=[Link];
}
public String identite(){
return "personne("+prenom+","+nom+","+age+")";
}
// accesseurs
public String getPrenom(){
return prenom;
}
public String getNom(){
return nom;
}
public int getAge(){
return age;
}
//modifieurs
public void setPrenom(String P){
[Link]=P;
UCB 2024 26
Tapamo Kenfack POO avec Java

}
public void setNom(String N){
[Link]=N;
}
public void setAge(int age){
[Link]=age;
}
}

5.2.4 Construction d’un objet enseignant

Le constructeur de la classe enseignant est le suivant :
// constructeur
public enseignant(String P, String N, int age, int section){
super(P,N,age);
[Link]=section;
}
L’instruction super(P,N,age) est un appel au constructeur de la classe parent, ici la classe personne.
On sait que ce constructeur initialise les champs prenom, nom et age de l’objet personne contenu à
l’intérieur de l’objet étudiant. Cela paraît bien compliqué et on pourrait préférer écrire :
// constructeur
public enseignant(String P, String N, int age, int section){
[Link]=P;
[Link]=N;
[Link]=age;
[Link]=section;
}
C’est impossible. La classe personne a déclaré privés (private) ses trois champs prenom, nom et age.
Seuls des objets de la même classe ont un accès direct à ces champs. Tous les autres objets, y compris
des objets fils comme ici, doivent passer par des méthodes publiques pour y avoir accès. Cela aurait
été différent si la classe personne avait déclaré protégés (protected) les trois champs : elle autorisait
alors des classes dérivées à avoir un accès direct aux trois champs. Dans notre exemple, utiliser le
constructeur de la classe parent était donc la bonne solution et c’est la méthode habituelle : lors de la
construction d’un objet fils, on appelle d’abord le constructeur de l’objet parent puis on complète les
initialisations propres cette fois à l’objet fils (section dans notre exemple).
Tentons un premier programme :
public class test1{
public static void main(String arg[]){
[Link](new enseignant("Jean","Dupont",30,27).identite());
}
}

5.2.5 Surcharge d’une méthode

Dans l’exemple précédent, nous avons eu l’identité de la partie personne de l’enseignant mais il
manque certaines informations propres à la classe enseignant (la section). On est donc amené à écrire
une méthode permettant d’identifier l’enseignant :
class enseignant extends personne{
int section;
public enseignant(String P, String N, int age, int section){
super(P,N,age);
[Link]=section;
UCB 2024 27
Tapamo Kenfack POO avec Java

}
public String identite(){
return "enseignant("+[Link]()+","+section+")";
}
}
La méthode identite de la classe enseignant s’appuie sur la méthode identite de sa classe mère (su-
[Link]) pour afficher sa partie personne puis complète avec le champ section qui est propre à la
classe enseignant. La classe enseignant dispose maintenant deux méthodes identite : celle héritée de
la classe parent personne et la sienne propre
Si E est un ojet enseignant, [Link] désigne la méthode identite de la classe enseignant. On
dit que la méthode identite de la classe mère est surchargée par la méthode identite de la classe fille.
De façon générale, si O est un objet et M une méthode, pour exécuter la méthode O.M, le système
cherche une méthode M dans l’ordre suivant :
– dans la classe de l’objet O
– dans sa classe mère s’il en a une
– dans la classe mère de sa classe mère si elle existe
– etc. . .
L’héritage permet donc de surcharger dans la classe fille des méthodes de même nom dans la
classe mère. C’est ce qui permet d’adapter la classe fille à ses propres besoins. Associée au polymor-
phisme que nous allons voir un peu plus loin, la surcharge de méthodes est le principal intérêt de
l’héritage.

UCB 2024 28
Tapamo Kenfack POO avec Java

Chapitre 6

Polymorphisme

6.1 Polymorphisme à travers l’héritage

6.1.1 Définition du polymorphisme
𝑥2
[0,1] [1,1]

𝑥 = [𝑥1 ,𝑥 2 ]
𝑥2

[0,0] 𝑥1 𝑥1

6.1.2 Utilisation du polymorphisme dans des classes dérivées

6.2 Redéfinition des méthodes (override)

6.2.1 Surcharge et redéfinition de méthodes
6.2.2 Utilisation de l’annotation @Override

6.3 Utilisation des classes abstraites et des interfaces

6.3.1 Introduction aux classes abstraites et interfaces
6.3.2 Différences entre les deux

UCB 2024 29
Tapamo Kenfack POO avec Java

Chapitre 7

Interfaces et Classes Abstraites

7.1 Différences entre interfaces et classes abstraites

Comparaison détaillée Cas d’utilisation pour chacun

7.2 Implémentation d’interfaces

Définition et implémentation d’interfaces Exemples et exercices pratiques

7.3 Création et utilisation de classes abstraites

Définition de classes abstraites Implémentation de méthodes abstraites et concrètes

UCB 2024 30
Tapamo Kenfack POO avec Java

Chapitre 8

Gestion des Exceptions

8.1 Concepts de base des exceptions

Les exceptions représentent le mécanisme de gestion des erreurs intégré au langage Java. Il
se compose d’objets représentant les erreurs et d’un ensemble de trois mots clés qui permettent de
détecter et de traiter ces erreurs (try, catch et finally ) mais aussi de les lever ou les propager (throw
et throws).
Lors de la détection d’une erreur, un objet qui hérite de la classe Exception est créé (on dit qu’une
exception est levée) et propagé à travers la pile d’exécution jusqu’à ce qu’il soit traité.
Ces mécanismes permettent de renforcer la sécurité du code Java.
Exemple d’exception levée non capturée
public class TestException {
public static void main([Link][] args) {
int i = 3;
int j = 0;
[Link]("résultat = " + (i / j));
}
}

Si dans un bloc de code on fait appel à une méthode qui peut potentiellement générer une
exception, on doit soit essayer de la récupérer avec try/catch, soit ajouter le mot clé throws dans la
déclaration du bloc. Si on ne le fait pas, il y a une erreur à la compilation. Les erreurs et exceptions du
paquetage [Link] échappent à cette contrainte. Throws permet de déléguer la responsabilité des
erreurs à la méthode appelante
Ce procédé présente un inconvénient : de nombreuses méthodes des packages java indiquent
dans leur déclaration qu’elles peuvent lever une exception. Cependant ceci garantit que certaines
exceptions critiques seront prises explicitement en compte par le programmeur.

8.2 Try, catch, finally

Le bloc try rassemble les appels de méthodes susceptibles de produire des erreurs ou des ex-
ceptions. L’instruction try est suivie d’instructions entre des accolades.

try {
operation_risquée1;
opération_risquée2;
} catch (ExceptionInteressante e) {
traitements
} catch (ExceptionParticulière e) {
traitements
} catch (Exception e) {
UCB 2024 31
Tapamo Kenfack POO avec Java

traitements
} finally {
traitement_pour_terminer_proprement;
}
Si un événement indésirable survient dans le bloc try, la partie éventuellement non exécutée de ce bloc
est abandonnée et le premier bloc catch est traité. Si un bloc catch est défini pour capturer l’exception
issue du bloc try alors elle est traitée en exécutant le code associé au bloc. Si le bloc catch est vide
(aucune instruction entre les accolades) alors l’exception capturée est ignorée. Une telle utilisation
de l’instruction try/catch n’est pas une bonne pratique : il est préférable de toujours apporter un
traitement adapté lors de la capture d’une exception.
S’il y a plusieurs types d’erreurs et d’exceptions à intercepter, il faut définir autant de blocs catch
que de types d’événements. Par type d’exception, il faut comprendre « qui est du type de la classe de
l’exception ou d’une de ses sous-classes ». Ainsi dans l’ordre séquentiel des clauses catch, un type
d’exception ne doit pas venir après un type d’une exception d’une super-classe. Il faut faire attention à
l’ordre des clauses catch pour traiter en premier les exceptions les plus précises (sous-classes) avant
les exceptions plus générales. Un message d’erreur est émis par le compilateur dans le cas contraire.
erreur à la compil car Exception est traité en premier alors que ArithmeticException est une
sous-classe de Exception
public class TestException {
public static void main([Link][] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
[Link]("résultat = " + (i / j));
} catch (Exception e) {
} catch (ArithmeticException e) {
}
}
}
Résultat de la compilation
tapamo@tapamo-ThinkPad-P50:/test01$ javac [Link]
[Link]: error: exception ArithmeticException has already been caught
} catch (ArithmeticException e) {
^
1 error
Si l’exception générée est une instance de la classe déclarée dans la clause catch ou d’une classe
dérivée, alors on exécute le bloc associé. Si l’exception n’est pas traitée par un bloc catch, elle sera
transmise au bloc de niveau supérieur. Si l’on ne se trouve pas dans un autre bloc try, on quitte la
méthode en cours, qui regénère à son tour une exception dans la méthode appelante.
L’exécution totale du bloc try et d’un bloc d’une clause catch sont mutuellement exclusives : si
une exception est levée, l’exécution du bloc try est arrêtée et si elle existe, la clause catch adéquate est
exécutée.

Remarque 1: Clause finilly

La clause finally définit un bloc qui sera toujours exécuté, qu’une exception soit levée ou non.
Ce bloc est facultatif. Il est aussi exécuté si dans le bloc try il y a une instruction break ou
continue.

8.2.1 La classe Throwable

Cette classe descend directement de la classe Object : c’est la classe de base pour le traitement
des erreurs.
UCB 2024 32
Tapamo Kenfack POO avec Java

Cette classe possède deux constructeurs : Throwable() et Throwable(String). La chaîne en para-

mètre permet de définir un message qui décrit l’exception et qui pourra être consulté dans un bloc
catch.
Les principales méthodes de la classe Throwable sont :
– String getMessage( ) : lecture de message
– void printStackTrace( ) : affiche l’exception et l’état de la pile d’exécution au moment de son
appel
– void printStackTrace(PrintStream s) : Idem mais envoie le résultat dans un flux

8.2.2 Utilisation de finally

8.3 Création de vos propres exceptions

8.3.1 Définition de classes d’exception personnalisées
8.3.2 Utilisation des exceptions personnalisées dans les programmes

UCB 2024 33
Tapamo Kenfack POO avec Java

Chapitre 9

Collections et Génériques

9.1 Introduction aux collections (List, Set, Map)

9.1.1 Présentation des principales interfaces de la collection framework
9.1.2 Exemples d’utilisation

9.2 Utilisation des collections Java

9.2.1 Manipulation des listes, ensembles et maps
9.2.2 Méthodes courantes des collections

9.3 Concepts de base des génériques

9.3.1 Introduction aux génériques
9.3.2 Utilisation des génériques dans les collections

UCB 2024 34
Tapamo Kenfack POO avec Java

Chapitre 10

Fichiers et Flux

10.1 Lecture et écriture de fichiers

10.1.1 Classes File, FileReader, FileWriter
10.1.2 Exemples pratiques de lecture et d’écriture

10.2 Utilisation des classes de flux (InputStream, OutputStream)

10.2.1 Introduction aux flux d’entrée et de sortie
10.2.2 Exemples d’utilisation des flux

10.3 Sérialisation des objets

10.3.1 Concepts de base de la sérialisation
10.3.2 Sérialisation et désérialisation d’objets

UCB 2024 35
Tapamo Kenfack POO avec Java

Chapitre 11

Bibliothèques et API Java

11.1 Introduction aux bibliothèques standard Java ([Link], [Link])

11.1.1 Aperçu des bibliothèques standard
11.1.2 Utilisation des classes utilitaires

11.2 Utilisation des classes et méthodes utiles

11.2.1 Méthodes communes des classes utilitaires
11.2.2 Exemples pratiques

11.3 Introduction aux API externes

11.3.1 Aperçu des API populaires
11.3.2 Comment intégrer et utiliser des API externes

UCB 2024 36
Tapamo Kenfack POO avec Java

Chapitre 12

Concurrence et Multithreading

12.1 Concepts de base du multithreading

12.1.1 Introduction au multithreading
12.1.2 Avantages et inconvénients

12.2 Création et gestion de threads

12.2.1 Création de threads avec Runnable et Thread
12.2.2 Gestion des threads et synchronisation

12.3 Synchronisation et gestion des ressources partagées

12.3.1 Problèmes de concurrence
12.3.2 Utilisation des mots-clés synchronized, wait, notify

UCB 2024 37
Tapamo Kenfack POO avec Java

Chapitre 13

Conception Orientée Objet

13.1 Principes SOLID

13.1.1 Introduction aux principes SOLID
13.1.2 Importance des principes SOLID dans la conception orientée objet

13.2 Design patterns classiques (Singleton, Factory, Observer)

13.2.1 Présentation des design patterns
13.2.2 Exemples de mise en œuvre

13.3 Bonnes pratiques de conception

13.3.1 Principes de conception robuste
13.3.2 Études de cas

UCB 2024 38
Tapamo Kenfack POO avec Java

Chapitre 14

Projets Pratiques

14.1 Introduction aux projets pratiques

14.1.1 Présentation des projets
14.1.2 Formation de groupes de travail

14.2 Développement d’un projet en petits groupes

14.2.1 Travaux pratiques en groupe
14.2.2 Suivi et assistance par l’enseignant

14.3 Revue de code et feedback

14.3.1 Présentation des projets
14.3.2 Feedback et amélioration

UCB 2024 39
Tapamo Kenfack POO avec Java

Chapitre 15

Révision et Évaluation

15.1 Révision des concepts clés

15.1.1 Récapitulatif des concepts appris
15.1.2 Questions-réponses

15.2 Session de questions-réponses

15.2.1 Clarification des doutes
15.2.2 Préparation pour l’évaluation finale

15.3 Évaluation finale (examen pratique et théorique)

15.3.1 Examen pratique : implémentation d’un projet ou d’un problème donné
15.3.2 Examen théorique : questionnaire sur les concepts étudiés

15.4 Random Examples

Définition 15.4.1: Limit of Sequence in ℝ

Let {𝑠 𝑛 } be a sequence in ℝ. We say

lim 𝑠 𝑛 = 𝑠
𝑛→∞

where 𝑠 ∈ ℝ if ∀ real numbers 𝜖 > 0 ∃ natural number 𝑁 such that for 𝑛 > 𝑁

𝑠 − 𝜖 < 𝑠 𝑛 < 𝑠 + 𝜖 i.e. |𝑠 − 𝑠 𝑛 | < 𝜖

Question 1

Is the set 𝑥−axis\{Origin} a closed set

Solution: We have to take its complement and check whether that set is a open set i.e. if it is a union
of open balls
Note:-
We will do topology in Normed Linear Space (Mainly ℝ𝑛 and occasionally ℂ𝑛 )using the language of
Metric Space

UCB 2024 40
Tapamo Kenfack POO avec Java

Fig. 15.1 – Constituants Android

UCB 2024 41
Tapamo Kenfack POO avec Java

Claim 15.4.1 Topology

Topology is cool

Exemple 15.4.1 (Open Set and Close Set)

Open Set: • 𝜙Ð
• 𝐵𝑟 (𝑥) (Any 𝑟 > 0 will do)
𝑥∈𝑋
• 𝐵𝑟 (𝑥) is open
Closed Set: • 𝑋, 𝜙
• 𝐵𝑟 (𝑥)
𝑥−axis ∪ 𝑦−axis

Théorème 15.4.1
If 𝑥 ∈ open set 𝑉 then ∃ 𝛿 > 0 such that 𝐵 𝛿 (𝑥) ⊂ 𝑉

Démonstration: By openness of 𝑉, 𝑥 ∈ 𝐵𝑟 (𝑢) ⊂ 𝑉

𝐵 𝛿 (𝑥)
𝐵𝑟 (𝑢)
𝑥
𝑢

Given 𝑥 ∈ 𝐵𝑟 (𝑢) ⊂ 𝑉, we want 𝛿 > 0 such that 𝑥 ∈ 𝐵 𝛿 (𝑥) ⊂ 𝐵𝑟 (𝑢) ⊂ 𝑉. Let 𝑑 = 𝑑(𝑢,𝑥). Choose 𝛿 such
that 𝑑 + 𝛿 < 𝑟 (e.g. 𝛿 < 𝑟−𝑑
2 )
If 𝑦 ∈ 𝐵 𝛿 (𝑥) we will be done by showing that 𝑑(𝑢,𝑦) < 𝑟 but

𝑑(𝑢,𝑦) ⩽ 𝑑(𝑢,𝑥) + 𝑑(𝑥,𝑦) < 𝑑 + 𝛿 < 𝑟

Corollaire 15.4.1
By the result of the proof, we can then show...

Lemme 15.4.1
Suppose 𝑣®1 , . . . ,𝑣®𝑛 ∈ ℝ𝑛 is subspace of ℝ𝑛 .

Proposition 15.4.1
1 + 1 = 2.

UCB 2024 42
Tapamo Kenfack POO avec Java

15.5 Random
Définition 15.5.1: Normed Linear Space and Norm ∥ · ∥

Let 𝑉 be a vector space over ℝ (or ℂ). A norm on 𝑉 is function ∥ · ∥ 𝑉 → ℝ⩾0 satisfying
1 ∥𝑥∥ = 0 ⇐⇒ 𝑥 = 0 ∀ 𝑥 ∈ 𝑉
2 ∥𝜆𝑥∥ = |𝜆|∥𝑥∥ ∀ 𝜆 ∈ ℝ(or ℂ), 𝑥 ∈ 𝑉
3 ∥𝑥 + 𝑦∥ ⩽ ∥𝑥∥ + ∥𝑦∥ ∀ 𝑥,𝑦 ∈ 𝑉 (Triangle Inequality/Subadditivity)
And 𝑉 is called a normed linear space.
• Same definition works with 𝑉 a vector space over ℂ √ (again ∥ · ∥ → ℝ⩾0 ) where 2 becomes
∥𝜆𝑥∥ = |𝜆|∥𝑥∥ ∀ 𝜆 ∈ ℂ, 𝑥 ∈ 𝑉, where for 𝜆 = 𝑎 + 𝑖𝑏, |𝜆| = 𝑎 2 + 𝑏 2

Exemple 15.5.1 (𝒑−Norm)

𝑉 = ℝ𝑚 , 𝑝 ∈ ℝ⩾0 . Define for 𝑥 = (𝑥1 ,𝑥 2 , · · · ,𝑥 𝑚 ) ∈ ℝ𝑚
  1𝑝
𝑝 𝑝 𝑝
∥𝑥∥𝑝 = |𝑥1 | + |𝑥2 | + · · · + |𝑥 𝑚 |

(In school 𝑝 = 2)

Special Case 𝒑 = 1: ∥𝑥∥1 = |𝑥 1 | + |𝑥2 | + · · · + |𝑥 𝑚 | is clearly a norm by usual triangle inequality.

Special Case 𝒑 → ∞ (ℝ𝒎 with ∥ · ∥∞ ): ∥𝑥∥∞ = max{|𝑥1 |,|𝑥 2 |, · · · ,|𝑥 𝑚 |}
For 𝑚 = 1 these 𝑝−norms are nothing but |𝑥|. Now exercise

Question 2

Prove that triangle inequality is true if 𝑝 ⩾ 1 for 𝑝−norms. (What goes wrong for 𝑝 < 1 ?)

Solution: For Property 3 for norm-2

When field is ℝ :
We have to show
s sÕ 2
Õ © Õ 2
(𝑥 𝑖 + 𝑦 𝑖 ) ⩽ ­ 𝑥𝑖 +
2
𝑦 𝑖2 ®
ª
𝑖 « 𝑖 𝑖 ¬
v
u
t" #" #
Õ Õ Õ Õ Õ
=⇒ (𝑥 𝑖 + 2𝑥 𝑖 𝑦 𝑖 + 𝑦 𝑖 ) ⩽
2 2
𝑥𝑖 + 2
2
𝑥𝑖
2
𝑦𝑖 +
2
𝑦 𝑖2
𝑖 𝑖 𝑖 𝑖 𝑖
" #2 " #" #
Õ Õ Õ
=⇒ 𝑥 𝑖 𝑦𝑖 ⩽ 𝑥 2𝑖 𝑦 𝑖2
𝑖 𝑖 𝑖

So in other words prove ⟨𝑥,𝑦⟩ 2 ⩽ ⟨𝑥,𝑥⟩⟨𝑦,𝑦⟩ where

Õ
⟨𝑥,𝑦⟩ = 𝑥 𝑖 𝑦𝑖
𝑖

Note:-
– ∥𝑥∥2 = ⟨𝑥,𝑥⟩
– ⟨𝑥,𝑦⟩ = ⟨𝑦,𝑥⟩
– ⟨·,·⟩ is ℝ−linear in each slot i.e.
⟨𝑟𝑥 + 𝑥 ′ ,𝑦⟩ = 𝑟⟨𝑥,𝑦⟩ + ⟨𝑥 ′ ,𝑦⟩ and similarly for second slot

UCB 2024 43
Tapamo Kenfack POO avec Java

Here in ⟨𝑥,𝑦⟩ 𝑥 is in first slot and 𝑦 is in second slot.

Now the statement is just the Cauchy-Schwartz Inequality. For proof

⟨𝑥,𝑦⟩ 2 ⩽ ⟨𝑥,𝑥⟩⟨𝑦,𝑦⟩

expand everything of ⟨𝑥 − 𝜆𝑦,𝑥 − 𝜆𝑦⟩ which is going to give a quadratic equation in variable 𝜆

⟨𝑥 − 𝜆𝑦,𝑥 − 𝜆𝑦⟩ = ⟨𝑥,𝑥 − 𝜆𝑦⟩ − 𝜆⟨𝑦,𝑥 − 𝜆𝑦⟩

= ⟨𝑥,𝑥⟩ − 𝜆⟨𝑥,𝑦⟩ − 𝜆⟨𝑦,𝑥⟩ + 𝜆2 ⟨𝑦,𝑦⟩
= ⟨𝑥,𝑥⟩ − 2𝜆⟨𝑥,𝑦⟩ + 𝜆2 ⟨𝑦,𝑦⟩

Now unless 𝑥 = 𝜆𝑦 we have ⟨𝑥 − 𝜆𝑦,𝑥 − 𝜆𝑦⟩ > 0 Hence the quadratic equation has no root therefore the
discriminant is greater than zero.

When field is ℂ :
Modify the definition by Õ
⟨𝑥,𝑦⟩ = 𝑥 𝑖 𝑦𝑖
𝑖

Then we still have ⟨𝑥,𝑥⟩ ⩾ 0

15.6 Algorithms

Algorithm 1: what
Input: This is some input
Output: This is some output
/* This is a comment */

1 some code here;

2 𝑥 ← 0;
3 𝑦 ← 0;
4 if 𝑥 > 5 then
5 x is greater than 5 ; // This is also a comment
6 else
7 x is less than or equal to 5;
8 end
9 foreach y in 0..5 do
10 𝑦 ← 𝑦 + 1;
11 end
12 for 𝑦 in 0..5 do
13 𝑦 ← 𝑦 − 1;
14 end
15 while 𝑥 > 5 do
16 𝑥 ← 𝑥 − 1;
17 end
18 return Return something here;

UCB 2024 44