Td Pattern

Exercice I (Factory et Abstract Factory)

1- Ecrire la classe abstraite Automobile caractérisée par un modèle, une couleur, une puissance et un espace.
Ajouter une méthode afficherCaractéristiques().

2- Ecrire les classes AutomobileElectricité et AutomobileEssence.

3- Ecrire la classe abstraite Scooter caractérisée par un modèle, une couleur et une puissance. Ajouter une
méthode afficherCaractéristiques().

4- Ecrire les classes ScooterElectricité et ScooterEssence.

5- Ecrire l’interface FabriqueVéhicule permettant de créer des Automobiles et des Scooters

6- Ecrire les classes FabriqueVéhiculeElecticité et FabriqueVéhiculeEssence réalisant FabriqueVéhicule

Exercice II (singleton)

1. Ecrire un programme java qui permet de créer une instance de Base de données unique. Cette base de
données possède deux attributs « record » ( n°de l’enregistrement courant) et « name » (nom de la
BdD). Une méthode, « editRecord », qui permet d’éditer un enregistrement dans la BDD (en affichant
seulement que l’enregistrement subit une opération de modification) et une méthode « getName », qui
retourne le nom de la BDD.

2. Testez dans un programme l’unicité de la BdD.

3. Y a-t-il une possibilité de défaillance ?

Exercice III (singleton) 2012

Implémentez dans un milieu bancaire le pattern singleton. Tout d’abord vous allez concevoir une classe
CompteBancaire qui permet de déposer ou retirer de l’argent sur un compte. Vous allez afficher les opérations
effectuées dans la console. Pour cela, vous allez implémenter une classe distincte nommée Journalisation
reprenant le pattern Singleton. Ainsi nous allons garantir que notre programme va utiliser une seule et même
instance de la classe Journalisation. Une troisième classe intitulée Main permettra d’exécuter l’application et
d’obtenir un résultat en console.

CompteBancaire
Journalisation
- numero : int
- ………. - solde : double
- log : String
+ CompteBancaire()
…….. + deposerArgent(depot : double)
……. + retirerArgent(retrait : double)
ajouterLog(log : String)
getLog() : String

Main

1. Spécifier l’attribut et les méthodes nécessaires afin que la classe Journalisation soit basée sur le pattern
Singleton. Elle possède aussi deux méthodes, ajouterLog(string) qui permet d'ajouter un message de log
et getLog() qui retourne tous les messages de log.

2. La classe CompteBancaire correspond à un compte. Celui-ci possède un numéro (identifiant) et un

solde. Il est possible de déposer de l’argent ou d’en retirer grâce aux méthodes deposerArgent(double)
et retirerArgent(double). Ces deux dernières méthodes utilisent la classe Journalisation pour tracer les
opérations.

3. La classe Main est la classe principale de notre programme. Elle va permettre d’exécuter un exemple et
d’afficher son résultat en sortie. En effet, sur le compte numéro 123 on va déposer 100 DA et retirer 80
DA. Puis sur le compte 321 on va déposer 200 DA et retirer 110DA.
 Exercice IV sur le Builder 2009

Afin de servir des pizzas, suivant la méthode du monteur on réalisera les classes java suivantes :

1- Une classe abstraite "MonteurPizza"qui permettra de monter quelconque pizza. La classe

"MonteurPizza" permettra de retourner une Pizza, de créer une nouvelle pizza et de montrer que pour
monter une pizza, il faut monter la patte, monter la sauce et monter la garniture.

2- Une classe "Pizza" qui représente le produit à monter. Elle est constituée d’une pate, d’une sauce et
d’une garniture.

3- Une classe "MonteurPizzaPiquante" qui fournit une implémentation (une spécification) du Monteur
abstrait, qui construit et assemble les différentes parties du produit (Pizza piquante). Une Pizza piquante
est constituée d’une patte feuilletée, d’une sauce piquante et d’une garniture en saucisson.

4- Une classe "Serveur" qui permettra de construire un objet "MonteurPizza" en utilisant la méthode de
conception Monteur. En plus des méthodes qui permettront de retourner et de modifier l’objet
"MonteurPizza", cette classe est constituée d’une méthode "construirePizza()" qui permettra de créer
une nouvelle pizza, de monter la pate, de monter la sauce et de monter la garniture.

5- Enfin le client commandant la pizza en écrivant un programme "Client"qui permettra d’instancier un

serveur, de monter et de construire une pizza piquante puis de servir (retourner) cette pizza.

Le monteur (ou "builder") est une classe abstraite ou une interface offrant des moyens de construction de
produits. Le diagramme de classe ci-dessous précise l’utilisation du Monteur.

« abstract »
Serveur MonteurPizza
- MonteurPizza mp # pizza : Pizza

…. ….
…. + creerNouvellePizza() : void
+ construirePizza() : void …………..

Pizza
MonteurPizzaPiquante
….

….
+ setPate(String pate) : void ….
…….. + creerNouvellePizza() : void
+ monterSauce() : void
Exercice V (Builder) 2011

Pour construire une maison, il faut d’abord construire l’étage, bâtir les murs et mettre enfin le toit. Le client
peut exiger une maison en bois ou en béton. Ecrire en java, les classes et les interfaces suivantes :
1. La classe abstraite MonteurMaison
2. La classe MonteurBois qui implémente MonteurMaison
3. La classe abstraite Maison (Une maison possède un étage, des mûrs et un toit) qui possède entre autre,
la méthode getReprésentation qui renvoie une chaîne de caractère
4. Les interfaces Etage, Murs et Toit qui possèdent aussi getReprésentation.
5. La classe MaisonBois implémentant Maison.
6. Les classes EtageBois, MursBois et ToitBois
7. La classe FabriqueMasion qui crée une maison en fabriquant étage, murs et toit et en affichant leurs
représentations.
8. La classe ClientMaison qui utilise FabriqueMaison, MonteurBois, MonteurBéton, MaisonBois et
MaisonBéton et qui affiche :
c:>Construction d’une maison en bois …
c:>Construction étage en bois terminé
c:>Construction murs en bois terminé
c:>Construction toit en bois terminé
c:>
c:>Construction d’une maison en béton …
c:>Construction étage en béton terminé
c:>Construction murs en béton terminé
c:>Construction toit en béton terminé
NB. : Ecrivez seulement les classes « en bois »
Exercice VI (Adapter)

Nous voulons développer un gestionnaire de fichier simple pour manipuler des documents textes. Il existe une
classe “FileManagerUtil”, qui fait cela. Cependant nous voulons la spécifier afin qu’elle s’adapte avec
l’interface voulue ‘FileManager’. ‘FileManagerImpl’ est une classe « adapter » qui implémente cette interface
et utilise les fonctionnalités de l’ « Adptee », ‘FileManagerUtil’.

FileManagerClient

1) Ecrire l’interface FileManager qui permet de lire ou écrire à partir d’une position, un nombre d’octets
dans un tableau.
public String read(int pos, int amount, byte[] data);

2) Ecrire la classe FileManagerUtil, qui possède un attribut f de type « RandomAccessFile ».

3) Ecrire la classe « FileManagerImpl » qui spécifie les fonctionnalités de FileManagerUtil et implémente
l’interface FileManager
4) Ecrire le programme FileManagerClent qui affiche :

Using filemanager: class FileManagerImpl

c:>Opening file: dummyfile.dat
c:>Writing 8 chars from string: dynamite to pos: 0 in file
c:>Reading 8 chars from pos: 0 in fileData written and read: dynamite
c:>Closing file
Exercice VII (Pattern Composite) 2012

Imaginons que nous ayons à gérer un petit magasin de sport (haltérophilie), lequel offre à ses clients la
possibilité d'acheter en pièces détachées, des barres, des poids d'haltères. Pour chaque article, qu'il soit
composé ou en pièces détachées, nous connaissons son prix, un nom descriptif.

 Le prix d'un ensemble est calculé suivant la méthode suivante : c'est la somme des prix de ses parties
(composées ou non) moins 10%
 Le nom descriptif d'un ensemble contient à la fois un descriptif de l'ensemble et le descriptif des
parties

Chaque produit a un ensemble de propriétés qui lui sont propres. Le poids d'haltère a un poids et la barre a une
longueur.

Nous nous pencherons ici sur la composition de produits. Pour cela, écrire les classes nécessaires :

L’interface Produit, la classe barre, la classe poids, la classe ProduitComposite (représente une altère, i.e.
une barre et plusieurs poids) et enfin la classe Program qui donnera un exemple d’utilisation.
Exercice VIII (Composite Pattern) 2011

Ecrire un pattern composite qui permet de composer des fichiers et des répertoires.

« interface »
AbstractFile
Repertoire
Fichier

+afficher(): void nom : String

nom : String
retrait : Retrait
retrait : Retrait
+ajouter(aF : AbstractFile) : void
..

a>

a> Retrait
Program

sbRetrait : StringBuffer

+augmenterRetrait() :void
+main(String[] args) : void
+diminuerRetrait() :void

Pour cela :

1) Ecrire l’interface «AbstractFile».

2) Ecrire une classe «Fichier» qui implémente «AbstractFile».
3) Ecrire classe « Repertoire » qui implémente aussi AbstractFile et qui possède un attribut files de type
« ArrayList », contenant tous les «AbstractFile» du répertoire.
4) Ecrire une classe Retrait qui permettra des retraits selon le niveau du fichier ou du répertoire.
5) Ecrire un programme « Program », créant quatre (05) « Fichier », et trois « Repertoire » tels que :

Composant Composés
repertoire1 fichier1
repertoire2 fichier2, fichier3, repertoire1
repertoire3 Fichier4, repertoire2, fichier5
Et en ayant l’affichage suivant après son exécution :
rép3
___a
___rép2
______c
______d
______rép1
_________e
___b
Exercice IX (Composite Pattern) 2010

Réécrire en Java, le diagramme de classe suivant :

Cercle

Pour cela :

6) Ecrire l’interface « Graphic », permettant d’afficher des graphiques (« Cercle » ou « CompositeGraphic »).

7) Ecrire la classe « Cercle » représentant un graphique élémentaire et implémentant l’affichage (Il suffit
d’afficher le texte : "Cercle").

8) Ecrire l’interface « CompositeGraphic » implémentant « Graphic », comportant un tableau de « graphic »

et deux (02) méthodes permettant d’ajouter ou de supprimer des « graphic » de ce tableau.

9) Ecrire un programme « Program », créant quatre (04) « Cercle », et trois « CompositeGraphic » tels que :

Composant Composés
graphic1 cercle1, cercle2, cercle3
graphic2 cercle4
graphic graphic1, graphic2

Afficher l’objet composé « graphic ».

Exercice X (Iterator Pattern) 2014

Soit le diagramme de classes ci-dessus. Ecrire une classe TestClientIterator qui

1- Remplira les 03 objets suivant dans un objet ArrayList.

Elément Type Valeur

1 Integer 42
2 String "test"
3 Double -12.34

2- Parcourir cette liste (comme iterator et/ou non), afin d’afficher ces trois éléments.

Exercice XI (Iterator Pattern)

BitSetIterator « interface »
- BitSet bitset Iterator<boolean>
- int index
+ hasNext )(: boolean
+ next)( : Boolean + hasNext )(: boolean
+ remove():void + next)( : Boolean
+ remove():void

TestClientBitSet

+main(String[] args) : void

 1- Ecrire une classe BitSetIterator qui implémente Iterator. BitSet est une classe qui implémente un vecteur de
taille dynamique et dont les éléments sont des booléens. ses méthodes set(i :int) et get(i :int) permettent de
modifier (par T) et de renvoyer la valeur du ième élément.

2- Ecrire le programme TestClientBitSet qui permettra d’initialiser un objet BitSet, d’accéder aux éléments de ce
dernier à travers un objet BitSetIterator et de les afficher.

Exercice XII (Template Pattern)

Le pattern Template method permet de reporter dans les sous-classes certaines étapes de l’une des opérations d’un
objet, ces étapes étant décrites dans les sous-classes.

Au sein d’un système de vente en ligne de véhicules, nous gérons des commandes issues de clients en France et en
Algérie. La différence entre ces deux commandes concerne notamment le calcul de la TVA. Le taux de la TVA en
France est de 19.6%, par contre en Algérie, il est de 17%.

Donnez une solution (UML & Java) qui permettra de factoriser au maximum les propriétés communes entre les deux
classes CommandeFrance et Commande Algerie : (montantHt, montantTva, montantTtc, calculeMontantTtc(),
calculeTva() et affiche()).