Université Moulay ismail 2022/2023

ENSAM-Meknèes 3ème année

TD_TP 6
Collections
1. Modéliser un étudiant
La classe Etudiant possède trois attributs privés :
• son nom, nommé nom, de type String,
• un ensemble de notes, nommé listeNotes, qui sont des entiers rangés dans un ArrayList<Integer>
• une moyenne de type double, nommée moyenne, qui doit toujours être égale à la moyenne des notes
contenues dans l'attribut listeNotes. Un étudiant sans aucune note sera considéré comme ayant une
moyenne nulle.
La classe Etudiant possède un constructeur permettant uniquement d'initialiser le nom de l’étudiant.
La classe Etudiant possède aussi cinq méthodes publiques :
• Un getter pour la moyenne de l'étudiant c'est-à-dire une méthode d'en-tête
public double getMoyenne() renvoie la valeur de l'attribut moyenne ;
• Un getter pour le nom de l'étudiant c'est-à-dire une méthode d'en-tête
public String getNom()renvoie le nom de l’étudiant;
• Un getter pour la liste des notes de l'étudiant c'est-à-dire une méthode d'en-tête
public ArrayList<Integer> getListeNotes() renvoie la liste des notes de l'étudiant ;
• La méthode d'en-tête public void ajouterNote(int note) ajoute la note reçue en paramètre
à listeNotes ; si la note reçue en paramètre est négative, la note introduite est 0 ; si la note reçue en
paramètre est supérieure à 20, la note introduite est 20 ; la méthode actualise en conséquence
l'attribut moyenne ; l'actualisation est faite à temps constant, et non pas en un temps proportionnel
au nombre de notes déjà enregistrées.
• La méthode d'en-tête public String toString() qui retourne une description de l'étudiant considéré
(par exemple : "Sophie (12.25)").
Indication : si note est une variable de type int, l'instruction :
listeNotes.add(note); ajoute un Integer contenant la valeur note à listeNotes.
Après avoir terminé la classe Etudiant, écrire un programme qui teste cette classe.
Indication (détail) : si la méthode toString décrite ci-dessus a été définie dans la classe Etudiant,
si etud est un objet de type Etudiant, l'instruction :System.out.println(etud);
est équivalente à l'instruction : System.out.println(etud.toString());
2. Modéliser un étudiant comparable à un autre
Il s'agit ici de compléter la classe Etudiant pour faire en sorte d'avoir une classe qui implémente
l'interface java.lang.Comparable<T>. C'est une interface générique, comme l'indique le <T> mais il n'y a
pas grand-chose à savoir sur le sujet pour l'utiliser. Il faudra, en implémentant l'interface, indiquer à la
place du T le type des objets qu'on veut comparer entre eux.
L'interface Comparable<T> déclare une seule méthode :
public int compareTo(T o);
Quand cette méthode est implémentée, elle doit retourner une valeur strictement négative, nulle ou
strictement positive selon que l'objet concerné (celui qui correspond à la référence this) est plus petit que
l'objet o, égal à l'objet o ou plus grand que l'objet o.
On comparera les étudiants selon leur moyenne (ou, si vous préférez, selon l'ordre alphabétique). Pour
cela, vous allez reprendre la classe Etudiant écrite précédemment pour la transformer en une classe qui
implémente l'interface java.lang.Comparable<T>.

Programmation Orientée Objet JAVA 1 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
Il faudra pour cela compléter l'en-tête de la classe Etudiant par "implements Comparable<Etudiant>".
Il faudra de plus définir la méthode compareTo déclarée par l'interface Comparable. Cette méthode
est à nouveau générique ; si la classe implémente Comparable<Etudiant>, le paramètre de la méthode
doit être de type Etudiant, l'en-tête est donc :
public int compareTo(Etudiant autreEtudiant)
Le code de la méthode doit respecter la fonctionnalité décrite plus haut.
Après avoir ainsi complété la classe Etudiant, modifiez aussi la méthode main de la
classe TestEtudiant pour tester la méthode compareTo.
3. Modéliser un groupe d'étudiants
Un groupe d'Etudiant(s) sera modélisé par la classe GroupeEtudiant la façon suivante.
La classe GroupeEtudiants posséde un attribut privé : une collection d'Etudiant(s)
nommée listeEtudiants, de type ArrayList<Etudiant>.
La classe GroupeEtudiants ne possède pas de constructeur explicite.
La classe GroupeEtudiant possède aussi cinq méthodes publiques :
• La méthode d'en-tête public int nombre() renvoie le nombre d'Etudiant(s) contenus
dans listeEtudiants ;
• La méthode d'en-tête public ArrayList<Etudiant> getListe() renvoie listeEtudiants.
• La méthode d'en-tête public void ajouterEtudiant(Etudiant etud) ajoute l'Etudiant reçu en
paramètre à listeEtudiants.
• La méthode d'en-tête public Etudiant chercher(String nom)
renvoie l'Etudiant dont le nom est indiqué par le paramètre ; si plusieurs Etudiant(s) ont même nom,
la méthode renvoie le premier Etudiant ayant ce nom contenu dans listeEtudiant; si aucun Etudiant
n'a le nom indiqué, la méthode retourne null . On pourra utiliser la méthode equals de la
classe String pour comparer une chaîne de caractères à une autre.
• La méthode d'en-tête public void lister() écrit à l'écran la liste des Etudiant(s). Elle utilise une ligne
par Etudiant; elle utilise la méthode toString de la classe Etudiant.
Après avoir terminé la classe GroupeEtudiant, écrire un programme qui teste cette classe.

On veut modifier la classe TestGroupeEtudiant de telle manière à créer une interactivité entre
l’utilisateur et l’application. En effet, Le programme laisse le choix à l’utilisateur de saisir de nouveaux
étudiants ou d’afficher ceux effectivement saisis (utiliser la boucle do …while). L’exécution de cette
application a pour résultat à l’écran :

Programmation Orientée Objet JAVA 2 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année

--------------Menu -----------------
1. Ajoute un étudiant Votre choix : 1
2. Affiche la classe Entrer le nom de l’etudiant : Philippe
3. Pour sortir Entrer le prenom de l’etudiant :T.
Votre choix : 2 Combien de notes pour l’etudiant
2 Philippe T. : 2
Il n’y a pas d’etudiant dans cette liste Entrer la note n° 1 : 12
--------------Menu ----------------- Entrer la note n° 2 : 8
1. Ajoute un etudiant --------------Menu -----------------
2. Affiche la classe 1. Ajoute un etudiant
3. Pour sortir 2. Affiche la classe
Votre choix : 1 3. Pour sortir
Entrer le nom de l’etudiant : M. Votre choix : 2
Entrer le prenom de l’etudiant : Sandra Les notes de Sandra M. sont : 15.0 13.0
Combien de notes pour l’etudiant Sa moyenne vaut 14.0
Sandra M. : 2 Les notes de Philippe T. sont : 12.0 8.0
Entrer la note n° 1 : 15 Sa moyenne vaut 10.0
Entrer la note n° 2 : 13 --------------Menu -----------------
--------------Menu ----------------- 1. Ajoute un etudiant
1. Ajoute un etudiant 2. Affiche la classe
2. Affiche la classe 3. Pour sortir
3. Pour sortir Votre choix : 3
• Créer une classe Fichier composée d’outils simplifiant la manipulation des fichiers en lecture et en
écriture. Les données de cette classe définissent deux objets de type BufferedWriter et
BufferedReader et d’une variable de type char, qui mémorise le mode de traitement utilisé (lecture
ou écriture). D’une façon générale, les traitements sur fichiers se déroulent en trois temps :
o ouverture du flux,
o puis traitement des données parcourant le flux et, pour finir,
o fermeture du flux.
• Pour écrire ou lire dans un fichier, il nécessaire, avant tout, d’ouvrir le flux en indiquant si ce flux est
entrant (lecture) ou sortant (écriture). Ajouter dans la classe Fichier la méthode ouvrir(String
nomDuFichier, char s) qui réalise cette opération.
• Ajouter la méthode void ecrire(string chaine) qui prend en paramètre la valeur à enregistrer dans le
fichier.
• Ajouter la méthode String lire() qui permet la lecture dans un fichier.
• Suivant le mode d’ouverture spécifié par la variable d’instance mode (initialisée lors de l’exécution de
la méthode ouvrir()), le flux (lecture ou écriture) est fermé grâce à la méthode close().Ajouter la
méthode void fermer() qui permet la lecture dans un fichier.
• Tester cette classe sur des données simple(chaine de caractère par exemple).

Programmation Orientée Objet JAVA 3 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
La sérialisation des objets
Un objet est sérialisé afin de pouvoir être transporté sur un flux de fichier, entrant ou sortant. Grâce
à cette technique, un objet peut être directement stocké dans un fichier (écriture) ou reconstruit à
l’identique en mémoire vive par lecture du fichier. Les mécanismes de sérialisation-désérialisation sont
fournis par l’intermédiaire des classes ObjectOutputStream et ObjectInputStream, grâce aux méthodes
writeObject() (sérialisation) et readObject() (désérialisation). Ces outils sont applicables à tous les objets
prédéfinis du langage Java, tels que les String,les vecteurs (Vector) ou encore les dictionnaires (Hashtable).
Lorsque vous souhaitez sérialiser un objet dont le type est défini par le programmeur, il est nécessaire
de rendre cet objet sérialisable. Pour cela, il suffit d’indiquer au compilateur que la classe autorise la
sérialisation, en utilisant la syntaxe suivante :
public class Exemple implements Serializable {
// Données et
// méthodes
}
De cette façon, tous les objets déclarés de type Exemple peuvent être lus ou écrits dans des fichiers
d’objets. Remarquez que l’objectif de la sérialisation est de placer, dans un flux, toutes les informations
relatives à un objet. Par conséquent, seules les variables d’instance sont prises en compte lors d’une
sérialisation, alors que les variables de classes (définies en static) ne peuvent être sérialisées. En effet, une
variable de classe est commune à tous les objets de l’application et non pas spécifique d’un seul objet.
Archiver un Groupe d’étudiants
Pour bien comprendre comment utiliser ces outils d’archivage d’objets, modifions l’application
TestGroupeEtudiant de sorte qu’elle puisse lire et stocker automatiquement l’ensemble des données du
GroupeEtudiant dans un fichier, portant le nom de Classe.dat.
Nous devons tout d’abord rendre sérialisable les objets que nous souhaitons sauvegarder. C’est pourquoi
il convient de modifier les en-têtes des classes
Etudiant et GroupeEtudiant de la façon suivante :
public class Etudiant implements Serializable {
}
public class GroupeEtudiant implements Serializable {
}
À défaut, vous obtenez une erreur d’exécution du type NotSerializableException, indiquant que l’objet
de type Etudiant ou Classe ne peut être sérialisé. Ensuite, les opérations d’archivage d’objets utilisent les
mêmes concepts que ceux décrits à la section précédente, à savoir ouverture du fichier, puis lecture ou
écriture des objets et, pour finir, fermeture du fichier. C’est pourquoi nous allons modifier la classe Fichier
pour y manipuler, non plus des fichiers textes, mais des fichiers d’objets. Les données de la classe
FichierEtudiant sont deux objets représentant des flux d’écriture (ofW), de lecture (ofR) d’objets, ainsi
qu’un caractère (mode) représentant le type d’ouverture du fichier et une chaîne de caractères
(nomDuFichier), où se trouve mémorisé le nom de fichier de sauvegarde des données (Classe.dat).

public class FichierEtudiant {

private ObjectOutputStream ofW;
Programmation Orientée Objet JAVA 4 B.BAKKAS
Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
private ObjectInputStream ofR;
private String nomDuFichier = "Classe.dat";
private char mode;
}
• Ajouter la méthode public void ouvrir(char s) qui permet l’ouverture du fichier Classe.dat en lecture
est réalisée grâce aux constructeurs des classes FileInputStream et ObjectInputStream, alors que
l’ouverture en écriture est effectuée par les constructeurs ObjectOutputStream() et
FileOutputStream().
• L’objectif est d’archiver l’ensemble des données relatives à une classe d’étudiants. La méthode
ecrire() prend en paramètre un objet tmp de type GroupeEtudiant, de sorte que l’information lui soit
transmise depuis l’application TestGroupeEtudiant. L’objet transmis est alors archivé grâce à la
méthode writeObject(tmp). Ajouter la méthode ecrire () dans la clasee FichierEtudiant.
• Inversement, la méthode lire() lit l’objet stocké dans le fichier Classe.dat et le transmet en retour à
l’application GestionClasse sous forme d’objet de type Classe. L’en-tête de la méthode a pour type
le type Classe. L’objet retourné est lu grâce à la méthode readObject(). Ajouter la méthode lire ()
dans la clasee FichierEtudiant.

Comme il s’agit d’un entier et que le fichier est un fichier texte, la valeur stockée dans tmp est convertie
en String grâce à l’instruction chaine = chaine.valueOf(tmp) . Ensuite, l’écriture de cette chaîne dans le
fichier est réalisée par l’instruction fW.write(chaine, 0, chaine.length()). La méthode write() envoie dans
le flux fW la chaîne spécifiée en premier paramètre. Les deuxième et troisième paramètres précisent
respectivement à partir de quel caractère (0) commence l’écriture dans le fichier et combien de caractères
(chaine.length) sont écrits. Pour notre exemple, l’intégralité de la chaine est écrite dans le fichier.

public class GestionClasse {

public static void main(String [] argument) {
byte choix = 0 ;
Classe C = new Classe();
do {
System.out.println("1. Ajoute un etudiant");
System.out.println("2. Affiche la classe");
System.out.println("3. Pour sortir");
System.out.print("Votre choix : ");
choix = Lire.b();
switch (choix) {
case 1 : C.ajouteUnEtudiant();
break;
case 2 : C.afficheLesEtudiants();
break;
case 3 : System.exit(0);
default : System.out.println("Cette option n’existe pas ");
}
} while (choix != 3);
}
}

Gestion des modules entre les formateurs

Programmation Orientée Objet JAVA 5 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
On souhaite gérer la répartition des modules entre les formateurs d’un institut de formation
professionnelle.
Soit la classe Module qui modélise un module et qui comportera les attributs suivants :
• reference
• intitule
• formateur (matricule du formateur qui enseigne ce module)
Soit la classe qui modélise un Formateur et comportera les attributs suivants :
• matricule
• nom
• prenom
• echelle
• lisetemodule.
Classe Module
1. Ecrire la classe Module avec un compteur des objets crées.
2. Ajouter une méthode choixEnseignant qui désigne l’enseignant d’un module.
3. Ecrire une méthode toString affichant l’état du module.
4. Ajouter les setters et les getters nécessaires.
Classe Formateur
1. Ecrire la classe Formateur avec un compteur des objets crées.
2. Ajouter la méthode compare qui teste l’égalité de 2 objets Formateur (2 objets sont égaux
s’ils ont le même matricule).
3. Créer une exception nommée ErreurEchelle qui se déclenche lors de la saisie d’une échelle
de formateur qui n’est pas comprise entre 1 et 20.
4. Ajouter une méthode supprimerFormateur qui annule le choix de l’enseignant d’un module.
5. Ajouter une méthode ajouterModule qui ajoute un module à la liste des modules pris en
charge par un formateur.
6. Ajouter une méthode supprimerFormateur qui supprime un module à la liste des modules
d’un formateur.
7. Ecrire une méthode toString affichant l’état du formateur.
8. Ajouter les setters et les getters nécessaires.
9. Ecrire un programme de test qui crée 4 formateurs et 5 modules.

Programmation Orientée Objet JAVA 6 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
Gestion du Personnel
Une entreprise souhaite informatiser la gestion de son personnel qui est constitué principalement de
cadres et des techniciens.
1. Classe Personnel
Un membre du personnel est représenté par son code CIN (chaine de caractère), son nom, son
prénom et son age. L’ensemble de ces informations constituera la classe Personnel.
Une variable de classe permettra de compter le nombre de personnels inscrits dans la base de
l’entreprise.
Le CIN sera constitué de la valeur du compteur à l’instant de la création du Personnel suivi de son
âge.
On veut pouvoir afficher les informations d’un personnel à l’aide de la méthode String toString().
Une méthode void incrementer() permettra d’incrémenter l’âge d’un personnel.
Une méthode int calculSalaire() permettra de calculer le salaire d’un personnel et de renvoyer cette
somme (nombre entier). Le salaire ne sera défini que dans les classes dérivées (voir suite du sujet).
1. Que peut-on dire de la méthode calculSalaire() ? Que peut-on en déduire de la classe
Personnel ?
2. Définir la classe Personnel et décrire toutes les méthodes définies ci-dessus.
3. Ecrire 2 constructeurs différents : un par défaut et un avec paramètres.
2. Classe Cadre
Un cadre est un membre du personnel auquel on ajoute la notion d’ancienneté (nombre entier),
correspondant au nombre d’années passées dans la société. L’ensemble de ces informations
constituera la classe Cadre.
La méthode void incrementer() doit incrémenter l’age et l’ancienneté du personnel.
Le salaire d’un cadre est calculé à partir d’une base de 10000Dhs à laquelle s’ajoute un pourcentage
proportionnel à l’ancienneté :
❖ pour une ancienneté inférieure à 5 ans : un pourcentage égal à 2 fois l’ancienneté
❖ pour une ancienneté supérieure ou égale à 5 ans : un pourcentage égal à 5 fois l’ancienneté
La méthode String toString() doit renvoyer les mêmes informations que précédemment mais en
ajoutant l’ancienneté et le salaire annuel perçu par ce salarié.
4. Quel lien existe-t-il entre la classe Personnel et la classe Cadre ?
5. Peut-on créer des objets de type Cadre ? Que peut-on en conclure de la classe Cadre ?
6. Définir la classe Cadre et décrire toutes les méthodes définies ci-dessus.
3. Classe Technicien
Un technicien est un membre du personnel auquel on ajoute le nombre de pannes qu’il a réparé au
cours du mois (nombre entier). L’ensemble de ces informations constituera la classe Technicien.
La méthode void incPannes() doit incrémenter le nombre de pannes traitées par le technicien.
Le salaire d’un technicien est calculé à partir d’une base de 5000 Dhs auquel s’ajoute une prime
proportionnelle au nombre de pannes traitées :
❖ pour un nombre inférieur à 50 : 20 Dhs par panne
❖ au delà des 50 pannes : 30 Dhs par panne

Programmation Orientée Objet JAVA 7 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
La méthode String toString() doit renvoyer les mêmes informations que précédemment mais en
ajoutant le nombre de pannes et le salaire annuel perçu par ce salarié.
7. Définir la classe Technicien et décrire toutes les méthodes définies ci-dessus.
4. Classe Société
La société comporte un certain nombre de personnels : cadres ou techniciens. L’ensemble est géré
dans la même classe nommée Societe.
La méthode void ajoutPersonnel(Personnel p) permet d’ajouter un personnel à la liste, qu’il soit
cadre ou technicien.
La méthode int paie() doit retourner la somme de tous les salaires annuels versés par la société à
ces cadres et ces techniciens.
La méthode String toString() doit afficher l’ensemble des salariés de la société et afficher la somme
de tous les salaires annuels.
8. De quelle manière peut-on stocker l’ensemble des personnels de cette société ?
9. Définir la classe Societe et décrire toutes les méthodes définies ci-dessus.
10. Ecrire une classe TesteGestionPersonnel qui permet de tester les différentes classes

Programmation Orientée Objet JAVA 8 B.BAKKAS

Université Moulay ismail 2022/2023
ENSAM-Meknèes 3ème année
Gestion d’exceptions
Exercice 1:
Que produit le programme suivant lorsqu’on lui fournit en donnée a :
➢ la valeur 0,
➢ la valeur 1,
➢ la valeur 2.
class Except extends Exception{ System.out.println ("suite du programme") ;
public Except (int n) { try {
this.n = n ; } System.out.println ("debut second bloc
public int n ; try") ;
} if (n!=1) throw new Except (n) ;
public class Chemin{ System.out.println ("fin second bloc try") ;
public static void main (String args[]) }
{ int n ; catch (Except e){
System.out.print ("donnez un entier : ") ; System.out.println ("catch 2 - n = " + e.n) ;
n = Clavier.lireInt() ; System.exit(-1) ;
try{ }
System.out.println ("debut premier bloc System.out.println ("fin programme") ;
try") ; }
if (n!=0) throw new Except (n) ; }
System.out.println ("fin premier bloc try") ;
}
catch (Except e){
System.out.println ("catch 1 - n = " + e.n);
}

Exercice 2:
1. Créer une classe d’exception PasDefini qui représente des erreurs.
2. Créer une classe Factorielle qui contient une méthode qui calcule le factoriel d’un entier
positive donné en paramètre. Cette méthode lance une exception PasDefini lorsque l’entier
est négatif.
3. Traiter l’exception dans le programme TestFactorielle.
Exercice 3:

1. Réaliser une classe EntNat permettant de manipuler des entiers naturels (positifs ou
nuls).Pour l’instant, cette classe disposera simplement :

➢ d’un constructeur à un argument de type int qui générera une exception de type ErrConst
(type classe à définir) lorsque la valeur reçue ne conviendra pas,
➢ d’une méthode getN fournissant sous forme d’un int, la valeur encapsulée dans un objet de
type EntNat.

2. Écrire un petit programme d’utilisation qui traite l’exception ErrConst en affichant un

message et en interrompant l’exécution.
3. Adapter la classe EntNat de la question 1 et le programme d’utilisation de manière à
disposer dans le gestionnaire d’exception du type ErrConst de la valeur fournie à tort au
constructeur.

Programmation Orientée Objet JAVA 9 B.BAKKAS