Liste des travaux dirigés

TD 1 Introduction au langage Java

Exercice 1
Ecrire un programme Java qui permet de créer une méthode calculer pour calculer le résultat de la
puissance d'un entier a par celui de b.

Exercice 2
Ecrire un programme Java qui permet de créer une méthode calculer pour calculer les impôts pour
un salarié, cette méthode admet deus paramètres, taux et salaire brut.

Exercice 3
Ecrire un programme Java qui permet de créer les méthodes suivantes:
 saisir une valeur entière,
 échanger deux valeurs données en paramètres,
 créer deux objets dans main et tester les méthodes saisir et échanger.

Exercice 4
Ecrire un programme java qui permet de créer les méthodes suivantes:
 saisir qui demande à l'utilisateur de saisir un entier pour la taille d'un tableau,
 remplir qui permet de créer un tableau d'entiers et saisir ses valeurs,
 afficher la moyenne des valeurs fournis, ainsi que la plus petite et la plus grande de ces valeurs.

Exercice 5
Ecrire un programme java permettant de saisir un tableau de notes pour déterminer le nb d’élèves
d’une classe ayant une note supérieure à la moyenne de la classe. On propose de créer les méthodes
suivantes:
 saisir le nombre d'élèves,
 saisir un tableau de notes,
 moyenne pour déterminer la moyenne des notes saisies,
 afficher pour afficher le nb d’élèves d’une classe ayant une note supérieure à la moyenne de la
classe.

Exercice 6
Ecrire un programme Hjms.java en langage JAVA qui pour un nombre de secondes donné en
paramètre, calcule et affiche son équivalent en nombre de jours, d'heures, de minutes et de
secondes.
Exemples d'exécution du programme :
C:\JAVA\TP2>java Hjms 3621
cette durée équivaut à 0 jours 1 heures 0 minutes 21
secondes
C:\JAVA\TP2>java Hjms 567231
cette durée équivaut à 6 jours 13 heures 33 minutes et
51 secondes
C:\JAVA\TP2>
TD 2 les classes simples

Exercice 1
Ecrire un programme qui manipule des lignes de commandes. Toutes les lignes de commandes sont
construites sur le même moule, à savoir une ligne de commande est composée de la référence à un
produit, son intitulé, son prix unitaire, la quantité commandée et son prix total. Ces caractéristiques
seront donc réunies dans une classe.

Les attributs de la classe LigneCommande sont :

-refArticle : String
-nomArticle : String
-prixUnitaire : double
- quantite : int

Les méthodes de la classe LigneCommande sont:

- un constructeur avec des paramètres,
- une méthode getRefArticle() qui retourne la référence de l'article.
- une méthode setRefArticle() qui affecte une nouvelle valeur à la référence article.
- une méthode calculerMontant() qui calcule et retourne le montant de la ligne commande.
- une méthode afficher() qui affiche les caractéristiques de la ligne de commande.
- une méthode afficherMontant() qui affiche le montant de la ligne de commande.

Travail demandé
1. Ecrire le code JAVA de la classe LigneCommande en respectant scrupuleusement les
spécifications données ci-dessus.
2. Ecrire un programme simple de test pour la classe LigneCommande.
Ce programme doit :
- declarer une instance de la classe LigneCommande, initialisée avec les valeurs suivantes :
refArticle :"1234", nomArticle : "Parapluie aluminium", prixUnitaire: 6.250, quantite:8
- modifier refArticle par la valeur "4321".
- afficher la refArticle.
- afficher la ligne de commande.
- calculer et afficher le montant de la commande.

Exercice 2
Le but de cet exercice est d´écrire un programme JAVA pour aider à la gestion de la billetterie des
différentes salles d'un complexe cinématographique. Les places non numérotées sont vendues selon
deux tarifs :
 un tarif "normal" qui est fixé en fonction de la salle et du film qui y est joué,
 un tarif réduit (familles nombreuses, militaires, chômeurs, étudiants) qui correspond à 80%
du tarif normal.
Après analyse du problème, il est décidé de représenter les salles de cinéma par des objets JAVA
instances d'une classe SalleCinema définie comme suit :
Les informations caractérisant un objet SalleCinema sont :
 une chaîne de caractères qui contient le titre du film joué,
 un entier qui contient le nombre de places de la salle,
  un réel qui contient le prix unitaire d'une place à tarif normal,
 un entier qui contient le nombre de places qui ont été vendues à tarif normal,
 un entier qui contient le nombre de places qui ont été vendues à tarif réduit.
Les valeurs des trois premières caractéristiques (titre du film, nombre de place, prix de la place)
sont fixées lors de la création d'un nouvel objet SalleCinema (c'est-à-dire, sont passées en
paramètres du constructeur). Quand aux deux autres variables (nombre de places vendues à tarif
normal et nombre de places vendues à tarif réduit) elles sont bien sur initialisées à 0.
La classe SalleCinema possède les méthodes suivantes :
 public int nbPlacesDisponibles()
 calcule et renvoie le nombre de places encore disponibles dans la salle.
 public setNbPlacesVenduesTR(int n)
 affecte n au nombre de places vendues à tarif réduit.
 public setNbPlacesVenduesTN(int n)
 affecte n au nombre de places vendues à tarif normal.
 public double chiffreAffaires()
 retourne le chiffre d'affaires produit par la salle pour la séance en cours (total des
ventes depuis la création de l'objet salle ou la dernière remise à zero du nombre de
places vendues).
 public double tauxRemplissage()
 retourne le taux (pourcentage) de remplissage de la salle.
 public String afficher()
 affiche tous les attributs de la classe SalleCinema, suivant ce
modèle:
Film joué : Sacré Graal ,
Nombre de places : 60 ,
Prix d'une place : 7.500 DT,
20 places vendues au tarif normal ,
14 places vendues au tarif réduit.
Travail demandé
1- Ecrire le code JAVA de la classe SalleCinema en respectant scrupuleusement les
spécifications données ci-dessus.
2- Ecrire un programme simple de test pour la classe SalleCinema.
Ce programme doit :
- créer deux salles correspondant aux informations définies dans la table ci-dessous.
- modifier les attributs (nbPlacesTN, nbPlaceTR) pour le 1ier film par les valeurs (110,10).
- modifier les attributs (nbPlacesTN, nbPlaceTR) pour le 2ième film par les valeurs (35,5).
- afficher les attributs des deux salles.
- afficher le nombre de places encore disponibles et le chiffre d'affaire produit pour chaque
salle.
Titre Nombre de Places Normales Prix de la place (tarif normal)
Chat Blanc, Chat Noir 120 8,5 DT
La vie est belle 50 7.5 DT
TD 3 Tableaux et attributs statiques

Exercice 1
Dans cette étude de cas il s'agit de gérer les étudiants d'une classe. Il faut pour cela former deux
classes d'objets : une classe Etudiant et une deuxième classe qui s'appelle Classe.

La classe Etudiant admet les attributs suivants:

matricule : c'est un entier auto-incrementé
nom : chaine
prenom : chaine
notes : un tableau de 3 réels
autoIncrement : entier (static) initialisé à 1 et incrémenté à chaque création d'un nouveau objet du
type Etudiant(partagé par tous les objets de cette classe).

La classe Etudiant admet les méthodes suivantes:

 un constructeur avec paramètres : nom,prenom et 3 notes.
 Une méthode calculerMoyenne()qui calcule et retourne la moyenne d'un étudiant suivant la
formule 0.25*n1+0.3*n2+0.45*n3.
 Une méthode afficher() qui affiche les informations de l'étudiant et sa moyenne.

Une classe est formée d'un ensemble d'étudiant dont le nombre ne doit pas dépasser un nombre
d'étudiant maximum fixé à 30.
La classe Classe contiendra les attributs suivants:
 nombre d'étudiant de la classe:entier (initialisé à 0).
 Nombre d'étudiant Max : entier (static et constant).
 Un tableau d'étudiants
Les méthodes pour Classe seront:
 un constructeur sans paramètres.
 Une méthode ajouterEtudiant(Etudiant e): qui ajoute l'étudiant donné en paramètre au premier
élément libre du tableau d'étudiants, et incrémente le nombre d'étudiants de la classe.
 Une méthode afficherClasse(): qui fait appel à la méthode afficher() de la classe Etudiant pour
afficher les étudiants d'une classe.

Ecrire un programme de test pour :

3. créer deux instances de la classe Etudiants suivants les exemples si-dessous :
e1("ben ali","Mohamed",15.5f,12,10)
e2("ben sal","ali",15f,12.5f,19.5f)
4. créer une instance de Classe et lui affecter les deux étudiants.
5. Afficher la liste des étudiants de la classe suivant ce format :

Les étudiants de cette classe sont :

Matricule Nom Prenom Moyenne
1 ben ali Mohamed 11.975
2 ben salah ali 16.275

Exercice 2
Dans cet exercice, il s'agit de concevoir une application java qui permet de gérer un carnet
d'adresses. En effet les éléments enregistrés dans le carnet d'adresse sont :
Les attributs qui caractérisent la classe
  Le nom: String
 Le prénom: String
 L'adresse : String
 Le numéro de téléphone : long
Les méthodes de la classe Personne
 Personne(...):un constructeur avec quatre paramètres
 Les méthodes getter/setter pour les deux attributs adresse et numéro de téléphone
 void afficher():une méthode qui affiche les caractéristiques d'une personne.
La classe CarnetAdresse possède les attributs suivants:
 Un tableau de Personne (carnet)
 Le nombre Maximum de Personne que peut contenir le carnet d'adresses
(NB_PERS_MAX=100)
 Le nombre courant de Personne enregistrées dans le carnet d'adresses.
Les méthodes de la classe CarnetAdresse
 Un constructeur sans paramètres.
 Une méthode public void ajouter(Personne p): qui ajoute un Personne donnée en
paramètre au tableau si la capacité du carnet le permet.
 Une méthode public boolean chercher (Personne p): qui retourne vrai si la personne
donnée en paramètre existe dans le tableau et faux si non.
 Une méthode public void supprimer (Personne p): qui supprime une personne du tableau.
 Une méthode public void afficher () : qui fait appel à la méthode afficher() de la classe
Personne pour afficher les personnes contenues dans le carnet d'adresses.

Travail Demandé
1. Ecrire le code de la classe Personne
2. Ecrire le code de la classe CarnetAdresse
3. Ecrire une classe de test qui permet de :
 créer deux instances de la classe Personne
 ajouter ces instances dans le carnet d'adresse
 supprimer la première personne créée
 afficher le carnet d'adresses

Exercice 3
On vous propose d'écrire la classe Article qui représente un article de magasin identifié par :
Les attributs de la classe Article :
 un nom sous forme de chaine de caractères,
 un prix (flottant),
 un identifiant code-barre (entier de 13 chiffres),
 une description de l'objet sous forme de chaine de caractères qui est optionnelle.

Les méthodes de la classe Article :

 un constructeur avec paramètres qui initialise tous les attributs,
 un constructeur avec paramètres qui initialise tous les attributs sauf la description (null),
 les méthodes getter/setter pour les attribut code-barre et description,
 la méthode public double getPrice(); qui renvoie simplement le prix de l'article
 la méthode public double getPrice (int quantité); qui renvoie le prix total (quantité*prix),
réduit de 5% si la quantité est supérieure à 10,
  la méthode public void afficher() qui affiche les valeurs des attributs de la classe Article.

Un magasin est un ensemble d'articles, dont le nombre est limité par la capacité maximale du
magasin.

La classe Magasin est décrite par l’attribut un vecteur "listeArticle" pour y classer les articles et
une constante pour la capacité maximale du magasin.
Les méthodes pour la classe Magasin seront:
 un constructeur sans paramètres.
 Une méthode public void ajouterArticle(Article e): qui ajoute un Article donné en
paramètre au vecteur si la capacité du magasin le permet.
 Une méthode public boolean chercherArticle(Article e): qui retourne vrai si l'article
donné en paramètre existe dans le vecteur et faux si non.
 Une méthode public void supprimerArticle(Article a): qui supprime un article du vecteur.
 Une méthode public void afficherMagasin(): qui fait appel à la méthode afficher() de la
classe Article pour afficher les articles du magasin.

Travail Demandé
1. Ecrire le code de la classe Article
2. Ecrire le code de la classe Magasin
3. Compléter la classe de test TestMagasin pour appeler toutes les méthodes de la classe Magasin.

public class TestMagasin{

public static void main (String[] args)
{
Article a1 = new Article ("Coca Cola", "Une bouteille de Coca", 5483918746744L, 1.500);
Article a2 = new Article ("Jus de fraise", 5473664615361L, 2.300);
Article a3 = new Article ("Biscuit", 5473664615881L, 0.850);
a3.setDescription("Paquet de 24");..........
}}
TD 4 Héritage et Polymorphisme

Exercice 1
Une application de gestion de bibliothèque doit manipuler des documents de natures disparates, par
exemple des livres et des dictionnaires. Tous les documents ont un titre. Les autres attributs varient
selon la catégorie du document : un livre possède un auteur et un nombre de pages, un dictionnaire
est caractérisé par le nombre de définitions de mots qu’il contient. Bien que de natures diverses, les
documents doivent pouvoir être manipulés de façon homogène en tant que simples documents, par
exemple pour en constituer des listes. On définit pour cela les classes Document, Livre et
Dictionnaire.
1 - Programmer ces classes.
2 - Indiquer les erreurs de syntaxe dans les lignes du programme suivant :
class TestBibli {
public static void main(String argv[]) {
Livre pereGoriot = new Livre(...);
Document doc; Livre livre;
doc = pereGoriot;
System.out.println(doc.titre);
System.out.println(doc.auteur);
livre = doc;
}}

3 - On dispose de la classe Bibliothèque qui permet de regrouper une liste de documents et de la

parcourir. Implémenter cette classe.

4- Rédiger la partie manquante du programme suivant qui doit compter le nombre de livres et le
nombre de dictionnaires présents dans la bibliothèque.
class TestdeClasse {
public static void main(String argv[]) {
ListDocuments bibli= new ListDocuments();
bibli.ajoute(new Livre("Le pere Goriot", "Balzac", 458));
bibli.ajoute( new Livre("Nounours", "Chantal Goya", 14));
bibli.ajoute( new Dictionnaire("Larousse", 4500));
bibli.ajoute( new Livre("Tintin", "Herge", 62));
bibli.ajoute( new Dictionnaire("Petit Robert", 5000));
int nbLivres=0; int nbDicos=0;
...
System.out.println("nombre de livres = "+nbLivres);
System.out.println("nombre de dictionnaires = "+nbDicos); }}

Exercice 2
1- Classe Ville
Écrire une classe Ville suivant les spécifications suivantes :
 Une Ville est définie par deux caractéristiques: un nom et un nombre d'habitants.
 Le nom de la ville est obligatoire lors de la construction d'une Ville. Ce nom ne peut pas
changer.
 La connaissance du nombre d'habitants est optionnelle lors de la construction d'une Ville
(valeur par défaut = 0). Ce nombre peut être modifié après la construction.
  Si nous essayons de construire une Ville sans paramètres, le programme doit afficher un
message d'erreur puis se terminer (Pensez à utiliser la méthode exit(code) de la classe
System).
 Une Ville peut afficher la valeur de ses attributs via une méthode description().
Écrire les CAT (Constructeurs – Accesseurs – classe de Test) répondant à ces spécifications.

2- Classe Capitale
Écrire une classe Capitale suivant les spécifications suivantes :
 Une Capitale est une Ville définie par un nom de pays.
 Une Capitale peut être construite avec : un nom de ville et un nom de pays OU un nom de
ville, un nom de pays et un nombre d'habitant.
 Une Capitale affiche la valeur de ses attributs avec des petites étoiles (***) autour (les
capitales sont prestigieuse), via une méthode description().
Écrire les CAT correspondants (pas de constructeur par défaut). On essayera de taper le moins
de code possible dans la classe Capitale. Que donne l'instruction :
Capitale c = new Capitale(); ?

3- Classe Patelin
Écrire une classe Patelin suivant les spécifications suivantes :
Un Patelin est une Ville ne pouvant pas avoir plus de 1000 habitants.
Un Patelin affiche la valeur de ses attributs avec des bâtons (| | |) autour (les patelins sont souvent
proches des forêts), via une méthode description().
Implémentez. Testez.

4 Que donnent les instructions suivantes ?

//-- 1er jeu de tests
Capitale c = new Capitale("Strasbourg", "France");
Ville v1 = (Ville) c; // upcast explicite
Ville v2 = c; // upcast implicite
Patelin p = (Patelin) c; // ?
//-- 2ème jeu de tests
Ville v1 = new Ville("Marseille");
Capitale c = (Capitale) v1; // downcast 1
Ville v2 = new Patelin("Marseille");
Patelin p = (Patelin) v2; // downcast 2
a. Indiquez ce qui ne marche pas.
b. Mettez en commentaire ce qui ne marche pas et ré exécutez.
c. Expliquez pourquoi certaines instructions de conversion marchent et d’autres pas.
d. Rajoutez, dans les deux jeux de tests précédents, les instructions ci-dessous, après avoir mis en
commentaire les instructions qui ne marchent pas. Qu’observez vous quand à l’exécution de la
méthode description()?
//-- 1er jeu de tests
c.description();
v1.description();
v2.description();
//-- 2ème jeu de tests
c.description();
v1.description();
v2.description();
p.description();
Exercice 3
Le diagramme de classes détaillé de la figure ci-dessous présente les classes Personne, Passager et
Personnel, utiles pour la gestion de la compagnie aérienne Albatros'Airlines.
 Parmi les méthodes prévues pour ces classes, citez les cas de surcharge et ceux de redéfinition.

 On précise le fonctionnement de ces trois classes par les remarques suivantes :

 pour créer une personne, on précise au moins son nom et son prénom : si son âge n'est pas précisé
il est fixé à -1 [par convention]
 lors de la création d'un objet représentant un membre du personnel, on fixe obligatoirement ses
nom et prénom, et son âge ; si le salaire n'est pas précisé, il est fixé à la valeur par défaut de
1500DT.
 on peut préciser l'effet du vieillissement en fixant un nombre d'années (par défaut, on vieillit d'un
an)
 une personne dont l'âge n'a pas été précisé ne subit pas le vieillissement.
 pour l'affichage des caractéristiques d'une personne, on ne donnera son âge que s'il a été précisé
 les méthodes ristourne et augmentation permettent respectivement de diminuer le prix du billet
d'un passager / d'augmenter le salaire d'un employé ; dans les deux cas, la valeur précisée en
paramètre correspond à un pourcentage; si on ne passe pas de paramètre à la méthode
augmentation, on aboutit à une augmentation de 1%.

Donnez les codes des fichiers Personne.java et Personnel.java, correspondant aux classes Personne
et Personnel.

 Proposez un exemple de classe de test, en vous basant sur la situation d'un certain avion qui
emporte 150 personnes (passagers et personnel confondus) :
 pour chaque personne, l'utilisateur en saisira les nom et prénom puis choisira entre "passager" et
"personnel" ; il saisira alors, selon le cas, son salaire ou le prix de son billet
 ce code devra mettre en évidence un cas de polymorphisme (vous l'identifierez clairement).
Donnez également un exemple d'appel qui serait impossible.

 [Cette question est indépendante des deux précédentes]

La compagnie Albatros'Airlines souhaite modéliser les différents types de personnel qu'elle
emploie. Elle distingue le personnel au sol du personnel navigant, et précise même le rôle des
pilotes et des hôtesses de l'air.
Notons que les Stewarts sont des hôtesses de l'air et que le commandant de bord est un des pilotes.
Proposez un diagramme de classe simplifié, qui complète les relations d'héritage entre Personne,
Passager et Personnel, et qui permette de schématiser les liens entre les différentes classes
suggérées ci-dessus.
TD 5 Classes abstraites & Interfaces

Exercice 1
1- La classe Vector ( package java.util ) est couramment utilisée. Nous allons ici l'utiliser de deux
façons pour créer une FIFO (First In / First Out) et une LIFO (Last In / First Out).
 Créer la classe abstraite Stack qui contient les classes abstraites:
Object get();
void put(Object);
 Implémenter cette classe de deux façons: par une classe FIFOStack puis par une
classe LIFOStack selon le comportement de pile désiré. (Utiliser les
méthodes addElement() et removeElement() de la classeVector ).

2- Transformez la classe Stack pour qu'elle devienne une interface qui est implémentée par les
classes FIFOStack et LIFOStack.
De quels type(s) sont les instances de FIFOStack et LIFOStack ?

Exercice 2
Cet exercice 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.
Le directeur d'une entreprise de produits chimiques souhaite gérer les salaires et primes de ses
employés au moyen d'un programme
Un employé est caractérisé par son nom, son prénom, son âge et sa date d'entrée en service dans
l'entreprise.

1. Ecrire le code d'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 votre 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. Leur salaire mensuel est le 20% du chiffre d'affaire qu'ils réalisent
mensuellement, plus 400 Dinars.
 Ceux affectés à la Représentation. Leur salaire mensuel est également le 20% du chiffre
d'affaire qu'ils réalisent mensuellement, plus 800 Dinars.
 Ceux affectés à la Production. Leur salaire vaut le nombre d'unités produites mensuellement
multipliées par 5.
 Ceux affectés à la Manutention. Leur salaire vaut leur nombre d'heures de travail mensuel
multipliées par 65 Dinars.

2. Ecrire le code de la 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 le mot "employé"
par la catégorie correspondante.
  Chaque sous classe est dotée de constructeur prenant en argument l'ensemble des attributs
nécessaires.

Employés à risques
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.

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 200Dinars.

3. Satisfait de la hiérarchie proposée, notre directeur souhaite maintenant l'exploiter pour afficher le
salaire de tous ses employés ainsi que le salaire moyen.
Ajoutez une classe Personnel contenant un "Vector" d'employés.
Définissez ensuite les méthodes suivantes à la classe Personnel :
void ajouterEmploye(Employe) :qui ajoute un employé.
void calculerSalaires():qui affiche le salaire de chacun des employés.
double salaireMoyen():qui affiche le salaire moyen des employés.
TD 6 Les exceptions

Exercice 1
La division par zéro crée une ArithmeticException.
1. Créez une classe d'objet MonEntier qui contient un attribut monentier de type int. Ecrivez le
constructeur de cette classe.
2. Munissez cette classe par la méthode division. Cette méthode retourne le résultat (double de la
division de l’attribut monentier d'un objet MonEntier par l’attribut monentier d'un autre objet
MonEntier appelé diviseur. L'objet diviseur sera passé en paramètre d'entrée de la méthode division.
3. Testez votre méthode division sur deux entiers quelconques. Recommencez avec un diviseur égal
à zéro. Que se passe-t-il ?
4. Dans la méthode division : testez le bloc qui effectue l'opération. Si une ArithmeticException
est générée, affichez le message "Division impossible".
N.B: Vous pouvez également afficher le message de l'exception en utilisant la méthode
getMessage() : System.out.println(variableException.getMessage());

Exercice 2
1- Compilez et exécutez le programme Factorielle.java suivant en essayant successivement :
 de ne pas faire figurer sur la ligne de commande le paramètre attendu
 de mettre un paramètre non-entier
 de mettre un paramètre entier négatif
 de mettre l'entier 20

class Factorielle {
public static void main (String[] args) {
int i, nbEntiers=0, factorielle=1;
int ancien;

nbEntiers= Integer.parseInt(args[0]);
for (i=2;i<= nbEntiers;i++) {
ancien=factorielle;
factorielle *=i;
}
System.out.println(" Voila la factorielle des "+ nbEntiers +
" premiers entiers : "+ factorielle );
}
}
Dans les deux premiers cas, une exception est signalée. Dans les deux derniers cas le résultat est
faux.

2- Vous devez modifier le programme pour que, dans chacun des cas, l'erreur soit précisée à
l'utilisateur.

Dans le premier cas, on souhaite que le programme affiche par exemple :

Indiquez le nombre d'entiers sur la ligne de commande
et si le paramètre indiqué est -4 :
-4 est négatif: la factorielle d'un nombre négatif n'est pas définie

3- Dans les deux premiers cas, utilisez les blocs catch pour afficher le message d'erreur.
4- Développer un mécanisme de propagation de l’exception (throws …)
Exercice 3
1- Compilez et exécutez le programme Stack.java suivant. Que constatez-vous?
import java.util.Vector;

public class Stack {

private Vector data=new Vector();
public void push(Object o) {
data.addElement(o);
}
public Object pop() {
Object sommet=null;
sommet=data.lastElement();
data.removeElement(sommet);
return sommet;
}

public static void main(String args[]){

Stack s=new Stack();

s.push(new String("FIN"));
s.push(new Integer(5));
s.push(new Float(10.7f));
s.push(new Double(20.5));
s.push(new String("DEBUT"));

System.out.println(" voici le contenu de la pile");

System.out.println("element1 : "+ s.pop());
System.out.println("element2 : "+ s.pop());
System.out.println("element3 : "+ s.pop());
System.out.println("element4 : "+ s.pop());
System.out.println("element5 : "+ s.pop());
System.out.println("element6 : "+ s.pop());
}
}

2- Déclarez que la méthode pop() génère une exception du type NoSuchElementException en

utilisant la clause throws.
Dans la méthode main, utilisez les instructions try{ ...} catch{ ... }. Dans le bloc catch,
affichez le message d'erreur "il n'y a plus d'éléments dans la pile".

3- Créez l'exception PileVideException qui hérite de la classe Exception. N'oubliez pas les
constructeurs !

4- La méthode pop() est la méthode qui génère l'exception. Indiquez dans son entête que cette
méthode génère une exception du type PileVideException.

5- Dans la méthode pop(), tester si la pile est vide, à l'aide de la méthode isEmpty() de la classe
Vector. Si la pile est vide, alors levez une nouvelle exception du type PileVideException.
Indiquez dans le message d'erreur: "ERREUR : La pile est vide !"
Exemple d'implémentation d'une méthode qui génère une exception
public maMethode throws MaClasseException {
if (condition_particuliere)
throw new MaClasseException("Message d'erreur");
 else {
... ...
...
}
}

6- Dans la méthode main, vous testerez dans le bloc try, les appels à la méthode pop(). Vous
capterez l'exception PileVideException dans un bloc catch, et vous afficherez le message d'erreur
correspondant.