Travaux dirigés Java, séance n° 2 [Link]

html

P P L O E J

T D 
N T
(Lien permanent: [Link] ( .pdf ))

L'objectif de ce TD est de programmer en utilisant un type abstrait de données (pile de

caractères) réalisée par une classe Java.

S

1. Programmation par abstraction

1. Classe pile simple
2. Documentation de la classe pile
3. Gestion des exceptions en java
4. Programme d'analyse d'une expression parenthésée

. P P A

.. C P S

On va programmer la classe Pile de caractères, représentée par un tableau et un indice

de sommet de pile.

Compléter la classe suivante (à créer dans un fichier [Link]):

1 public class Pile {

2 //
3 // Déclarations des attributs de la pile
4 //
5 static final int MAX = 8;
6 char t[];
7 int top;
8
9 //
10 // Programmation des opérations (méthodes) de la pile
11 //
12 public Pile() {
13 // Initialise une pile vide
14 t = new char[MAX];
15 top = -1;
16 }
17
18 public void empiler(char c) {
19 // Empile le caractère donné en paramètre
20 if (!estPleine())
21 t[++top] = c;

1 of 7 4/22/2022, 1:36 PM
Travaux dirigés Java, séance n° 2 [Link]

22 else
23 [Link]("Pile pleine");
24 }
25
26 public char sommet() {
27 // Retourne le caractère au sommet de la pile, sinon '\0'
28 // ... a compléter ...
29 }
30
31 public void depiler() {
32 // décapite la pile (retire le sommet )
33 // ... a compléter ...
34 }
35
36 public boolean estVide() {
37 // Teste si la pile est vide
38 return (top < 0);
39 }
40
41 public boolean estPleine() {
42 // teste si la pile est pleine
43 // ... à completer ...
44 }
45
46 }; // class Pile
47
Exercice 1) Ecrire un programme qui lit une chaîne de caractère et l'imprime inversée.

Algorithme :

Pile p, char c;
lire (c);
Tant que (c != '#')
empiler c sur p;
lire (c)
ftq
Tantque (pile non vide)
c = sommet de p;
écrire (c);
dépiler p;
ftq

Indications :

• Créer le programme dans un fichier [Link]

• Pour lire un caractère en entrée standard, utiliser :

char monChar; Scanner clavier = new Scanner([Link]);

monChar = [Link]().charAt(0);

• La fin de la chaîne à lire est marquée par le caractère # '.

2 of 7 4/22/2022, 1:36 PM
Travaux dirigés Java, séance n° 2 [Link]

Retrouver la solution ici ( [Link] ).

Exercice-2 ) Ecrire un programme qui lit une un texte contenant une série de
parenthèses et qui

• à la rencontre du caractère ( il l'empile sur une pile p

• à la rencontre du caractère ) il dépile la pile p
• ignore tout autre caractère.
• s'arrête à la lecture du caractère # .

A la fin du texte lu, si la pile est vide l'expression est bien parenthésée. Sinon, il y a plus
de parenthèses ouvrantes que de parenthèses fermantes. Si la pile est vide
prématurément, lors d'un dépilement, alors il y a plus de parenthèses fermantes que de
parenthèses ouvrantes.

.. D D L C P

On va créer une page Web de documentation de la classe Pile. Il doit y avoir

• D'abord un texte sous forme de commentaire qui documente la classe en générale,

par exemple ce qu'est un objet Pile etc.
• Ensuite, il doit y avoir un texte qui documente chaque méthode en indiquant ses
paramètres données, son résultat éventuel et le traitement effectué.

Dans le fichier [Link] contenant la classe Pile, ajouter en début de fichier un

commentaire qui commence par /** . C'est le commentaire générale de la classe.
Exemple :

/**
Classe Java correspondant à une pile
Un pile est un objet sur lequel on empile ...
etc...
*/

Ensuite, avant chaque déclaration de méthode, ajouter le commentaire qui documente la

méthode. Exemple :

/**
* Empile le caractère donné
*/
public void empiler(char c){...}
...

On peut alors créer les pages documentation de la classe Pile avec la commande
javadoc

$ javadoc [Link]

3 of 7 4/22/2022, 1:36 PM
Travaux dirigés Java, séance n° 2 [Link]

Un certain nombre de fichiers sont alors créés. L'un des fichiers est [Link] qui est
la page Web principale.

On peut améliorer la documentation finale en rajoutant des lignes commentaires

@param , @return , @see , pour documenter les paramètres. Exemple : Source à
documenter, documentation générée.

.. G D E E J

Une exception est un cas particulier (ou erreur) qui se produit dans un programme. Par
exemple pile vide en cas de dépilement, rencontre d'un caractère nom numérique lors de
la lecture d'un nombre etc.

L'exemple simple suivant est une méthode qui calcule la factorielle d'un entier, et qui
lève une exception quand l'entier est négatif.

1 static public int fact(int x) throws ExceptionFactNegatif

2 if ( x < 0 ) throw new ExceptionFactNegatif();
3 else {
4 // calcul factorielle dans int f ...
5 return f;
6 }
7 }
8
On rajoute au profile de la méthode le mot clé throws et le type d'objet levé, qui est ici le
classe ExceptionFactNegatif . (voir plus bas).

L'utilisation de cette méthode doit s'attendre, grâce à une instruction try , à une
éventuelle levée d'exception et la capter, grâce à une instruction catch , pour pouvoir la
traiter.

1 int n = ...
2 try {
3 int f = fact(n);
4 }
5 catch (ExceptionFactNegatif e) {
6 [Link]("Valeur negative pour factorielle");
7 [Link]();
8 }
9
try indique un bloc d'instructions dans lequel une exception peut être levée "une erreur
peut se produire".

Le bloc catch contient les instructions à exécuter dans le cas où un type d'exception
s'est produit dans le try correspondant. Ici, on imprime une message pour la
circonstance. catch est paramétré par l'exception à capter. ici objet e de classe
ExceptionFactNegatif .

On peut utiliser cet objet e justement, pour suivre la trace de l'exception produite, avec

4 of 7 4/22/2022, 1:36 PM
Travaux dirigés Java, séance n° 2 [Link]

[Link]() en plus du message à imprimer.

Le résultat de la séquence de programme précédente exécutée pour n = -1 est:

Valeur negative pour factorielle

ExceptionFactNegatif
at [Link]([Link])
at [Link]([Link])

La classe correspondant à l'exception souhaitée, ExceptionFactNegatif ici, est donnée

par:

class ExceptionFactNegatif extends Throwable {};

Classe qui ne contient rien. Seul son nom suffit. (N'est elle pas une exception?...)

Le fait c'est qu'elle est sous classe de la classe prédéfinie Throwable . Condition
nécessaire pour pouvoir être soulevée comme exception.

A un même bloc try peuvent correspondre deux blocs catch . On peut ajouter à
l'exemple ci-dessus le cas de factorielle qui dépasse la capacité d'un int . Factorielle 13
est déjà 6 227 020 800.

On crée donc une deuxième exception,

class ExceptionFactSuperieur12 extends Throwable {};

et on écrira :

1 try {
2 int f = fact(n);
3 }
4 catch (ExceptionFactNegatif e) {
5 [Link]("Valeur negative pour factorielle");
6 [Link]();
7 }
8 catch (ExceptionFactSuperieur12 e) {
9 [Link]("Valeur > 12 pour factorielle");
10 [Link]();
11 }
12
Exercice-3)

Suivant ce même modèle, reprendre la classe pile et traiter les cas d'une pile vide (dans
dépiler et sommet) et d'une pile pleine (dans empiler).

Indication :

On définira deux classes ExceptionPileUnderflow et ExceptionPileOverflow

correspondant respectivement aux cas débordement de pile par en bas, pile vide, ou
débordement par en haut, pile pleine.

5 of 7 4/22/2022, 1:36 PM
Travaux dirigés Java, séance n° 2 [Link]

On reprogrammera les opération de la classe pile en conséquence, par exemple:

1 public char sommet() throws ExceptionPileUnderflow {

2 // Retourne le caractère au sommet de la pile
3 if (!estVide())
4 return t[top];
5 else
6 throw new ExceptionPileUnderflow();
7 }
8
etc...

On reprendra ensuite le programme [Link] avec cette fois-ci des blocs

try / catch .

Une solution : [Link], [Link]. (voir la version .html pour

les liens)

.. P D' D' E P

Exercice-4)

a) Réfléchir à un algorithme qui vérifie si une chaîne (ou expression) est bien
parenthésée: une parenthèse fermante est en correspondance avec une parenthèse
ouverte. "Parenthèse" à prendre au sens large parmi les symboles: ( < [ { } ] > ) .

Exemple :

{[(a+51)-(c)]} est correcte

{(a+b)] est incorrecte ( ] ne correspond pas à { ),

ainsi que (a+b)) (parenthèse fermante en trop) ou
((a+b) (parenthèse ouvrante en trop)

Indications :

• Le programme doit ignorer (ne pas traiter) les symboles autres que les
"parenthèses".
• Les étapes sont :

6 of 7 4/22/2022, 1:36 PM
Travaux dirigés Java, séance n° 2 [Link]

1. On commence par une pile vide (voir figure)

2. On lit { , on l'empile
3. On lit [ , on l'empile
4. On lit ( , on l'empile
5. On ignore a+51 , on lit ) , elle correspond au sommet de la pile (4), on dépile
celle-ci
6. On ignore - , on lit ( , on l'empile
7. On ignore c , on lit ) , elle correspond au sommet de la pile (6), on dépile celle-
ci
8. On lit ] , il correspond au sommet de la pile (7), on dépile celle-ci
9. On lit } , elle correspond au sommet de la pile (8), on dépile celle-ci. On a fini
la lecture. Si on finit une pile vide, l'expression est correctement parenthésée.

b) Utiliser la pile de l'exercice précédent pour programmer cet algorithme.

That's all folks.

Evaluation :

Certains exercices seront évalués à la demande et corrigés par l'encadrant

du TP.

7 of 7 4/22/2022, 1:36 PM