Telechargé par hbkstudio1

Cours patron-de-conception MRPRO avancement2-converted

publicité
Patrons de Conception
Raoudha MARAOUI
[email protected]
Plan
I.
II.
III.
IV.
V.
Introduction
Patrons de conception
Les modèles de création
Les modèles de structures
Les modèles de comportement
I.
Introduction
I.
Introduction
• Cycle de vie d’un logiciel
Maintenance
Analyse
Conception
Implémentation
Test
○ Conception
• Macroscopique
• Microscopique ou détaillée
○ Maintenance
• Corrective: correction des erreurs résiduels
• Evolutive: intégrer de nouvelles
fonctionnalité dans le logiciel
Utilisation
I.
Introduction
La conception d’un logiciel : un art difficile
○
Une conception réutilisable, extensible et efficace (complexité
linéaire non exponentielle) est une activité extrêmement
difficile.
○
Concepteur:
○
□
□
Novice
Expert
Un concepteur novice hésite entre les différents variantes:
Classe abstraite/ classe effective, relation de héritage/ relation
client/serveur.
○
○
Un concepteur expert trouve tout de suite la solution
Quel est le secret?
□
L’expérience
I.
○
Introduction
L’implémentation :
□ Est une activité répétitive : choses semblables mais non identiques
□ Solution : des algorithmes fondamentaux et des structures de
données fondamentales.
○
Conception :
□ Répétition : choses semblables mais non identiques
□ Solution : solution conceptuelle proposées sont connues
sous le
nom : Patron de conception [1]
= des modèles de conception
= des microarchitectures logicielles
= Design Pattern.
[1] « Design Patterns » Catalogue de modèle de conception réutilisable ( 1995 version Anglaise, version
française (traduction) 1990). Ce cours va présenter quelques patterns issue de ce livre. Ces patterns sont
connues sous le nom Patterns de E.Gamma ou encore Patterns de GoF ( bandes de quatres).
I.
○
Introduction
Référence de base :
« Design Patterns : Catalogue de modèle de conception réutilisable »
-
Ce cours va présenter quelques patrons issus de ce livre,
Ces patrons son connu sous le nom de patron « E.Gamma » ou
encore « patterns de Gof » ( la bande des quatres)
Les patterns de Gof sont au nombre de 23
Les deux objectifs fondamentaux de la conception OO:
- Ne pas réinventer la roue
- Réutiliser systématiquement des solutions conceptuels qui ont
fait leurs preuve.
II. Design Pattern :
Définition, propriétés, description et
catalogues
II.
Design Pattern
2.1 Définition
□ Un modèle de conception décrit un problème (sous-entendu
problème de conception) qui se manifeste constamment dans
notre environnement et décrit également le cœur de la
solution de ce problème. De telle manière que plusieurs
utilisateurs de ce modèle de conception ne se font pas de la
même manière.
□ Un modèle de conception propose une solution générique
(solution paramétrée encore squelette) à une famille de
problèmes.
II.
Design Pattern
2.2 Propriété
□ Un bon modèle de conception possède les caractéristiques
suivantes :
○ Il résout un problème de conception récurrent.
○ La solution proposée n’est pas évidente
○ La solution proposée doit être élégante et utile.
II.
Design Pattern
2.3 Description des modèles de conception
○ Tous les modèles de conception de E.Gamma sont
décrits selon le même canevas (format unique)
○ Un tel canevas comporte plusieurs rubriques :
intention, motivation, indication d’utilisateurs,
structure…
II.
Design Pattern
2.4 Catalogue de modèle de conception
II.
Design Pattern
2.5 Organisation de catalogues
III. Les modèles de création
III. Les modèles de création
3.1 Objectif
o
Les modèles de conception de création de E.Gamma sont en nombre de
5 : Fabrication, Fabrique abstraite, Prototype, Singleton et Moteur.
o
Les objectifs principaux de ces patrons sont :
1.
Abstraire le processus
d’instanciation( ou de
création d’objets)
2.
Cacher la création
d’un objet : qui a
créer l’objet, quand et
comment ?
Conséquence:
Créer , composer, assembler et représenter les objectifs pour des instances
d’une façon simple et flexible.
III. Les modèles de création
Les deux caractères récurrents sont :
1.
Ces modèles encapsulent les
connaissances concrètes des
classes formants le système
étudié.
2.
Ces modèles cachent
le
processus
de
création des objets.
III. Les modèles de création
3.2 Les modèles singletons (objet créateur)
o
Intention
Ce modèle garantit qu'une classe possède une seule instance (objet) et fournit
un accès (interface) de type global à cette classe.
o Motivations
Lorsqu’un seul serveur d’impression qui gère l’impression sur plusieurs
imprimantes.
• Un seul ordonnanceur pour gérer plusieurs processus.
• Utilisation d’objets partagés (variable globale dans le langage procédural).
III. Les modèles de création
3.2 Les modèles singletons (objet créateur)
o Structure (microarchitecture) :
Singleton
+donnee_singleton
+operation_singleton
+aquis_singleton
+instance():singleton
instance_unique
o Constituants :
La classe singleton offre une opération classe permettant d’accéder à la seule
instance.
Collaboration :
Le client doit passer par l’interface instance pour accéder à instance_unique
de la classe singleton .
o
III. Les modèles de création
TD1
o Enoncé:
Utiliser le patron singleton pour implémenter en java une variable
globale (objet partagé) par exemple un compteur de type entier.
o Solution:
Faire des correspondances compteur-> singleton
Connaissances concrètes :
•
•
•
•
•
Cpt
Incrémenter
Décrémenter
Réinitialiser
Valeur
Donnée Singleton
Opération Singleton
Acquis Singleton
III. Les modèles de création
o Solution en JAVA
public class Compteur {
private int cpt ;
private static Compteur instance_Unique= NULL ;
private Compteur(){
cpt=0 ;
}
public void reinitialiser(){
cpt=0 ;
}
public void incrementer(){
cpt++ ;
}
public void decrementer (){
cpt-- ;
}
public static Compteur instance(){
If (instance_Unique =NULL)
intance_Unique= new Compteur();
return instance_Unique ;
}
public int valeur()
{ return cpt ;
}
}
class test{
public static void main(String args[]){
Compteur.instance().incrementer();
Compteur.instance().incrementer();
Compteur.instance().incrementer();
Compteur.instance().decrementer();
System.out.println(‘’ valeur = ‘’+
compteur.instance().valeur()) ;
}
}
Compteur
- Cpt :entier
+ incrementer() :void
+ décrementer():void
+ initialiser(): void
+valeur(): entier
+ instance():Compteur
instance_Unique
III. Les modèles de création
3.3 Le modèle monteur (objet créateur)
o Intention
• Il offre le moyen de créer des objets complexes.
• Il sépare le processus (ou l’algorithme) de création et la représentation des
objets de telle manière que le même processus puisse être utilisés par des
représentations différentes,
o Motivations
Un objet complexe peut comporter plusieurs composants et il sera crée
progressivement ( partie par partie).
RTF
ASCII
Texte; .ps
…
.pdf
III. Les modèles de création
3.3 Le modèle monteur (objet créateur)
o
Structure (micro-architecture)
Directeur
Construire()
Monteur
Construire_Partie()
MonteurConcret
Produit
Construire()
AcqProduit() : Produit
III. Les modèles de création
3.3 Le modèle monteur (objet créateur)
o
Structure (micro-architecture)
• La classe Monteur alimente la création de l’objet de type Produit.
• Le client va récupérer (à la fin du processus création) l’objet
Produit en passant par l’interface AcqProduit.
Remarque :
Possibilité de réutiliser l’algorithme de construction encapsulé par
l’opération construire offerte par la classe Directeur.
III. Les modèles de création
3.3 Le modèle monteur (objet créateur)
o
Exemple
Analyseur RTF
Conversion
ConversionCaractére()
Fichier
ConversionPolice()
construire()
ConversionParagraphe()
ASCII
Text
ConversionCaractére()
ConversionPolice()
ACQ produit()
ConversionParagraphe()
ConversionCaractére()
« crée »
AcqProduit()
« crée »
ASCII
Text
Exercice : Patron Monteur
Exercice : Patron Monteur
Exercice : Patron Monteur
Exercice : Patron Monteur
Exercice : Patron Monteur
Exercice : Patron Monteur
Exercice : Patron Monteur
Exercice : Patron Monteur
IV. Les modèles de structure
ou structuraux
IV. Les modèles structuraux
4.1 Objectifs
Les modèles de conceptions structuraux visent la composition des
objets et des classes.
Composition:
En passant par des objets : composition dynamique càd à l’exécution,
On utilise la relation fournisseur_client (UML: agrégation, composition , association..)
En passant par des classes: composition statique càd à la compilation.
On utilise la relation d’héritage (simplex ou multiple) (UML: généralisation,
spécialisation)
IV. Les modèles structuraux
4.2 Le modèle Façade
o
Intention :
- Il propose une vue simple d’un sous système.
o Motivation :
- Pour des applications complexes, on peut proposer une
décomposition par niveau.
- Ainsi l’application est perçue comme une collection de sous
systèmes.
- Un sous-système encapsule des classes (représenté par la
notion de « package » en UML).
IV. Les modèles structuraux
4.2 Le modèle Façade
Fig.1 Idée façade
o Les clients doivent faire des efforts importants pour localiser
ou identifier les classes (appartenant aux sous-systèmes)
souhaitées.
IV. Les modèles structuraux
4.2 Le modèle Façade
Clients
Fig.2
o Fig.2: Les clients visés par le patron Façade n’ont pas besoin de
personnalisation des classes appartenant au sous-système.
IV. Les modèles structuraux
o
Structures
Clients
Fig.2
IV. Les modèles structuraux
o
Constituants
o Façade :
- Elle propose une vue (interface= plusieurs services) simple
des fonctionnalités offertes par le sous-système.
- Elle délègue les requêtes (demandes) venant des clients aux
classes concernées appartenant au sous-système.
- Un seul objet « Façade » pourrait souvent faire l’affaire.
o Les classes des sous-systèmes :
- Elles ne connaissent pas Façade, càd elles ne possèdent pas
des références sur des objets Façade.
o Les clients :
- Ces classes passent inévitablement par Façade.
- Elles ne connaissent pas les classes du sous-systèmes.
IV. Les modèles structuraux
TD2
o Enoncé :
On donne les 3 classes A ,B et C exportant respectivement ra, rb
et rc. Réaliser en java une classe f sous forme d’une Façade
exportant une primitive r utilisant sous forme d’une séquence
ra, rb , rc.
IV. Les modèles structuraux
TD2
o Solution :
A
ra()
B
F
rb()
r()
application
C
rc()
Relation entre classe:
-Structurelles (association, agrégation, composition)
-Non structurelles (dépendance)
IV. Les modèles structuraux
TD2
Public class A{
Public A()
{…}
Public void ra(){ … }
}
Public class B{
Public B()
{…}
Public void rb(){ … }
}
Public class C{
Public C()
{…}
Public void rc(){ … }
}
Public class F {
Public F () { … }
Public void r(){
A a= new A();
B b= new B();
C c= new C();
a.ra();
b.rb();
c.rc();
}
}
Class Application{
Public Application()
{
F f= new F ();
f.r();
}
}
IV. Les modèles structuraux
4.3 Le modèle composite
o Intention :
- Il permet d’organiser des structures composites sous forme
arborescente ou hiérarchique.
- Ces structures comportent des objets individuels (simples ou
atomiques ou terminaux) et des objets composites (ou non
terminaux).
- Le modèle composite propose la même interface aux clients
permettant la manipulation soit des objets terminaux soit des
objets non terminaux.
o Motivation :
- Les structures (arbres, foret) sont largement utilisées en
informatique.
IV. Les modèles structuraux
4.3 Le modèle composite
o Structure:
Composant
enfant
1..*
Operation()
Ajouter(composant)
Client
Supprimer(composant)
AcqEnfant(int)
feuille
composite
Operation()
Operation()
Ajouter(composant)
Objet terminaux
Supprimer(composant)
AcqEnfant(int):composant
Objet non terminaux
IV. Les modèles structuraux
4.3 Le modèle composite
o Constituants:
Composant :
- La classe composant possède une interface commune aux
deux types d’objet : terminaux et non terminaux.
- Ainsi elle peut proposer des opérations abstraites et des
opérations abstraites ayant une implémentation par défaut (
avec souvent une sémantique qui ne fait rien) : ajouter() ,
supprimer() et AcqEnfant(int).
Feuille :
- Elle modélise un groupe d’objets terminaux.
- Elle redéfinit ou surcharge les opérations abstraites héritées
de la classe composant.
IV. Les modèles structuraux
4.3 Le modèle composite
o Constituants:
Composite :
- Elle modélise un groupe d’objets non terminaux.
- Elle peut redéfinir toutes les méthodes héritées de la classe
composant.
Client :
- Ils envoi ses requêtes au composant.
IV. Les modèles structuraux
TD3
o Enoncé:
Utiliser le modèle Composite pour modéliser les prédicats
comportant des variables booléennes, des opérateurs
booléens unaires er des opérateurs booléens binaire.
La modélisation proposée doit permettre l’évaluation des
prédicats.
o Illustration :
le prédicat (a^b) v (c^d)v Ꞁe peut être modélisé par l’arbre
suivante :
v
Ꞁ
v
^
a
^
b
c
e
d
IV. Les modèles structuraux
TD3
o Solution:
correspondance :
Variable
Feuille
Unaire
Composite
Binaire
Composite
Prédicat
Composant
Evaluation
Opération
IV. Les modèles structuraux
TD3
o Solution:
correspondance :
Application
Predicat
1
2
Evaluation() :
boolean
Binaire
Variable
evaluation():b
oolean
Unaire
evaluation():b
oolean
evaluation():b
oolean
NON
evaluation():
boolean
Et
Ou
evaluation():
boolean
evaluation():
boolean
IV. Les modèles structuraux
o
Traduction JAVA:
Public abstract class Predicat{
Public abstract boolean evaluation() ;}
Public class variable extends Predicat{
Public abstract class Unaire extends Predicat{
Protected Predicat operande ;
Protected Unaire(Predicat p){
Super();
Private boolean valeur;
Operand=p;}}
Public variable(){
Valeur= false;}
Public boolean evaluation(){
Public class NON extends Unaire{
Public NON(Predicat p){
Super(p);
Return valeur ;
}
}
Public void affecter(boolean v){
Public Boolean evaluation(){
Return ! operande.evaluation();
Valeur= v;}
}
}
IV. Les modèles structuraux
o
Traduction JAVA:
Public abstract class Binaire extends Predicat{
Public class Et extends binaire{
Public ET(Predicat g, Predicat d){
Protected Predicat gauche;
Protected Predicat droite;
Super(g,d) ;}
Public boolean evaluation(){
Protected Biniare(Predicat g, Predicat d){
}
}
Return(g.evaluation()&& d.evaluation())
Super();
}
Gauche=g;
Public class Ou extends binaire{
Droite=d;
Public Ou (Predicat g, Predicat d){
Super(g,d) ;}
Public boolean evaluation(){
Return(g.evaluation()|| d.evaluation() );
}
IV. Les modèles structuraux
Public class Exp{ Public static void main(String args[] ){
Variable a= new variable();
Variable b= new variable();
Variable c= new variable();
Variable d= new variable();
Et e1= new ET(a,b);
Et e2= new Et(c,d) ;
OU exp= new Ou(e1,e2) ;
a.affecter(true);
b.affecter(true);
c.affecter(true);
d.affecter(true);
System.out.println(“res” + exp.evaluation() );} }
V. Les modèles de
comportement ou
comportementaux
V.
Les modèles comportementaux
5.1 Objectif
• Ces modèles permettent de décrire des algorithmes, des
comportements entre objets et communication inter-objet.
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
o Intention
- Le modèle Patron de méthode définit, dans une opération
appelée « Patron méthode », le squelette d’un algorithme.
- Un tel algorithme possède des parties invariantes et des
parties variantes.
- Les parties variantes sont déléguées aux classes
descendantes (sous-classes).
- Le squelette ou la structure de l’algorithme ne doit pas être
touché par les sous-classes.
Rappel : Un algorithme est une séquence d’état qui aboutit à
une solution.
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
o Motivation
ARS : algorithme de recherche séquentiel
Cas1 : ensemble d’éléments stockés dans un tableau.
#define n 10 ;
int a[n] ;
unsigned recherche(int x){
unsigned i;
i=0;
while ((i<n)&&(a[i]!=x))
i++;
return (i<n);
}
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
Cas2: ensemble d’éléments stockés dans une liste linéaire
struct nœud
{
int cle ;
struct nœud* suivant ;
}
struct liste{
struct nœud * premier ;
struct nœud * dernier ;
}
Unsigned recherche (int x){
struct nœud *p ;
p=ll -> premier ;
while(p && p-> cle!=x)
p= p -> suivant;
return p!= null;
}
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
Remarque :
Chose semblable mais non identique : structure ou
squelette de l’algorithme de recherche séquentiel
identique dans les deux cas.
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
o Structure :
Classe abstraite
PatronMethode()
operationPrimitive1()
operationPrimitive2()
Classe concrete
operationPrimitive1()
operationPrimitive2()
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
o Constituants
• Classe abstraite :
- Elle encapsule le squelette (ou la structure) de l’algorithme dans
l’opération PatronMéthode. Celle-ci ne peut pas être surchargé par les
classes descendantes .
− Elle propose des méthodes abstraites (operationPrimitives1() et
operationPrimitives2() ) permettant de modéliser les étapes variantes
de l’algorithme. Ces méthodes ne peuvent pas être appelées par des
clients.
− L’opération PatronMéthode en tant qu’opération effective va appeler
les
opérations
abstraites
(operationPrimitives1()
et
operationPrimitives2()).
V.
Les modèles comportementaux
5.1 Le modèle Patron de méthode
o Constituants
Un tel principe permettant une structure de contrôle inversée est connu
sous le nom de principe Hollywood.
• Classe concrète :
Elle
permet
d’implémenter
les
parties
variantes
(operationPrimitives1() et operationPrimitives2()) de l’algorithme.
Remarque :
1. le modèle PatronMethode est largement utilisé dans les bibliothèques
de classe.
2. La classe abstraite est appelée également « classe comportement »
V.
Les modèles comportementaux
TD4
o Enoncé
Utiliser le patron de conception Patron méthode pour implémenter
l’algorithme de recherche séquentiel.
V.
Les modèles comportementaux
TD4
o Solution
Recherche
« final »
À ne pas surcharger
+ trouver()
#demander()
#avancer()
#courant()
#audela()
liste
tableau
#demander()
#demander()
#avancer()
#avancer()
#courant()
#courant()
#audela()
#audela()
V.
Les modèles comportementaux
TD4
Public Class Tableau extends Recherche
o Solution JAVA
{private int []a ;
Public Abstract Class Recherche
Private int position ;
{
Protected Abstract void demander() ;
Public Tableau(int [] b)
Protected Abstract void avancer();
{
Protected Abstract boolean audela():
Super() ;
Protected Abstract int courant();
a= new int [b.length] ;
Public final boolean trouve (int x)
for (int i=0; i<a.length(); i++)
{demarrer();
While( ! audela() && courant() != X)
avancer();
a[i]=b[i];
}
Protected void demarrer()
Return (!audela());
{
}
Position=0 ;
}
}
V.
Les modèles comportementaux
TD4
Public class Test
o Solution JAVA
{
Protected void avancer()
Public static void main( String [] args)
{ position ++ ;
{ int [] c= {13, 8, 4, 100, 300};
}
Tableau t= new Tableau(c) ;
Protected int courant()
System.out.println(t.trouve(13)) ;
{
System.out.println(t.trouve(8)) ;
Retrun a[position] ;
System.out.println(t.trouve(4)) ;
}
System.out.println(t.trouve(100)) ;
Protected boolean audela()
System.out.println(t.trouve(300)) ;
{return position >= a.length;
}
}
}
}
V.
Les modèles comportementaux
Question
Trouver une modélisation OO en UML de la représentation physique
donnée ci-dessus.
premier
cle suivant
dernier
V.
Les modèles comportementaux
Question
Trouver une modélisation OO en UML de la représentation physique
donnée ci-dessus.
premier
dernier
cle suivant
liste
0..1
premier
0..1
noeud
0..1
cle : integer
dernier
suivant
V.
Les modèles comportementaux
Question
JAVA
Class Nœud
{ private int valeur ;
privateNoeud suivant ;
Public Nœud (int val, Nœud s)
{valeur= val ;
suivant=s ;
}
Public int obtenir_valeur()
{return valeur ;}
Public void changer_valeur(int v){
valeur=v ;
}
Public Nœud obtenir_suivant()
{return suivant ;
}
Public void changer_suivant(Nœud s)
{suivant=s ;}}
Public class liste extends recherche
{
private Nœud premier ;
private Nœud dernier ;
private Nœud courand_ref ;
Public liste()
{super() ;
premier= null ;
dernier= null ;
}
Public void ajouter_apres_dernier(int x)
{ Nœud n= new Nœud(x,null) ;
dernier.changer_suivant(n);
dernier=n;
}
Protected void demarrer()
{courant_ref= premier ;
}
Protected void avancer()
{ courant_ref= courant_ref.obtenir_suivant() ;
}
V.
Les modèles comportementaux
Question
JAVA
Protected int courant()
{ return courant_ref.obtenir_valeur() ;
}
Protected boolean audela()
{
Return courant_ref== null ;
}
Public final void parcours()
{demarrer();
While(!=audela())
{action();
avancer();
}
}
Protected abstract void Action()
{}
}
V.
Les modèles comportementaux
5.2 Le modèle Stratégie
o Intention
- Définit une famille d’algorithmes, encapsule chacun d’entre
eux et les rend interchangeables.
- Le modèle stratégie permet aux algorithmes d’évoluer
indépendamment des clients.
o Motivation
- Un problème donné peut être résolu par plusieurs
algorithmes.
Par exemple: Tri: Tri insersion, tri selection, tri à bulle, tri
rapide, tri par tas,
V.
Les modèles comportementaux
5.2 Le modèle Stratégie
-Une mauvaise solution: codifier l’algorithme au sein de la
classe client
Class Client {…
Public void tri_insertion(){…}
…}
Problème:
- L’évoluvité de la classe Client ne sera pas aisée.
Idée forte du modèle stratégie et développer les algorithmes
et les clients.
V.
Les modèles comportementaux
5.2 Le modèle Stratégie
o Structure
Strategie
Contexte
interfaceContexte()
Strategie
interfaceAlgorithme()
StrategieConcret A
StrategieConcret B
StrategieConcret C
interfaceAlgorithme()
interfaceAlgorithme()
interfaceAlgorithme()
V.
Les modèles comportementaux
5.2 Le modèle Stratégie
o Constituant
• Strategie:
- Elle propose une interface commune à tout les algorithmes
représentés
• StrategieConcrete:
- Elle implémente l’interface proposée par la classe abstraite
« strategie »
- Elle encapsule un algorithme bien définit.
• Contexte:
-Elle modélise le contexte d’application des algorithmes
représentés
- Elle gère une référence sur un objet strategie.
- Elle peut fournir une interface offrant les données
nécessaires à l’exécution d’un algorithme représenté.
V.
Les modèles comportementaux
5.2 Le modèle Stratégie
o Collaboration
• Le client commence par choisir une stratégie concrète (à
défaut on peut lui proposer une stratégie choisie à priori) et il
configure l’objet contexte avec la stratégie choisie. Ensuite il
passe par l’objet contexte.
• Les deux classes « contexte » et « strategie » peuvent interagir
par l’implémentation d’une stratégie concrète.
• L’interaction entre contexte et strategie peut être assurée par
une référence sur un objet contexte géré par strategie, soit par
dépendances non-structurelles (paramètres formels).
V.
Les modèles comportementaux
TD5
o Enoncé
• Mettre en évidence les apports du modèle stratégie pour une
conception OO de table de hashage.
Rappel: Table de hashage
Fonction de hashage
Clef1
Clef2
1.
2.
Clef3
Clef4
…
Espace de clés
3.
m
4.
Espace des indices
V.
Les modèles comportementaux
TD5
• La fonction hashage permet de transformer une clé vers un
indice.
• Pour une entrée (où un indice appartient à [0,m-1] on peut lui
attacher plusieurs clefs.
• Ceci est connu sous le nom d’une collision.
H(k)= ord(k) mod m
ord(k)=k
11,1,6,7,13,8,14,5
n=8
m=5
0
m-1
0
5
1
11
2
7
3
13
4
14
1
8
6
V.
Les modèles comportementaux
TD5
• Fonction de hashage
Méthode de division:
h(k)= k mod m
avec m est un nombre premier et k un entier.
Méthode de multiplication:
h(k)=[h(KA, mod 1)]
KA mod 1 représente la partie décimale de KA
V.
Les modèles comportementaux
TD5
o Solution
• Correspondance
contexte
Hashage
strategie
Fonction de hashage
strategieConcret A
Division
strategieConcret B
Multiplication
V.
Les modèles comportementaux
TD5
o Solution
Hashage
ajouter()
FonctionDeHashage
Supprimer()
h(k:integer,n:integer) :integer
Rechercher()
Division
Multiplication
h(k:integer,n:integer) :integer
A:real
h(k:integer,n:integer) :integer
Affecter_A (a:real)
V.
Les modèles comportementaux
5.3 Le modèle Observateur
o Intention
- Ce modèle introduit deux concepts: sujet et observateur.
- Il permet d ’établir une interdépendance souvent de type 1
à plusieurs
- Un sujet observé par plusieurs observateurs.
- Le changement de l’objet observé entraine une
modification vers ses observateurs
V.
Les modèles comportementaux
5.3 Le modèle Observateur
o Motivation
a
b
c
80
10
10
50
30
20
40
30
30
sujet
a=50%
b=30%
c=20%
notifié
Requête pour
V.
Les modèles comportementaux
5.3 Le modèle Observateur
o Structure
Sujet
notifier()
1..*
observateur
Attache(o:observateur)
Observateur
MiseAjour()
Detache (o:observateur)
Sujet concret
Observateur concret
EtatObservateur
EtatObservateur
AcqEtat()
sujet
MiseAjour()
V.
Les modèles comportementaux
5.3 Le modèle Observateur
o Constituants
• Sujet:
- Elle propose une interface permettant d’attacher et de détacher
des observateurs dynamiquement
- Elle connait ses observateurs via une référence.
- Elle propose une interface de notification (opérateur notifié)
permettant d’informer ses observateurs d’un changement d’état
d’un sujet concret.
• Sujet concret:
- Elle mémorise l’état d’un sujet concret qui pourrait intéresser
un observateur concret
- Elle fournit une interface (AcqEtat())permettant d’aquérir son
état.
V.
Les modèles comportementaux
5.3 Le modèle Observateur
o Constituants
• Observateur:
- C’est une classe abstraite qui propose une interface de mise à
jour commune à tous les observateurs concrets
• Observateur concret:
- Elle implémente l’interface de mise a jour
- Elle mémorise un état lié aux aspect pertinents du sujet observé
- Elle gère une référence su le sujet observé (ici l’association
ayant comme rôle sujet)
V.
Les modèles comportementaux
5.3 Le modèle Observateur
o Collaboration
• Un sujet concret qui détecte un changement lié à son état active
l’opération « notifier », celle-ci informe tout les observateurs
observant ce sujet concret,
• Chaque observateur concret concerné va activer l’opération mise
à jour, celle-ci pourrait demander des renseignements auprès du
sujet concerné,
V.
Les modèles comportementaux
TD6
o Enoncé
• En utilisant le modèle observateur, proposer une C.OO d’un sujet
ayant trois grandeurs A, B et C et observés par 3 afficheurs:
tabulaire, histogramme et circulaire.
V.
Les modèles comportementaux
TD6
o Solution
Grandeur
Attacher(visualisation)
1..*
Détacher(visualisation)
Observateur
Visualisation
MiseAjour()
Notifier()
Tabulaire
Histogramme
Circulaire
A:real
A:real
A:real
GrandeurReelle
A:real
B:real
B:real
B:real
B:real
C:real
Visualisation()
C:real
Visualisation()
C:real
Visualisation()
C:real
ObtenirA ():real
Miseajour()
Miseajour()
Miseajour()
sujet
ObtenirB():real
sujet
ObtenirC():real
sujet
V.
Les modèles comportementaux
5.4 Le modèle itérateur
o Intention
- Il définit une méthode d’accès séquentielle à un agrégat
d’objet sans dévoiler sa représentation interne.
- Agrégat est un objet stockant plusieurs objets: c’est une
structure composite
o Motivation
- Des structures de données ou des agrégats (comme table,
liste linéaire, arbre, …) peuvent être parcourue en adoptant
plusieurs itinéraires,
- Table
de gauche à droite
de droite à gauche
V.
Les modèles comportementaux
5.4 Le modèle itérateur
o Motivation
Idem, pour les listes:
Liste
Premier()
Suivant()
Dernier()
Elementcourant()
Supprimer()
Ajouter()
- Il s’agit d’une mauvaise solution, car on intègre dans la
structure de donnée (ou dans l’agrégat), les opérations liées
au parcours séquentiel de cet agrégat.
- Idée: découpler des techniques séquentielles appelées
itérateurs.
V.
Les modèles comportementaux
5.4 Le modèle itérateur
o Structure
Iterateur
Premier()
Suivant()
Agregat
termine():boolean
CreerItérateur():iterateur
Elementcourant()
AgregatConcret
IterateurConcret
CreerItérateur():iterateurConcret
agregat
V.
Les modèles comportementaux
5.4 Le modèle itérateur
o Constituants
-Iterateur:
• Il offre une interface (premier, suivant, termine, elementCourant)
permettant de parcourir d’une façon séquentielle un agrégat, Bien
entendu il s’agit d’une classe abstraite.
- IterateurConcret:
• Il implémente l’interface proposée par Iterateur,
• Il gère une référence sur un agrégat concret,
• Il gère un indexe permettant de connaitre l’élément courant.
- Agregat:
• Il propose une interface abstraite permettant de créer des
itérateurs,
-AgregatConcret:
• Il implémente l’interface proposée par Agregat.
V.
Les modèles comportementaux
5.4 Le modèle itérateur
o Collaboration
-Itérateur concret assure le suivi de l’élément courant de l’agrégat et
permet de déterminer l’élément suivant dans le parcours.
V.
Les modèles comportementaux
TD7
o Enoncé
-En s’inspirant du modèle itérateur proposer deux itérateurs
permettant de parcourir un tableau de gauche à droite et de droite à
gauche.
V.
Les modèles comportementaux
TD7
o Solution
Iterateur
Premier()
Tableau
Suivant()
element(integer):T
termine():boolean
Longueur():integer
Elementcourant()
Afficher(iterateur)
agregat
agregat
GD
DG
index
index
Premier()
Premier()
Suivant()
Suivant()
termine():boolean
termine():boolean
Elementcourant()
Elementcourant()
V.
Les modèles comportementaux
TD7
Void afficher (iterateur it) {
it.premier();
While(!it.premier())
It.suivant;}
Tableur t=new Tableur();
GD g=new GD(t);
DG d=new DG(t);
t.afficher(g);
t.afficher(d);
Public class GD extends iterateur{
Private Tableau agregat;
Private int index;
Public GD(Tableau t){
Agregat=t;
…}
}
Parcourir le tableau
de droite à gauche
et de gauche à
droite en affichant
ses valeurs.
V.
Les modèles comportementaux
5.5 Le modèle commande
o Intention
- Il encapsule une requête ou une opération dans un
objet ceci permet de gérer plusieurs types de requêtes
(ou opérations).
- Il permet de proposer une solution OO au fonction
CallBack (les paramètres fonctionnels dans les
langages procéduraux)
V.
Les modèles comportementaux
5.5 Le modèle commande
o Motivation
2
Void sousprogramme (…,void(*sp)(…))
{…
(*sp)();
…
1
}
Void sp1 (…){}
Sousprogramme(…,sp1)
1:on active
2:on revient sur l’environnement
Alias:Action/transaction
V.
Les modèles comportementaux
5.5 Le modèle commande
o Structure
Commande
Invocateur
1..*
CommandeConcret
Recepteur
Client
Exécuter()
action
Exécuter()
recepteur
« crée »
V.
Les modèles comportementaux
5.5 Le modèle commande
o Constituants
• Commande:
- Déclare une interface abstraite (Executer()) pour exécuter une
opération (ou une requête)
• CommandeConcret:
- concrétise executer en appelant ou en invoquant des opérations
offertes par la classe recepteur,
- La commande concrète peut être non-autonome (dépend de la
classe récepteur) ou encore composite.
• Invocateur:
- Demande à commandeConcret d’exécuter la requête ou
l’opération.
• Récepteur:
- Collabore avec commandeConcret pour pouvoir exécuter
l’opération.
• Client:
- crée la commande concrète positionne le récepteur.
V.
Les modèles comportementaux
5.5 Le modèle commande
o Mérites
• ça découple l’invocation du récepteur.
• Il permet d’ajouter des commandes concrètes sans toucher aux
classes existantes.
V.
Les modèles comportementaux
TD8
o Enoncé
En s’inspirant du modèle commande, proposer une conception OO de
l’opération traversée d’un tableau. Une telle opération doit être
paramétrée sur l’action à effectuer sur chaque élément visité.
V.
Les modèles comportementaux
TD8
o Solution
Invocateur
1 Commande
Executer()
Parcours()
Tableau
Premier()
Suivant()
recepteur
termine():boolean
Incrementation
Afficher
Elementcourant()
Executer()
Executer()
Modifiercourant()
recepteur
V.
Les modèles comportementaux
5.5 Le modèle visiteur
o Intention
- Représente l’opération qui doit être appliquée sur les
éléments d’une structure d’objet.
o Motivation
- La traversée des structures d’objets nécessite souvent
d’effectuer une opération sur chaque élément visité.
- Les structures d’objet à traverser peuvent être
polymorphes (càd comportant plusieurs types
d’objets).
V.
Les modèles comportementaux
5.5 Le modèle visiteur
o Motivation
Class A
{void faireOp1();
void faireOp1();
.
.
.
}
- A joue le rôle de structure
d’objet à traverser.
- Prévoir toutes les
opération à effectuer sur
cette structure d’objet.
Une faible cohésion de la classe A.
V.
Les modèles comportementaux
5.5 Le modèle visiteur
Element
1..*
o Structure
Structure
d’objet
Accepter(visiteur)
ElementConcretA
ElementConcretB
Accepter(visiteur)
Accepter(visiteur)
OperationA()
OperationB()
Visiteur
Client
visiteElementConcretA(ElementConcretA)
visiteElementConcretB(ElementConcretB)
VisiteurConcretA
VisiteurConcretB
visiteElementConcretA(ElementConcretA)
visiteElementConcretA(ElementConcretA)
visiteElementConcretB(ElementConcretB)
visiteElementConcretB(ElementConcretB)
V.
Les modèles comportementaux
5.5 Le modèle visiteur
o Constituants
• Visiteur: représente une opération (visiteElementConcret) pour
chaque classe qui dérive de l ’élément. Il s’agit d’une classe
abstraite.
• VisiteurConcret: implémente l’interface proposée par visiteur.
• Structure d’objet: représente la structure d’objet polymorphe à
traverser.
-Crée une référence avec multiplicité sur la classe abstraite
Element.
• Element: représente la classe fondatrice de différents types
d’objets.
-Propose une interface appelée Accepter permettant d’activer le
visiteur concret adéquat.
• ElementConcret: implémente l’interface proposée par Element.
V.
Les modèles comportementaux
TD9
o Enoncé
En s’inspirant du modèle Visiteur, proposer une conception OO
permettant de traverser une bibliothèque contenant plusieurs livres.
Les opérations à appliquer sur chaque livre visité sont:
-Afficher les caractéristiques (titre, prix,..)
-Modifier
V.
Les modèles comportementaux
TD9
o Solution
Test
Element
make
Accepter(v:visiteur)
Visiteur
Visitelivre(Livre)
Livre
Accepter(v:visiteur)
Afficher
modifier
modifierPrix(mp:integer)
Visitelivre(Livre)
Visitelivre(Livre)
Name(t:string,p:integer)
Merci!
Des questions?
Téléchargement
Explore flashcards