Travaux Pratiques

Monter en compétences dans le développement Orientée

Objet en Java.
Présenté par Ghislain AKINOCHO – ESMT – 2021/22

Cette fiche vous permettra de monter en force dans la maîtrise de la philosophie objet et du
développement d’applications en Java. Néanmoins, sachez que c’est en pratiquant qu’on développe
ces aptitudes et cela quel que soit le domaine.

Les prérequis pour démarrer ces exercices pratiques sont les suivants :
- Avoir lu les slides de présentation pour chaque thème abordé.
- Disposé du JDK 1.8 minimum.
- Disposé de l’IDE Eclipse.

Page | 1
TP1- Les interfaces
Objectif : Ce TP vous permettra de concevoir une hiérarchie de classes utilisant la notion d'interface.
Il vous servira également de révision pour les notions d'héritage, de classes abstraites et de
polymorphisme.

1. Lancer Eclipse et créer un nouveau projet Java : Menu File – New – Java Project

2. Nommez-le « 001-interfaces-salaries »

3. Le directeur d'une entreprise de produits chimiques souhaite gérer les salaires et primes de ses
employés au moyen d'un programme Java.

Un employé est caractérisé par son nom, son prénom, son âge et sa date d'entrée en service
dans l'entreprise.

Implémenter une classe abstraite « Employe » dotée des attributs nécessaires, d'une méthode
abstraite « calculerSalaire () » (ce calcul dépendra en effet du type de l'employé) et d'une
méthode « getNom () » retournant une chaine de caractère obtenue en concaténant la chaine
de caractères "L'employé " avec le prénom et le nom.

Dotez également cette classe d'un constructeur prenant en paramètre l'ensemble des attributs
nécessaires.

Calcul du Salaire

Le calcul du salaire mensuel dépend du type de l'employé. On distingue les types d'employés
suivants :

- Ceux affectés à la Vente (Vendeur). Leur salaire mensuel est le 20 % du chiffre d'affaire
qu'ils réalisent mensuellement, plus 400 KF (Kilo francs avec 1 KF = 1 000 FCFA).

- Ceux affectés à la Représentation (Représentant). Leur salaire mensuel est également le

20 % du chiffre d'affaire qu'ils réalisent mensuellement, plus 800 KF.

- Les vendeurs et représentants sont des commerciaux.

- Ceux affectés à la Production (Technicien). Leur salaire vaut le nombre d'unités

produites mensuellement multipliées par 5.

- Ceux affectés à la Manutention (Manutentionnaire). Leur salaire vaut leur nombre

d'heures de travail mensuel multipliées par 2,5 KF.

Implémenter une hiérarchie de classes pour les employés en respectant les conditions
suivantes :

- La super-classe de la hiérarchie doit être la classe « Employe ».

- Les nouvelles classes doivent contenir les attributs qui leur sont spécifiques ainsi que le
codage approprié des méthodes « calculerSalaire () » et « getNom () », en changeant

Page | 2
 le préfixe "L’employé " par la catégorie correspondante. Par exemple : "Le vendeur ",
"Le représentant ", etc …

- Chaque sous-classe est dotée d’un constructeur prenant en argument l'ensemble des
attributs nécessaires.

- Ne pas hésiter à introduire des classes intermédiaires pour éviter au maximum les
redondances d'attributs et de méthodes dans les sous-classes.

Employés à risque

Certains employés des secteurs « production » et « manutention » sont appelés à fabriquer et

manipuler des produits dangereux. Après plusieurs négociations syndicales, ces derniers
parviennent à obtenir une prime de risque mensuelle.

Compléter la solution en introduisant deux nouvelles sous-classes d'employés. Ces sous-

classes désigneront les employés des secteurs « production » et « manutention » travaillant
avec des produits dangereux.

Ajouter également à votre programme une interface pour les employés à risque permettant de
leur associer une prime mensuelle fixe de 100 KF.

Collections d’employés

Satisfait de la hiérarchie proposée, le directeur souhaite maintenant l'exploiter pour afficher le

salaire de tous ses employés ainsi que le salaire moyen.

Ajoutez une classe « Personnel » contenant une "collection" d'employés. Il s'agira d'une
collection polymorphique d'Employe - regardez le cours si vous ne voyez pas de quoi il s'agit.

Définir ensuite les méthodes suivantes dans la classe « Personnel » :

- void ajouterEmploye (Employe) qui ajoute un employé à la collection.

- void afficherSalaires () qui affiche le salaire de chacun des employés de la collection.
- double salaireMoyen () qui renvoie le salaire moyen des employés de la collection.

4. Implémenter cette solution sous Eclipse et tester les différentes fonctionnalités.

5. Créez un nouveau projet et nommez-le « 001-interfaces-personnel »

6. Considérons un établissement d’enseignement dans lequel on se propose d’implémenter une

application de gestion de l’ensemble du personnel.

Un Personnel est un fonctionnaire relevant du MENESR (Ministère de l’Éducation Nationale,

de l’Enseignement Supérieur et de la Recherche) ; il est défini par un certain nombre de
variables d’instances privées, chacune associée à une paire de getter/setter :

a. nom (String)

b. anneeDeNaissance (int)

c. matricule (int)

Page | 3
 Un Enseignant est une entité pouvant dispenser des cours ; cela peut être un personnel de
l’éducation nationale, mais pas nécessairement (un cours peut être donné par un intervenant
extérieur) ; comme précédemment, cela se définit par un ensemble de variables d’instance
privées avec leurs méthodes publiques d’accès :

a. nom (String)

b. anneeDeNaissance (int)

c. matiere (String)

d. titre (Aucun (juste enseignant), Docteur, Assistant, Maître-Assistant, Maître-Conférence,

Professeur, Professeur-Agrege)

Un Chercheur est une autre entité non nécessairement membre de l’éducation nationale,
consacrant une partie de son temps à des recherches ; encore une fois, des variables d’instance
privées et des méthodes publiques d’accès :

e. nom (String)

f. anneeDeNaissance (int)

g. domaineDeRecherches (String)

h. nombrePublications (int)

Les entités qui n’appartiennent pas au MENESR doivent disposer d’une autorisation qui peut
être soumise pour validation, qui peut être annulée (elle n’est donc plus valide). Une
« Autorisation » est une entité qui dispose des variables d’instances suivantes :

i. libellé (String)

j. statut (Boolean) : valide ou non

k. debut (int) : Valide à partir de l’année 2000 (par exemple)

l. fin (int) : … jusqu’à l’année 2007 (par exemple)

7. Définir la hiérarchie de classes la mieux adapter au contexte puis les implémenter et les rendre
parfaitement opérationnelles.

En outre, nous supposerons que des méthodes sont disponibles par ailleurs, qui prennent pour
argument des objets spécifiques de trois classes du modèle :

- public static void gestionCarriere (Personnel unPersonnel);

- public static void emploiDuTemps (Enseignant unEnseignant);

- public static void rapportActivite (Chercheur unChercheur);

8. Définir ces trois méthodes (dans une autre classe), et afficher simplement quelques attribut de
l'argument passé en paramètre.

Page | 4
 9. Instanciez dans votre main quelques Personnel, Enseignant et Chercheur, et testez ces trois
méthodes. Faites des tests supplémentaires sur les autres classes instanciables que vous auriez
éventuellement créées.

10. Maintenant, on aimerait avoir des objets qui soient à la fois des Personnels, des Enseignants
et des Chercheurs et qu'on puisse passer à chacune des trois méthodes. Il va donc falloir
modifier votre code en utilisant la notion d’interfaces.

11. Le travail à faire est le suivant :

- définir une classe « PersonnelEnseignantChercheur » destinée à représenter des

personnels de l’éducation nationale qui sont en même temps des enseignants et des
chercheurs.

- Il faut utiliser les trois classes « Personnel », « Enseignant » et « Chercheur », et la

nouvelle classe doit être définie de telle manière que ses instances puissent être
données pour argument aux méthodes ci-dessus. Il faudra certainement retoucher la
signature de ces méthodes.

L'idée générale est de parler de comportements qui sont au nombre de 3 au moins et qui seront
des interfaces. Ce sont elles qui, dans l'ultime version du code seront appelées « IPersonnel »,
« IEnseignant » et « IChercheur ».

- définir de la même manière des classes « PersonnelEnseignant »,

« EnseignantChercheur », « PersonnelChercheur », etc…

- Ces classes concrètes implémenteront 2 des trois interfaces et les méthodes static ci-
dessus doivent donc désormais, sans aucun changement, fonctionner avec deux
objets de types différents.

Vous avez terminé ! Vous êtes prêt pour le TP suivant.

Page | 5
TP2- Les collections et la généricité
Objectif : Ce TP vous permettra de mettre en œuvre le concept de généricité en implémentant des
méthodes et des classes génériques.

1. Lancer Eclipse et créer un nouveau projet Java : Menu File – New – Java Project

2. Dans le projet « 001-interfaces-salaries », on souhaite trier la collection d’employés selon

le salaire mais également sur le critère du « Nom Prénom » et de l’âge. Proposer une solution
utilisant les interfaces Comparable <T> et Comparator <T>.

3. Créer un nouveau projet Java intitulé « 006-collections-generiques »

4. La classe abstraite « IntArray » ci-dessous encapsule un tableau d'entiers. Elle comporte

deux méthodes permettant de trier le tableau et d'afficher son contenu. Proposez une classe
générique « GenericArray » à l’image de la classe précédente, permettant d’encapsuler tout
type d’objets, de les trier selon l’ordre naturel et de les afficher.

package sn.esmt.formation.java;

public abstract class IntArray {

protected int values [];

public IntArray (int values []) {

this.values = values;
}

public abstract void trier ();

public abstract void afficher ();
}

5. Dans votre main, instanciez des objets de type « GenericArray » pour trier et afficher des
entiers, réels, Personne, Emission, Employe, etc … Le choix de l’ordre naturel de tri des
différents objets est laissé à votre appréciation.

6. Reprendre le TP « 001-interfaces-salaries » et, en utilisant les interfaces génériques

Comparable <T> et Comparator <T> donner la possibilité de trier les membres du personnel
et de les afficher selon leur salaire, leur nom et prénom et selon leur ancienneté (du plus
ancien au plus récent). Implémenter à cet effet les méthodes suivantes dans la classe
« Personnel » :
a. public void afficherLePersonnelSelonNomPrenom () ;
b. public void afficherLePersonnelSelonSalaire () ;
c. public void afficherLePersonnelSelonAnciennete() ;

7. Tester les fonctionnalités dans la classe principale.

Page | 6
Vous avez terminé ! Vous êtes prêt pour le TP suivant

Page | 7
TP3- Les exceptions
Objectif : Ce TP vous apprendra à gérer convenablement les erreurs en utilisant le mécanisme offert
par les « exceptions » en Java.

1. Lancer Eclipse et créer un nouveau projet Java : Menu File – New – Java Project

2. Nommez-le « 007-les-exceptions »

3. Entrer le code suivant dans votre classe principale « Main »

package sn.esmt.formation.java.runtime;

import java.util.Scanner;

class Clavier {
private Clavier() {}

public static int lireInt () {

Scanner sc = new Scanner (System.in);

int value = sc.nextInt();
sc.close();

return value;
}

public static int lireInt (String message) {

System.out.print(message);
return lireInt();
}
}

public class Main {

public static void main (String[] args) {
int age = Clavier.lireInt("Entrez votre age svp : ") ;
System.out.println ("Saisie correcte : " + age);
}
}

4. Lancer l’exécution puis saisissez une information ne correspondant pas à un entier lorsque vous
y êtes invité. Une erreur se produit. Quel est le type de l’erreur (classe de l’exception) et quel
est le message associé ?

5. L’exécution du programme a été interrompue par cette erreur. Proposez une solution basée
sur la gestion des exceptions permettant d’éviter cette interruption.

6. Dans le programme qui suit, un message est affiché lorsque l’âge est inférieur à 18. On souhaite
déclencher une exception non contrôlée de type « IllegalArgumentException » dans ce cas
de figure. Modifier le code en conséquence.

Page | 8
 public class Main {
public static void main (String[] args) {
int age = Clavier.lireInt("Entrez votre age svp : ") ;
validate (age) ;
System.out.println("Suite du programme ...") ;
}

private static void validate (int age) {

if (age < 18) {
System.out.println("[NOK] Vous êtes mineur donc non éligible.");
} else {
System.out.println ("[OK] Vous êtes éligible ! Bonne chance !");
}
}
}

7. Sans traiter l’exception, relancez le programme et entrez une information erronée (age < 18),
le programme crash comme le montre la figure ci-dessous.

8. Modifiez le code source de sorte à capturer l’erreur avant que le crash ne se produise puis
relancez le programme et entrez la même valeur pour l’âge. Cette fois, il n’y a pas de crash.
L’erreur est détectée, capturée et traitée convenablement. Le programme se poursuit
normalement comme le montre la figure ci-dessous en exemple.

9. On souhaite capturer et traiter convenablement les deux erreurs susceptibles de se produire :

- L’erreur déclenchée lors de la saisie d’une information du type différent de int.

- L’erreur déclenchée lors de la saisie d’un âge < 18.

Proposer une solution basée sur le « multi catch » pour effectuer la modification. Testez et
assurez-vous que tout se passe correctement.

10. Créer un nouveau projet Java intitulé « 007-exceptions-naturels »

11. Implémenter une classe « EntierNaturel » permettant de manipuler des entiers naturels
(positifs ou nuls uniquement). Pour l’instant, cette classe disposera simplement :

- d’un constructeur à un argument de type int qui générera une exception de type
« ConstructorException » (classe d’exception contrôlée personnalisée) lorsque la
valeur reçue ne convient pas.

Page | 9
 - Cette classe devra disposer d’un attribut d’instance de type int qui recevra la valeur
fournie à tort au moment de la construction de l’objet et du message d’erreur
approprié.

12. Écrire un petit programme d’utilisation « EntierNaturelRun » qui tente d’instancier un

« EntierNaturel » et de l’afficher. Quelle est la réaction du compilateur lors de l’invocation
du constructeur ? pourquoi ? Choisissez la meilleure approche pour traiter le problème qu’il
vous signale.

13. Adapter la classe « EntierNaturel » pour qu’elle dispose des méthodes statiques permettant
de réaliser les opérations suivantes sur deux « EntierNaturel » : « addition »,
« soustraction » et « multiplication ».

14. Elles généreront respectivement des exceptions contrôlées « AdditionException »,

« SoustractionException » et « MultiplicationException » lorsque le résultat ne sera pas
représentable ; la limite des valeurs des naturels sera fixée à la plus grande valeur du type int
(Integer.MAX). Par exemple :

- Si le résultat de la somme de deux entiers naturels est supérieur à la constante

Integer.MAX alors une exception de type « AdditionException » est déclenchée.

- Si le résultat de la multiplication de deux entiers naturels est supérieur à la constante

Integer.MAX alors une exception de type « MultiplicationException » est déclenchée.

- Si le résultat de la différence de deux entiers naturels est inférieur à 0 alors une

exception de type « DifférenceException » est déclenchée.

15. Effectuer les différentes opérations sur des entiers naturels quelconques dans le main et
analyser les résultats. Essayer de déclencher les différents types d’exception pour vous
assurer que votre programme est conforme.

Vous avez terminé ! Vous êtes prêt pour le TP suivant.

Page | 10