Introduction au modèle de stratégie et au modèle de méthode de modèle en Java (avec code)

Cet article vous présente le modèle de stratégie et le modèle de méthode de modèle en Java (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Modèle de stratégie

Introduction

Le modèle de stratégie appartient au modèle de comportement d'un objet. Son objectif est d'encapsuler chaque algorithme dans une classe indépendante avec une interface commune pour un ensemble d'algorithmes, afin qu'ils puissent être remplacés les uns par les autres. Le modèle de stratégie permet à l'algorithme de changer sans affecter le client.
L'objectif principal est de remplacer l'écriture d'instructions if else par la définition d'algorithmes similaires, et ils peuvent être remplacés les uns par les autres à tout moment.

Le mode Stratégie est principalement composé de ces trois rôles, le rôle environnemental (Contexte), le rôle stratégique abstrait (Stratégie) et le rôle stratégique concret (ConcreteStrategy).

• Rôle d'environnement (Contexte) : détient une référence à une classe de stratégie et la fournit au client.

• Rôle de stratégie abstraite (Stratégie) : Il s'agit d'un rôle abstrait, généralement implémenté par une interface ou une classe abstraite. Ce rôle fournit toutes les interfaces requises par les classes de stratégie spécifiques.

• Rôle de stratégie concrète (ConcreteStrategy) : emballe des algorithmes ou des comportements liés.

Le schéma d'exemple est le suivant :

Pour faciliter la compréhension, reprenons la méthode de calcul utilisée lors de notre premier apprentissage de Java.
Lors de l'utilisation d'une calculatrice pour les calculs, les méthodes d'addition, de soustraction, de multiplication et de division sont souvent utilisées. Si nous voulons obtenir la somme de l'addition de deux nombres, nous devons utiliser le signe "+", pour obtenir la différence de la soustraction, nous devons utiliser le signe "-", et ainsi de suite. Bien que nous puissions écrire une méthode générale en utilisant if/else via une comparaison de chaînes, chaque fois que le symbole calculé est ajouté, nous devons ajouter le code correspondant à la méthode d'origine. Si la méthode de calcul suivante est ajoutée, modifiée ou supprimée, cela sera le cas. rendre difficile la maintenance ultérieure.
Mais parmi ces méthodes, nous avons constaté que la méthode de base est fixe.À l'heure actuelle, nous pouvons développer un modèle de stratégie, ce qui peut efficacement éviter le jugement par if/else, même si d'autres règles de calcul sont ajoutées ultérieurement. faire des ajustements.

Définissez d’abord un rôle stratégique abstrait et disposez d’une méthode de calcul.

interface CalculateStrategy {
   int doOperation(int num1, int num2);
}

Définissez ensuite les rôles stratégiques spécifiques de l'addition, de la soustraction, de la multiplication et de la division et mettez-les en œuvre.

Ensuite, le code est le suivant :

class OperationAdd implements CalculateStrategy {
   @Override   public int doOperation(int num1, int num2) {
          return num1 + num2;
   }
}
class OperationSub implements CalculateStrategy {
   @Override   public int doOperation(int num1, int num2) {
          return num1 - num2;
   }
}
class OperationMul implements CalculateStrategy {
   @Override   public int doOperation(int num1, int num2) {
          return num1 * num2;
   }
}
class Operationp implements CalculateStrategy {
   @Override   public int doOperation(int num1, int num2) {
          return num1 / num2;
   }
}

Enfin, définissez un rôle d'environnement et fournissez une interface informatique que le client peut utiliser.
Le code est le suivant :

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

Après l'avoir écrit, testons-le.
Le code du test est le suivant :

    public static void main(String[] args) {
          int a=4,b=2;
          CalculatorContext context = new CalculatorContext(new OperationAdd());    
          System.out.println("a + b = "+context.executeStrategy(a, b));
     
          CalculatorContext context2 = new CalculatorContext(new OperationSub());      
          System.out.println("a - b = "+context2.executeStrategy(a, b));
     
          CalculatorContext context3 = new CalculatorContext(new OperationMul());    
          System.out.println("a * b = "+context3.executeStrategy(a, b));
    
          CalculatorContext context4 = new CalculatorContext(new Operationp());    
          System.out.println("a / b = "+context4.executeStrategy(a, b));
}

Résultat de sortie :

a + b = 6
a - b = 2
a * b = 8
a / b = 2

Avantages du mode stratégie :

Bonne évolutivité, vous pouvez ajouter de nouvelles classes pour implémenter de nouveaux algorithmes sans modifier la structure de l'objet
Bonne flexibilité, vous pouvez modifier librement l'algorithme Switch

Inconvénients du mode Stratégie :

L'utilisation de plus de classes de stratégie augmentera la complexité du système. ;
Le client doit connaître toutes les classes de polices avant d'appeler;

Scénarios d'utilisation :

S'il existe de nombreuses classes dans un système et que la différence entre elles réside uniquement dans leur comportement, alors l'utilisation du modèle de stratégie peut permettre à un objet de choisir dynamiquement un comportement parmi de nombreux comportements
A ; le système doit choisir dynamiquement l'un des nombreux algorithmes ;
Si un objet a de nombreux comportements, sans modèles appropriés, ces comportements doivent utiliser plusieurs instructions de sélection conditionnelle pour y parvenir ;

Modèle de modèle

Introduction

Dans Modèle de modèle, une classe abstraite définit publiquement la manière/le modèle de la méthode pour l'exécuter. Ses sous-classes peuvent remplacer l'implémentation de la méthode si nécessaire, mais les appels seront effectués de la manière définie dans la classe abstraite. Ce type de modèle de conception est un modèle comportemental. Définir le squelette d'un algorithme en une seule opération, en reportant certaines étapes aux sous-classes.

Mode Modèle, son idée principale est de créer un modèle et de le fournir au client pour appel. En plus des modèles de CV, de contrats, etc. que nous utilisons souvent dans la vie, il existe également des modèles très classiques utilisés en Java, c'est-à-dire que la classe HttpService fournit une méthode service(), qui appelle l'une des sept méthodes. méthodes ou Plusieurs réponses complètes aux appels des clients. Ces méthodes do doivent être fournies par la sous-classe spécifique de HttpServlet.

Le mode Modèle est principalement composé du rôle Modèle abstrait et du rôle Modèle concret.

• 抽象模板(Abstract Template): 定义了一个或多个抽象操作，以便让子类实现。这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤;定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体方法。

• 具体模板(Concrete Template): 实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤;每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。

示例图如下:

这里为了方便理解，我们依旧使用一个简单的示例来加以说明。
我们以前在玩魂斗罗、双截龙、热血物语、忍者神龟等等游戏的时候，都需要在小霸王游戏机上插卡，然后启动游戏才能玩，其中魂斗罗这种游戏，启动游戏之后就可以直接玩了，但是忍者神龟这种游戏则在启动游戏之后，需要选择其中一个角色才能开始玩。那么我们可以根据这个场景写出一个通用的模板，主要包含启动游戏，玩游戏，结束游戏这几个必须实现的方法，选择人物这个方法改成可选。

那么这个抽象类的代码如下:

abstract class  Game{    
    //启动游戏    
    protected abstract void  runGame();    
    //选择人物    
    protected  void choosePerson() {};    
    //开始玩游戏    
    protected abstract void startPlayGame();    
    //结束游戏    
    protected abstract void endPlayGame();    
    //模板方法    
    public final void play() {
        runGame();
        choosePerson();
        startPlayGame();
        endPlayGame();
    }
    
}

定义好该抽象类之后，我们再来定义具体模板实现类。这里定义两个游戏类，一个是魂斗罗，一个忍者神龟。

那么代码如下:

class ContraGame extends Game{   @Override   protected void runGame() {
       System.out.println("启动魂斗罗II...");
   }   
@Override   protected void startPlayGame() {
          System.out.println("1P正在使用S弹打aircraft...");
   }   
@Override   protected void endPlayGame() {
          System.out.println("1P被流弹打死了，游戏结束！");
   }
}
class TMNTGame extends Game{
   @Override   protected void runGame() { 
         System.out.println("启动忍者神龟III...");
   }   
   @Override   protected void choosePerson() {       System.out.println("1P选择了Raph ！");
   }   
   @Override   protected void startPlayGame() {
          System.out.println("Raph正在使用绝技 “火箭头槌” ");
   }   
   @Override   protected void endPlayGame() {
          System.out.println("Raph 掉进井盖里死了，游戏结束了！ ");
   }
}

最后再来进行测试，测试代码如下:

public static void main(String[] args) {
       Game game = new ContraGame();
       game.play();
       System.out.println();
       game = new TMNTGame();
       game.play();

}

输出结果:

启动魂斗罗II...1P正在使用S弹打aircraft...1P被流弹打死了，游戏结束！

启动忍者神龟III...1P选择了Raph ！
Raph正在使用绝技 “火箭头槌” 
Raph 掉进井盖里死了，游戏结束了！

模板模式优点：

扩展性好，对不变的代码进行封装，对可变的进行扩展；
可维护性好，因为将公共代码进行了提取，使用的时候直接调用即可；

模板模式缺点：

因为每一个不同的实现都需要一个子类来实现，导致类的个数增加，会使系统变得复杂；

使用场景：

有多个子类共有逻辑相同的方法；
重要的、复杂的方法，可以考虑作为模板方法。

注意事项：

为防止恶意操作，一般模板方法都加上 final 关键词！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!