INF1426 - Développement d’application de bureau

TD1

Exercice 1
1. Écrire une classe nommée Voiture ayant les propriétés (attributs) suivantes :
marque, modele, couleur, numeroDeChassis, nombreDePlaces.

2. Créer un constructeur par défaut, un constructeur d’initialisation et un

constructeur par recopie..

3. Écrire les accesseurs (getters et setters) des attributs couleur et

numeroDeChassis. NB : Les accesseurs des autres attributs sont certes
nécessaires mais ne sont pas demandés dans le cadre du présent exercice).

4. Réécrire la méthode toString(). NB : La méthode doit renvoyer une chaîne de

caractères et ne doit rien imprimer à l’écran.

5. On veut maintenant disposer d’une méthode qui permet de peindre une

voiture en une couleur de son choix. La méthode prendra alors en paramètre la
couleur souhaitée et peindra la voiture en cette couleur. Vérifier que cette
méthode existe déjà.

6. On dira que deux voitures sont identiques si elles ont le même numéro de
châssis. Écrire une méthode nommée egale qui prend en paramètre une
voiture et la compare à la voiture courante. Cette méthode retourne un booléen
dont la valeur est égale à true si la voiture passée en paramètre lui est
identique et false sinon.

7. On voudrait à tout moment, connaître nombre de voitures créées. Après

réflexion, les informaticiens ont conclu qu’il faut créer un attribut pour stocker
cette valeur.

7.1. Faut-il créer un attribut de classe ou d’instance ?

7.2. Écrire ensuite le code correspondant à la déclaration de cet attribut et

de ses accesseurs de cet attribut.

7.3. Écrire l'accesseur en lecture de cet attribut.

7.4. Écrire l'accesseur en modification de cet attribut.

8. Écrire une classe de test nommée Programme dans laquelle on écrira une
méthode nommée main. Dans le corps de la méthode main :

1/6
 8.1. Créer deux voitures voiture1 et voiture2.

8.2. Créer voiture3, une voiture identique à voiture2.

8.3. Qu’affiche l'instruction system.out.println(voiture2 == voiture3) ? True

ou False ?

8.4. Qu’affiche l'instruction system.out.println(voiture2.egale(voiture3)) ?

True ou False ?

8.5. Écrire le code permettant de modifier le numéro de châssis de voiture3.

8.6. Qu’affiche l'instruction system.out.println(voiture2.egale(voiture3)) ?

True ou False ?

8.7. Écrire le code permettant d’afficher les trois voitures.

Exercice 2 : Gestion de vente

Dans le dépôt de vente d’une boutique, on dispose d’articles organisés par
catégories. Pour simplifier la gestion, un article est décrit par une référence, un libellé,
un prix unitaire et une et une seule catégorie. Une catégorie est décrite par une
référence et son libellé.
La boutique propose des articles en détail et/ou en lots appelés kits. Un kit est
considéré comme un article composé d’articles qui peuvent aussi être des kits.
La prix de l’article est une valeur intrinsèque pour les articles non composés. Par
contre pour les kits, cette information est une valeur calculée en fonction des
composantes.
Lors d’une vente, le vendeur saisit pour chaque article payé, la quantité et
éventuellement une remise qui ne doit pas dépasser 10 % du prix unitaire de l’article.
Pour les kits, hormis une remise similaire à la précédente (<=10 %) une remise
systématique de 5 % est faite sur chaque composante. Chaque vente d'articles
donne lieu à un déstockage.

Travail à faire
1. En se basant sur le design pattern composite, proposer un modèle de
stockage des articles de ce dépôt.
2. Créer les classes correspondantes au modèle proposé.

2/6
 3. Proposer un modèle pour la gestion de la facturation. On précise qu’une
facture comprend : une référence, la date de vente, le client (décrit par un
numéro d’identification, son nom et prénom) et des lignes de ventes. Une ligne
de vente est constituée d’un article (référence, libellé), la quantité vendue et la
remise.
4. Dans une classe Boutique de test, créer les articles listés dans le tableau
suivants:

Référence Libellé Catégorie Quantité Prix unitaire

5SS50EA HP ELITEBOOK PC portable 7 450 000

X360 830 G5

7GY98EA HP ENVY X360 PC portable 6 490 000

13-AR0007NF

TWX4PO Téléphone Tecno Téléphone 5 65 000

WX4PO portable

CASD231 Carte mémoire Carte 15 2 000

sandisk 4 GB mémoire

DC1000B KINGSTON SSD Disque dur 10 33 000

DC1000B 480
GO

KTORDI Kit ordinateur Kit ordi = 1 x 5SS50EA + 2 x DC1000B

KTTEL Kit téléphone Kit Tel = 1 x TWX4PO + 1 x CASD231

5. Afficher le stock (liste des articles simples et leur quantité)

6. Créer un client.
7. Créer une facture contenant les lignes suivantes au nom du client:
a. 1 x KTORDI
b. 2 x KTTEL
c. 2 x 7GY98EA
8. Afficher la facture.
9. Afficher à nouveau le stock.

3/6
Exercice 3 : Développement du jeu de démineur
Le jeu démineur est composé d'un plateau rectangulaire, d'un chronomètre et d'un
compteur de mines. Le plateau est un quadrillage de cases. Au début du jeu, toutes les
cases du plateau sont couvertes, le compteur de mines indiquant le nombre de mines
restantes à localiser. Le chronomètre compte le nombre de secondes écoulées depuis le
début de la partie. La partie commence lorsque la première case est découverte. Quand
une case est découverte, son contenu est affiché. Le contenu d'une case peut être rien,
une mine ou un nombre indiquant le nombre de mines présentes dans les cases voisines.
Les scénarios suivants peuvent se produire lorsqu'une case est découverte, en fonction de
son contenu :
➔ Un chiffre – Il ne se passe rien
➔ Un blanc – Toutes les cases voisines sont dévoilées, à condition qu'elles ne soient
pas signalées par un drapeau. Si l'une de ces cases voisines ne contient rien, le
processus de découverte continue automatiquement à partir de cette case.
➔ Une mine – Le jeu est terminé et le joueur a perdu.

Si elle est toujours couverte, une case peut être marquée en respectant les règles
suivantes:
➔ Marquer une case qui n'est ni découverte ni marquée décrémente le compteur de
mines restantes à localiser et un drapeau apparaît sur la case. Il indique que cette
case contient potentiellement une mine. Une case marquée d'un drapeau ne peut
être découverte.

➔ Marquer une case déjà signalée d'un drapeau permet de la remettre dans son état
initial, à savoir couverte et non marquée. Le compteur de mines est alors incrémenté
de 1.

Travail à faire

1. Création d’une interfaces pour les états d’une case

Écrire une interface Etat qui déclare les méthodes suivantes :
■ void decouvrir() : dont l’appel découvrira la case ,
■ void marquer() : dont l’appel marquera la case,
■ Etat etatSuivant() : dont l’appel renverra l’état suivant.

2. Création de la classe représentant une case

4/6
 2.1. Écrire une classe nommée Case et qui contient les attributs suivants :
■ x de type entier : index de la ligne contenant la case,
■ y de type entier : index de la colonne contenant la case,
■ minee de type booléen : a la valeur true si la case cache une mine et
false sinon,
■ etatCourant de type Etat : référence un objet de type Etat dont le type
concret permettra de définir et connaître l’état de la case.

NB : La classe Case n’implémente pas l’interface Etat.

2.2. Écrire un constructeur avec, comme arguments, les paramètres x et y .

2.3. Écrire une méthode List<Case> getVoisines() qui renvoie une collection des
cases voisines de la case courante.

2.4. Utiliser la méthode de la question 2.3 et les méthodes de l’interface Etat

pour écrire deux méthodes decouvrir() et marquer() qui permettent
respectivement de découvrir et de marquer une case.
Indication :
La classe Case ne fournira pas d’implémentation complète à ces méthodes
mais va plutôt déléguer tout ou une partie des comportements variables à
son attribut etatCourant.
Chaque appel des méthodes decouvrir() et marquer() doit faire changer
d’état à la case.

3. Création de la classe représentant la grille (le plateau)

3.1. Écrire une classe nommée Grille et qui contient les attributs suivants:
■ nombreLignes de type entier : nombre de cases sur une colonne,
■ nombreColonnes de type entier : nombre de cases sur une ligne,
■ cases de type List<Case> : collection des cases de la grille. Cette
collection aura une longueur égale à
nombreLignes X nombreColonnes une fois que toutes les cases
seront rattachées à la grille.

3.2. Écrire un constructeur avec, comme arguments, les paramètres

nombreLignes et nombreColonnes.

4. Création, dans la classe grille, d’une méthode qui renvoie la case de

coordonnées x et y

4.1. Écrire une méthode getCase(int n) qui renvoie la case située à la position
n de la liste cases. On rappelle que pour obtenir l’élément situé à la
position i d’un objet de type List, on appelle la méthode get(i) sur cet
objet.

5/6
 4.2. Pour faire correspondre une case de coordonnées (x, y) de la grille à une
case située à une position i de la collection cases, considérer la
correspondance schématisée à la figure suivante.

En utilisant une combinaison entre cette correspondance et la méthode

getCase(int n) , écrire la méthode getCase(int x, int y) qui renvoie la
case de coordonnées x et y.

5. Création des classes représentant les états d’une case

5.1. Écrire une classe nommée CaseCouverte qui implémente l’interface Etat
et qui représente l’état d’une case couverte. Fournir une implémentation
à chacune des méthodes de l’interface Etat.

5.2. Écrire une classe nommée CaseDecouverte qui implémente l’interface

Etat et qui représente l’état d’une case découverte. Fournir une
implémentation à chacune des méthodes de l’interface Etat.

5.3. Écrire une classe nommée CaseMarquee qui implémente l’interface Etat
et qui représente l’état d’une case marquée. Fournir une implémentation
à chacune des méthodes de l’interface Etat.

NB :
- Respecter le principe de l’encapsulation.
- Par contre, pour des raisons de lisibilité, ne pas écrire les accesseurs.
- Bien indenter le code.

6/6