Design Pattern (1/3)

Licence Informatique 3e année – Programmation objet avancée

Design Pattern (1/3)

 Un pattern (ou design pattern) décrit :



une situation constituant un problème souvent rencontré dans le développement d'applications



une (ou plusieurs) solution(s) type(s) à ce problème, de manière semi-formelle



les conséquences de l'usage de ce pattern

 Un pattern est indépendant des différents langages objets, c’est une solution abstraite de haut niveau, pas une brique logicielle



Exemples de patterns non logiciels :



Le pattern porte, élément rectangulaire sur charnière à droite et poignée à gauche comme solution au problème de l'accès à une pièce close



Le pattern vélo, cadre monté sur deux roues en ligne avec selle, la roue avant sur cadre pivotant et la roue arrière entrainée par un pédalier comme solution au problème du déplacement rapide à la force des jambes

 Un pattern s’exprime souvent par des interfaces et des classes abstraites, dans un schéma UML

Licence Informatique 3e année – Programmation objet avancée

Design Pattern (2/3)

 Avantages des patterns :



vocabulaire commun



capitalisation de l'expérience : catalogue de solutions



niveau d'abstraction plus élevé améliorant la construction des logiciels



réduction de la complexité du développement de logiciel

 Inconvénients des patterns :



effort d'abstraction et de synthèse



apprentissage des patterns

 Trois grands types de patterns :



Patterns de création : donnent des solutions aux problèmes liés à l'instanciation des classes



Patterns structurels : donnent des solutions aux problèmes de structuration des classes, d'abstraction, de réutilisation



Patterns de comportements : donnent des solutions aux problèmes de

communication entre objets et d'algoritmique

Licence Informatique 3e année – Programmation objet avancée

Design Pattern (3/3)

 Patterns de référence :

Patterns de création Abstract Factory

Builder FactoryMethod

Prototype Singleton

Patterns structurels Adapter

Bridge Composite

Decorator Facade Flyweight

Proxy

Patterns de comportement Chaine of responsability

Command Interpreter Iterator Mediator Memento Observer

State Strategy Template method

Visitor

Licence Informatique 3e année – Programmation objet avancée

Abstract Factory (1/4)

 Pattern Abstract Factory :



On veut pouvoir créer des objets de différents types mais appartenant à une même « famille » (par exemple des divans et des cuisines équipées)



La création doit pouvoir se faire au travers d'une seule et même classe (une usine de meuble abstraite)



Les objets peuvent être créés par différentes classes (par exemple des usines des usines concrètes) qui chacune peuvent produire plusieurs types d'objets de la famille



Les objets doivent pouvoir être manipulés sans que l'on ait besoin de savoir

quelle classe (usine) les a créés

Licence Informatique 3e année – Programmation objet avancée

Pattern Abstract Factory (2/4)

Licence Informatique 3e année – Programmation objet avancée

Pattern Abstract Factory (3/4)

public abstract class Divan{...}

public abstract class CuisineEquipee{...}

public class CuisineEquipeePlastique extends CuisineEquipee{...}

public class CuisineEquipeeBois extends CuisineEquipee{...}

public class DivanLaine extends Divan{...}

public class DivanPeauPhoque extends Divan{...}

Licence Informatique 3e année – Programmation objet avancée

Pattern Abstract Factory (4/4)

public abstract class UsineMeuble{

public abstract Divan creerDivan();

public abstract CuisineEquipee creerCuisineEquipee();

public static UsineMeuble getUsine(boolean ecolo){

if(ecolo) return new UsineMeubleEcolo();

else return new UsineMeublePolluante();

} }

public class UsineMeublePolluante extends UsineMeuble{

public DivanPeauPhoque creerDivan(){...}

public CuisineEquipeePlastique creerCuisineEquipee(){...}

}

public class UsineMeubleEcolo extends UsineMeuble{

public DivanLaine creerDivan(){...}

public CuisineEquipeeBois creerCuisineEquipee(){...}

}

Licence Informatique 3e année – Programmation objet avancée

Pattern Singleton

 Pattern Singleton : on veut écrire une classe qui ne doit posséder qu'une seule instance

public class Terre{

private static final Terre INSTANCE = new Terre();

private Terre() {...}

public static Terre getInstance() {

return INSTANCE; // Il n'y a qu'une seule Terre!

} }

Licence Informatique 3e année – Programmation objet avancée

Pattern Adapter (1/3)

 Pattern Adapter (objet) : on veut pouvoir utiliser une interface fixée, mais la classe cible qui offre les méthodes dont on a besoin possède une autre interface

 L'Adapter :



implémente l'interface souhaitée par l'objet utilisateur



inclut par composition une instance de la classe cible

Licence Informatique 3e année – Programmation objet avancée

Pattern Adapter (2/3)

public interface DepollutionCote{

public void dépolluerPlage();

public Oiseau[] sauverOiseaux();

}

public class DepollutionAdapter implements DepollutionCote{

ServiceNettoyage sn;

...

public void dépolluerPlage(){

sn.lessivageMazout();

}

public Oiseau[] sauverOiseaux(){

return sn.traitementPiafs(new Solvant());

} }

public class ServiceNettoyage{

private LinkedList equipe;

...

public int lessivageMazout(){...}

public Oiseau[] traitementPiafs(Solvant s){...}

}

Licence Informatique 3e année – Programmation objet avancée

Pattern Adapter (3/3)

 Pattern Adapter (classe) : on veut pouvoir utiliser une interface fixée, mais la classe cible qui offre les méthodes dont on a besoin possède une autre interface

 L'Adapter :



implémente l'interface souhaitée par l'objet utilisateur



hérite de la classe cible

Licence Informatique 3e année – Programmation objet avancée

Pattern Composite (1/2)

 Pattern Composite : on veut pouvoir manipuler des objets sous forme

arborescente, sans avoir à distinguer un noeud de l'arbre, une feuille

de l'arbre ou un arbre en soi (exemple : des expressions au sens

algorithmique)

Licence Informatique 3e année – Programmation objet avancée

Pattern Composite (2/2)

public abstract class MesuresPourLEnvironnement{

...

public abstract void appliquerMesures();

public void ajouter(MesuresPourLEnvironnement m){...}

public void supprimer(MesuresPourLEnvironnement m){...}

public MesuresPourLEnvironnement sousMesures(int index){...}

}

public class MesureComposee extends MesuresPourLEnvironnement{

public void appliquerMesures(){

// appliquer les sous mesures }

}

public class MesureElementaire extends MesuresPourLEnvironnement{

public void appliquerMesures(){

attendreQueCaAillePlusMalPourAgir();

} }

Licence Informatique 3e année – Programmation objet avancée

Pattern Iterator (1/2)

 Pattern Iterator : on veut pouvoir accéder séquentiellement à un agrégat d'objets sans avoir à en connaitre la structure interne

 Un Iterator, fourni par l'agrégat, permet de se positionner en début

d'agrégat et d'avancer par pas dans cet agrégat

Licence Informatique 3e année – Programmation objet avancée

Pattern Iterator (2/2)

public abstract class MareesNoires{

...

public abstract Iterator createIterator();

}

public class MareesNoiresEnBretagne

extends MareesNoires{

...

public MNIterator createIterator(){...}

}

public interface Iterator{

public Object first();

public Object next();

public boolean isDone();

public Object currentItem();

}

public classe MNIterator{

public Object first(){...}

public Object next(){...}

public boolean isDone(){...}

public Object currentItem(){...}

}

MareesNoiresEnBretagne mnb = new MareesNoiresEnBretagne();

for(Iterator i = mnb.createIterator();!i.isDone();){

MareeNoire mn = i.next();

mn.nettoyer();

}

Licence Informatique 3e année – Programmation objet avancée

Collection et Iterator en Java (1/2)

 L'API Java propose, dans le paquetage java.util un certain nombre de structures linéaires (tableau, listes plus ou moins

chaînées, ensembles énumérés, tables de hachage, vecteurs, piles et files) implémentant l'interface Collection

 L'interface Collection hérite de l'interface Iterable qui implémente le pattern Iterator

public interface Iterable{

public Iterator iterator();

}

public interface Collection extends Iterable{

public boolean add(Object o);

public boolean contains(Object o);

public Iterator iterator();

public boolean remove(Object o);

...

} public interface Iterator{

public boolean hasNext();

public Object next();

public void remove();

}

Licence Informatique 3e année – Programmation objet avancée

Collection et Iterator en Java (2/2)

public class Vector implements Collection, ...{

...

}

public class LinkedList implements Collection, ...{

...

}

LinkedList l = new LinkedList();

...

for(Iterator i = l.iterator();i.hasNext();){

Object o = i.next();

...

} ...

Vector v = new Vector();

...

for(Iterator i = v.iterator();i.hasNext();){

Object o = i.next();

...

} ...

Licence Informatique 3e année – Programmation objet avancée

Pattern Strategy (1/2)

 Pattern Strategy : on veut pouvoir choisir à l'exécution l'algorithme utilisé pour l'implémentation d'une méthode

 La classe définit son comportement à travers une interface qui peut

être instanciée par différentes classes qui implémentent différemment

le comportement

Licence Informatique 3e année – Programmation objet avancée

Pattern Strategy (2/2)

public interface TraitementDesDechets{

public void traiterDechets(Dechets d);

}

public class UsineDeRetraitement{

private TraitementDesDechets tdd;

...

public void retraitement(Dechets d){

tdd.traiterDechets(d);

} }

public class Incineration implements TraitementDesDechets{

...

public void traiterDechets(Dechets d){

// tout bruler }

}

public class TriEtRecyclage implements TraitementDesDechets{

...

public void traiterDechets(Dechets d){

// trier, recycler ce qui peut l'être }

}

Dechets d = new Dechets();

UsineDeRetraitement ur = new

UsineDeRetraitement();

ur.setTraitement(new TriEtRecyclage());

ur.retraitement(d);

Dechets e = new Dechets();

ur.setTraitement(new Incineration());

ur.retraitement(e);

Licence Informatique 3e année – Programmation objet avancée

Strategy et Comparator

 Collections est une classe de l'API Java qui offre, entre autres, des méthodes de tri opérant sur des instance de l'interface List, qui hérite de l'interface Collection

 La méthode de

Collections utilise pour trier (par ordre croissant) les éléments de la liste une stratégie de comparaison d'éléments définie par un Comparator

public static void sort(List list, Comparator c)

public interface Comparator{

public int compare(Object o1, Object o2);

public boolean equals(Object o);

}

public class MyComparator implements Comparator{

public int compare(Object o1, Object o2){

return ((Usine) o1).getCO2Emis() - ((Usine) o2).getCO2Emis();

}

public boolean equals(Object o){...}

}

// Liste d'éléments de type Usine List listeUsines = ...;

Collections.sort(listeUsines,new MyComparator());

Licence Informatique 3e année – Programmation objet avancée

Strategy et Comparable

 La méthode de Collections utilise pour trier les éléments de la liste une stratégie de comparaison d'éléments définie par les éléments de la liste, qui doivent implémenter l'interface Comparable

public static void sort(List list)

public interface Comparable{

public int compareTo(Object o);

}

public class Usine implements Comparable{

...

public int compareTo(Object o){

return ((Usine) o1).getCO2Emis() - this.getCO2Emis();

} }

// Liste d'éléments de type Usine List listeUsines = ...;

Collections.sort(listeUsines);

Licence Informatique 3e année – Programmation objet avancée

Pattern Observer (1/3)

 Pattern Observer : on veut que lorsque l'état d'un objet change, ce

changement soit répercuté sur tous les objets qui dépendent du

premier. On veut également pouvoir gérer de manière dynamique cette

dépendance de un à plusieurs c'est à dire ajouter ou supprimer des

dépendances sans toucher au code des classes.

Licence Informatique 3e année – Programmation objet avancée

Pattern Observer (2/3)

 L'objet observé (Observable) gère une liste d'observateurs

(Observer) dotés d'une méthode de mise à jour (update) et notifie les changements aux observateurs en appelant leurs méthodes de mise à jour

public class Observable{

private List listeObservers;

...

public void addObserver(Observer o){...}

public void removeObserver(Observer o){...}

public void notify(Object o){

for(Iterator i = listeObservers.iterator();i.hasNext();) ((Observer) i.next()).update(o);

} }

public interface Observer{

public void update(Object o);

}

Licence Informatique 3e année – Programmation objet avancée

Pattern Observer (3/3)

public class TrouDansCoucheOzone extends Observable{

private List listeObservers;

private int tailleTrou;

...

public void addObserver(Observer o){...}

public void removeObserver(Observer o){...}

public void notify(){

for(Iterator i = listeObservers.iterator();i.hasNext();) ((Observer) i.next()).update(new Integer(tailleTrou));

}

public void setTailleTrou(int t){

this.tailleTrou = t;

this.notify();

} }

public class VacancierSurLaPlage implement Observer{

...

public void update(Integer t){

// rajouter ou enlever de la crème solaire selon la taille du trou dans la couche d'ozone }

}

Licence Informatique 3e année – Programmation objet avancée

Observer et Observable en Java

 L'API Java offre



Une interface Observer



Une classe Observable qui implémente la gestion d'une liste d'Observer

 L'appel des méthodes de notification de Observable doit être précédé de l'appel de setChanged

public interface Observer{

public void update(Observable o, Object arg);

}

public class Observable{

public Observable();

public void addObserver(Observer o);

public void deleteObserver(Observer o);

public void notifyObservers();

public void notifyObservers(Object arg);

protected void setChanged();

...

}

Licence Informatique 3e année – Programmation objet avancée

Pattern MVC

 Dans les interfaces graphiques, il est préférable de séparer les données manipulées et l'affichage de ces données



d'un coté les classes qui implémentent le modèle des données



de l'autre les classes qui gèrent l'affichage des données dans l'interface



le pattern Observer permet de lier les deux (quand les données changent, l'affichage doit être mis à jour)

 Pattern MVC (Modèle Vue Contrôleur) : on ajoute aux parties modèle et vue la partie controleur qui gèrent les actions sur le modèle

Modèle

Contrôleur notifie Vue

modifie

active