modèle de stratégie

Dans Strategy Pattern, le comportement d'une classe ou son algorithme peut être modifié au moment de l'exécution. Ce type de modèle de conception est un modèle comportemental.

Dans le modèle de stratégie, nous créons des objets qui représentent diverses stratégies et un objet de contexte dont le comportement change à mesure que l'objet de stratégie change. L'objet stratégie modifie l'algorithme d'exécution de l'objet contexte.

Introduction

Intention : Définir une série d'algorithmes, les encapsuler un par un et les rendre interchangeables.

Solution principale : La complexité et la difficulté de maintenance causées par l'utilisation de if...else lorsqu'il existe plusieurs algorithmes similaires.

Quand utiliser : Un système a de très nombreuses classes, et ce qui les distingue est leur comportement direct.

Comment résoudre : Encapsulez ces algorithmes dans des classes un par un et remplacez-les arbitrairement.

Code clé : Implémentez la même interface.

Exemples d'application : 1. Les conseils de Zhuge Liang, chaque conseil est une stratégie. 2. Comment voyager, choisir de faire du vélo ou de prendre une voiture. Chaque façon de voyager est une stratégie. 3. LayoutManager dans JAVA AWT.

Avantages : 1. L'algorithme peut être commuté librement. 2. Évitez d’utiliser plusieurs jugements conditionnels. 3. Bonne évolutivité.

Inconvénients : 1. Les catégories de stratégie augmenteront. 2. Tous les cours de stratégie doivent être exposés au monde extérieur.

Scénarios d'utilisation : 1. S'il existe de nombreuses classes dans un système et que la différence entre elles réside uniquement dans leur comportement, alors le modèle de stratégie peut être utilisé pour faire en sorte qu'un objet se comporte dynamiquement dans plusieurs façons. Choisissez un comportement. 2. Un système doit choisir dynamiquement l’un des nombreux algorithmes. 3. Si un objet a de nombreux comportements, ces comportements doivent être implémentés à l'aide de plusieurs instructions de sélection conditionnelle sans utiliser de modèles appropriés.

Remarque : Si un système dispose de plus de quatre stratégies, vous devez envisager d'utiliser le mode mixte pour résoudre le problème de l'expansion des classes de politiques.

Implémentation

Nous allons créer une interface Stratégie qui définit l'activité et une classe de stratégie d'entité qui implémente l'interface Stratégie. Context est une classe qui utilise une certaine stratégie.

StrategyPatternDemo, notre classe de démonstration utilise Context et un objet de stratégie pour démontrer les changements de comportement d'un Context lorsque les stratégies qu'il configure ou utilise changent.

Étape 1

Créer une interface.

Strategy.java

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

Étape 2

Créez une classe d'entité qui implémente l'interface.

OperationAdd.java

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

OperationSubstract.java

public class OperationSubstract 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éez la classe Context.

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

Utilisez Context pour voir quand il change de stratégieStratégie le comportement change quand.

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 OperationSubstract());		
      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

Vérifiez le résultat.

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