Patron Stratégie

Dans le patron Stratégie, le comportement d'une classe ou son algorithme peut être modifié à l'exécution. Ce type de patron de conception appartient à la catégorie des patrons comportementaux.

Le patron Stratégie définit une série d'algorithmes ou de stratégies, et encapsule chaque algorithme dans une classe indépendante, ce qui permet de les interchanger. En utilisant le patron Stratégie, différents algorithmes peuvent être sélectionnés à l'exécution selon les besoins sans modifier le code client.

Dans le patron Stratégie, nous créons des objets représentant diverses stratégies et un objet contexte dont le comportement change lorsque l'objet stratégie change. L'objet stratégie modifie l'algorithme d'exécution de l'objet contexte.

Introduction

intention

Encapsuler chaque algorithme afin qu'ils puissent être utilisés de manière interchangeable.

Principaux problèmes résolus

  • Résoudre le problème de complexité et de difficulté de maintenance causé par l'utilisation d'instructions conditionnelles (telles que if...else) lorsque plusieurs algorithmes similaires existent.

Cas d'utilisation

  • Lorsqu'il y a de nombreuses classes dans un système, et que la seule différence entre elles est leur comportement.

Approche d'implémentation

  • Définir l'interface de stratégie: Toutes les classes de stratégie implémenteront cette interface unifiée.
  • Créer des classes de stratégie concrètes: Chaque classe de stratégie encapsule un algorithme ou un comportement spécifique.
  • Classe Contexte: Contient une référence à un objet de stratégie et invoque la stratégie via cette référence.

Code clé

  • Interface de stratégie: Spécifie les méthodes que toutes les classes de stratégie doivent implémenter.
  • Classe de stratégie concrète: Implémente l'interface de stratégie et contient l'implémentation concrète de l'algorithme.

Exemple d'application

  1. Ruse ingénieuse: Chaque sac de sagesse représente une stratégie, contenant un plan différent.
  2. Sélection du mode de déplacement: Faire du vélo, prendre une voiture, etc. Chaque mode est une stratégie remplaçable.
  3. LayoutManager de Java AWT: Différents gestionnaires de disposition implémentent la même interface mais fournissent différents algorithmes de disposition.

Avantages

  1. Changement libre d'algorithme: Il permet de changer d'algorithme à l'exécution selon les besoins.
  2. Éviter les tests conditionnels multiples.: Cela élimine les instructions conditionnelles complexes.
  3. Bonne extensibilité: L'ajout d'un nouvel algorithme nécessite uniquement l'ajout d'une nouvelle classe de stratégie, sans modifier le code existant.

Inconvénients

  1. Nombre croissant de classes de stratégie: Chaque algorithme supplémentaire nécessite une classe de stratégie supplémentaire.
  2. Toutes les classes de stratégie doivent être exposées.: Les classes de stratégie doivent être exposées publiquement afin qu'elles puissent être sélectionnées et utilisées.

Suggestions d'utilisation

  • Lorsqu'il existe plusieurs algorithmes ou comportements dans le système, et qu'ils peuvent se remplacer mutuellement, utilisez le patron de stratégie.
  • Lorsque le système doit sélectionner dynamiquement des algorithmes, le patron de stratégie est un choix approprié.

Notes

  • Si le nombre de classes de stratégie dans le système est trop important, envisagez d'utiliser d'autres patrons ou techniques de conception pour résoudre le problème d'explosion des classes.

Structure

Le patron de stratégie comprend les rôles principaux suivants :

  • Contexte: Maintient une référence à un objet stratégie et est chargé de déléguer les requêtes du client à l'objet stratégie spécifique pour exécution. La classe de contexte peut obtenir des objets stratégie spécifiques par injection de dépendances, fabrique simple et autres méthodes.
  • Stratégie abstraite: Définit l'interface publique ou la classe abstraite des objets stratégie, et spécifie les méthodes que les classes de stratégie concrètes doivent implémenter.
  • Stratégie concrète: Implémente l'interface ou la classe abstraite définie par la stratégie abstraite, et contient l'implémentation concrète de l'algorithme.

Le patron de stratégie fournit un moyen de sélectionner dynamiquement différents algorithmes en découplant les algorithmes du code qui les utilise. Le code client n'a pas besoin de connaître les détails de l'algorithme spécifique ; au lieu de cela, il utilise la stratégie sélectionnée en appelant la classe de contexte.

Implémentation

Nous allons créer une activité définissantStrategyInterfaces et implémentationsStrategyclasse de stratégie concrète de l'interface.Contextest une classe qui utilise une certaine stratégie.

StrategyPatternDemo, notre classe de démonstration utiliseContextet des objets stratégie pour démontrer les changements de comportement du Context lorsque la stratégie avec laquelle il est configuré ou qu'il utilise change.

策略模式的 UML 图

Étape 1

Créer une interface.

Strategy.java

public interface Strategy { public int doOperation(int num1, int num2); }

Étape 2

Créez des classes concrètes qui implémentent l'interface.

OperationAdd.java

public class OperationAdd implements Strategy{ @Override public int doOperation(int num1, int num2) { return num1 + num2; } }

OperationSubtract.java

public class OperationSubtract implements Strategy{ @Override public int doOperation(int num1, int num2) { return num1 - num2; } }

OperationMultiply.java

public class OperationMultiply implements Strategy{ @Override public int doOperation(int num1, int num2) { return num1 * num2; } }

Étape 3

CréerContextclasse.

Context.java

public class Context { private Strategy strategy; public Context(Strategy strategy){ this.strategy = strategy; } public int executeStrategy(int num1, int num2){ return strategy.doOperation(num1, num2); } }

Étape 4

UtilisationContextpour voir quand il change de stratégieStrategyChangements de comportement à l'exécution.

StrategyPatternDemo.java

public class StrategyPatternDemo { public static void main(String[] args) { Context context = new Context(new OperationAdd()); System.out.println("10 + 5 = " + context.executeStrategy(10, 5)); context = new Context(new OperationSubtract()); System.out.println("10 - 5 = " + context.executeStrategy(10, 5)); context = new Context(new OperationMultiply()); System.out.println("10 * 5 = " + context.executeStrategy(10, 5)); } }

Étape 5

Exécutez le programme et affichez les résultats :

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
autres extensions