Le patron de conception Strategy

1
Le patron de conception  Strategy 

• Simon Durocher (2907206)

2
Le principe général du patron

• Le patron  Strategy  cherche principalement à
  séparer un objet de ses comportements/algorithmes
  en encapsulant ces derniers dans des classes à
  part.
• Pour ce faire, on doit alors définir une famille
  de comportements ou dalgorithmes encapsulés et
  interchangeables.

3
Le problème général résolu par le patron

• Le patron  Strategy  est utilisé lorsque
• Un problème possède plusieurs algorithme pour le
  résoudre.
• Surtout si les algorithmes possèdent différents
  efficacités dans différentes situations.
• Un objet peut avoir plusieurs comportements
  différents.
• Aussi applicable lorsque différentes classes sont
  seulement différentes daprès leur comportement.
• Des données que lutilisateur ne devrait pas
  connaître se retrouve dans un algorithme.

4
Les avantages du patron

• Si les algorithmes/comportements sont dans une
  classe a part, il est beaucoup plus facile de
• se retrouver dans le code principale
• enlever, ajouter et modifier un
  algorithme/comportement
• diminuer lutilisation de tests conditionnels
• éliminer la redondance et le couper/coller
• accroître la réutilisabilité du code ainsi que sa
  flexibilité

5
Limplémentation du patron

• Pour implémenter le patron  Strategy  ont doit
• 1. Définir une interface commune à tout les
  algorithmes ou comportements de même
  famille.
• Ceci ce fait habituellement en créant une classe
  abstraite.
• Ceci nous assure que tout les stratégies vont
  avoir les paramètres nécessaire à leur bon
  fonctionnement quitte à ce que certaines
  reçoivent des paramètres non nécessaires.
• 2. Créer les classes comportant les algorithmes
  ou les comportements à partir de
  linterface commune.
• 3. Utilisé la stratégie voulu dans le code de
  lobjet.

6
Représentation du patron
7
Les participants

• Dans limage précédente, les participants sont
• Strategy
• Linterface commune de toute les stratégies.
• Utilisé par Context pour appelé une stratégie
  concrète.
• ConcreteStrategy
• Utilise linterface Strategy pour implémenté un
  algorithme.
• Context
• Maintient une référence à un objet Strategy.
• Est configuré avec une ConcreteStrategy.

8
Exemple dutilisation du patron

• Calculer la vitesse verticale avec différentes
  stratégies.
• Sans gravité ni friction.
• Avec gravité seulement.
• Avec friction seulement.
• Avec gravité et friction.
• Paramètres nécessaires
• Vitesse initiale.
• Temps.
• Gravité.
• Friction.

9
Classe BalleStrategy (interface commune)

• On commence par définir linterface commune dans
  une classe abstraite.
• abstract class BalleStrategy
• abstract public float vitesse(float v_in, float
  temps, float grav, float fric)

10
Classe BalleStrategyRien (stratégie 1)

• Ensuite on définit les stratégies dans des
  classes.
• class BalleStrategyRien extends BalleStrategy
• public float vitesse(float v_in, float temps,
  float grav, float fric)
• return v_in

11
Classe BalleStrategyGrav (stratégie 2)

• class BalleStrategyGrav extends BalleStrategy
• public float vitesse(float v_in, float temps,
  float grav, float fric)
• return (v_in - gravtemps)

12
Classe BalleStrategyFric (stratégie 3)

• class BalleStrategyFric extends BalleStrategy
• public float vitesse(float v_in, float temps,
  float grav, float fric)
• return (v_in - tempsfric)

13
Classe BalleStrategyGravFric (stratégie 4)

• class BalleStrategyGravFric extends BalleStrategy
• public float vitesse(float v_in, float temps,
  float grav, float fric)
• return (v_in - (gravfric)temps)

14
Classe BalleContext

• Ensuite on crée la classe de lobjet.
• class BalleContext
• BalleStrategy strat
• public BalleContext( BalleStrategy strategy )
• this.strat strategy
• public float ContextInterface(float v_in, float
  temps, float grav, float fric)
• return (strat.vitesse(v_in, temps, grav,
  fric))

15
BalleProg

• Finalement on utilise lobjet dans un programme.
• public class BalleProg
• public static void main(String args)
• float m0
• BalleContext bc new BalleContext( new
  BalleStrategyRien() )
• m bc.ContextInterface(2, 3, 4, 5)
• System.out.println("Avec la stregie Rien, on
  obtient " m)
• BalleContext bc2 new BalleContext( new
  BalleStrategyGravFric() )
• m bc2.ContextInterface(2, 3, 4, 5)
• System.out.println("Avec la stregie GravFric,
  on obtient " m)

16
Références

• http//www.exciton.cs.rice.edu/JavaResources/Desig
  nPatterns/StrategyPattern.htm
• http//www.scriptsphp.net/article.Le-design-patter
  n-Strategy
• http//www.dofactory.com/Patterns/PatternStrategy.
  aspx
• http//www.patterndepot.com/put/8/JavaPatterns.htm
  

17
Questions