Interface fonctionnelle et Design_patterns

il y a un dossier « telecommand.zip » qui contient l’implémentation d’un programme Java.

Question #1. Que fait ce programme ? Quel design pattern est-utilisé ? Faîtes un diagramme de classes UML de l’application.

Identifier les « rôles » de chaque classe dans le design pattern.

Question #2.

Etendre le programme précédent pour que la télécommande puisse être invoqué avec des numéros (0, 1, .., 9).

Modifier RemoteControl et inventer de nouvelles fonctionnalités (e.g., éteindre la cuisine, la TV, régler la luminosité de la pièce principale, etc.) en utilisant le même design pattern.

Question #3. Ajouter la possibilité d’annuler une commande (par exemple, si j’ai éteint la cuisine et que j’annule la commande, je dois retrouver la même luminosité dans la cuisine)

Dans le dossier « bonbon.zip», il y a un dossier « bonbons » qui contient l’implémentation d’un programme Java.

Question #1: Que fait ce programme ? Quels sont les défauts de conception ?

Question #2: Spécifier le diagramme de la machine à état du distributeur de bonbon

Question #3: On souhaite ajouter un état « gagnant » :

le cas se produit lorsque l’utilisateur de la machine tourne la poignée (en ayant préalablement insérer une pièce évidemment) et de manière aléatoire il gagne parfois trois bonbons.

• Décrire rapidement comment vous feriez dans le code d’origine

• Implémenter ce nouvel état à l’aide du même design pattern (cf Question 3)

• (option) Étendre le programme pour permettre la paramétrisation du (1) nombre de bonbons gagnés et (2) de la fréquence de gain •

Pour comprendre en quoi consiste l’ aplatissement d’ un stream, considérons une structure comme [ [1,2,3],[4,5,6],[7,8,9] ] qui a “deux niveaux”. Aplatir cela signifie le transformer en une structure «à un niveau»: [ 1,2,3,4,5,6,7,8,9 ] .

[ "film1"=>[ acteur1,A2,3], f[4,5,6],[7,8,9]

Stream<String> stream;

Map<String, List<String>> map;

Map<String, Long> map2;

HashSet acteursdbl;

stream = Files.lines(Paths.get(C_FILE));

//Question 1

//Construction de la HashMap

map = stream

.map(t -> t.split(";"))

.collect(Collectors.toMap(t -> t[0], l -> Arrays.asList(l).subList(1, l.length)));

//parcours de la HashMap

for (Map.Entry<String, List<String>> entry : map.entrySet()) {

System.out.println("Key : " + entry.getKey() + " - values : " + entry.getValue());

}

Description

Le pattern Observer a pour objectif de construire une dépendance entre un sujet et des observateurs de sorte que

chaque modification du sujet soit notifiée aux observateurs afin qu’ils puissent mettre à jour leur état.

Collaborations

Le sujet concret notifie ses observateurs lorsque son état interne est modifié. Lorsqu’un observateur reçoit cette

notification, il se met à jour en conséquence. Pour réaliser cette mise à jour, il peut invoquer des méthodes du sujet

donnant accès à son état.

Domaines d’application

Le pattern est utilisé dans les cas suivants :

- une modification dans l’état d’un objet engendre des modifications dans d’autres objets qui sont déterminés

dynamiquement ;

- un objet veut prévenir d’autres objets sans devoir connaître leur type, c’est à dire

sans être fortement couplé à ceux-ci;

- on ne veut pas fusionner deux objets en un seul.

Exemple

Nous voulons mettre à jour l’affichage d’un catalogue de véhicules en temps réel. Chaque fois que les informations

relatives à un véhicule sont modifiées, nous voulons mettre à jour l’affichage de cellesci.

Il peut y avoir plusieurs

affichages simultanés.

La solution préconisée par le pattern Observer consiste à établir un lien entre chaque véhicule et ses vues pour que le

véhicule puisse leur indiquer de se mettre à jour quand son état interne a été modifié.

Donner le diagramme de classe