Comment implémenter le modèle de stratégie Java à l'aide de code

Modèle de stratégie

Le modèle de stratégie est l'un des 23 modèles de conception en Java. est le mode stratégie.

1. Quel est le modèle de stratégie pour qu'ils puissent être échangés sans aucun impact sur l'utilisation du client ? Le modèle de stratégie appartient au modèle de comportement des objets. Il encapsule l'algorithme, sépare la responsabilité de l'utilisation de l'algorithme de la mise en œuvre de l'algorithme et délègue la gestion de ces algorithmes à différents objets.

En fait, dans la vraie vie, nous rencontrons souvent des situations où il existe plusieurs stratégies parmi lesquelles choisir pour atteindre un certain objectif. Par exemple, lorsque vous voyagez, vous pouvez prendre un avion, prendre un train, voyager. un vélo, ou conduire votre propre voiture privée, etc. Ou par exemple, pour les achats en ligne, vous pouvez choisir la Banque industrielle et commerciale de Chine, la Banque agricole de Chine, la Banque de construction de Chine, etc., mais les algorithmes qu'elles fournissent sont tous les mêmes, c'est-à-dire pour vous aider à payer .

Nous rencontrerons également des situations similaires dans le développement de logiciels. Lorsqu'il existe plusieurs algorithmes ou stratégies pour implémenter une certaine fonction, nous pouvons choisir différents algorithmes ou stratégies en fonction de différents environnements ou conditions. remplir cette fonction.

2. Avantages et inconvénients du mode stratégie

Avantages :

Plusieurs instructions conditionnelles ne sont pas faciles à maintenir, et l'utilisation du modèle de stratégie peut éviter l'utilisation de plusieurs instructions conditionnelles

Grâce à l'héritage, le code commun de la famille d'algorithmes peut être placé dans la classe parent pour éviter la réutilisation du code et fournir une série d'algorithmes réutilisables
Fournissez différentes implémentations du même comportement, les clients peuvent choisir différentes
• en fonction de différentes exigences de temps ou d'espace

fournit un support parfait pour le principe d'ouverture et de fermeture et peut ajouter de nouveaux algorithmes de manière flexible sans modifier le code d'origine

• L'utilisation de
est placée dans la classe d'environnement et l'implémentation de l'algorithme est déplacée vers la classe de stratégie spécifique, réalisant la séparation des deux
• Inconvénients :

Le client doit comprendre la différence entre tous les algorithmes de stratégie afin de choisir la classe d'algorithme appropriée au bon moment#🎜 🎜#

Le modèle de stratégie crée de nombreuses classes de stratégie, ce qui augmente la difficulté de maintenance

• 3 La structure du. modèle de stratégie
• 1. Classe de stratégie abstraite : Définit une interface publique. Différents algorithmes implémentent cette interface de différentes manières. Les rôles environnementaux utilisent cette interface pour appeler différents algorithmes, généralement en utilisant des interfaces ou des classes abstraites.
  2. Classe de stratégie spécifique : implémente l'interface définie par la stratégie abstraite et fournit une implémentation d'algorithme spécifique.

3. Classe d'environnement : contient une référence à une classe de stratégie, qui est finalement appelée par le client.

Schéma de structure :

4. #Maintenant il y a trois canards : Canard vert, canard rouge, petit canard (le petit canard ne sait pas encore voler)

Définissez maintenant le parent de un canard Classe :

Il existe des méthodes qui peuvent être appelées, et il existe des méthodes qui montrent l'apparence (car chacune est différente, elle doit être réécrite par une sous-classe)

Cela peut voler aussi

(ici Utilisation du mode stratégie)

public  abstract class duck {
    //鸭子都会叫：
    public void quack(){
        System.out.println("嘎嘎嘎");
    }
    //鸭子的外观，因为都不一样，所以由子类去实现
    public abstract void display();
	
	//以下使用策略模式：
    //在父类中持有该接口，并由该接口代替飞行行为（组合）
    private Flying flying;
    //提供set方法
    public void setFlying(Flying flying) {
        this.flying = flying;
    }
    public void fly(){
        flying.Fly();
    }
}

Définir une interface de vol :

/**
 * 策略接口：实现了鸭子的飞行行为
 */
public interface Flying {
    void Fly();
}

On le sait le mode stratégie consiste à encapsuler l'algorithme qui doit être utilisé. Levez-vous, il existe deux méthodes de

flying et cannot fly

encapsulées dans un autre

package#🎜 🎜# : # 🎜🎜# Peut voler (hérité de l'interface de vol ci-dessus, remplace la méthode de vol) :

public class FlyWithWin implements Flying {
    @Override
    public void Fly() {
        System.out.println("我会飞");
    }
}

Can' t fly : #🎜 🎜#

public class FlyNoWay implements Flying {
    @Override
    public void Fly() {
        System.out.println("我不会飞行");
    }
}

Remarque : J'encapsule les deux méthodes ci-dessus séparément en tant que famille d'algorithmes, puis lorsque le programme doit utiliser l'un des algorithmes , le programme ne sera pas affecté par l'algorithme. L'impact du changement, car l'effet final de l'algorithme ici est le même Canard :

/**
 * 红色鸭子
 */
public class RedDuck extends duck{
    public RedDuck(){
        super();
        //给鸭子注入飞行的能力，这里就是通过算法族里面的会飞的算法
        super.setFlying(new FlyWithWin());
    }
    @Override
    public void display() {
        System.out.println("我是红色的鸭子");
    }
}

Type petit canard. (ne peut pas voler) :

/**
 *
 * 绿色鸭子
 */
public class GreenDuck extends duck{
    public GreenDuck(){
        super();
        //给鸭子注入飞行的能力，这里也是通过算法族里面的会飞的算法
        super.setFlying(new FlyWithWin());
    }
    @Override
    public void display() {
        System.out.println("我是绿色的鸭子");
    }
}

Type de test : #🎜 🎜#

/**
 * 小鸭子，还不会飞
 */
public class SamllDuck extends duck{
    public SamllDuck(){
        super();
        //小鸭子不会飞，所以使用了算法族里面不会飞的算法
        super.setFlying(new FlyNoWay());
    }

    @Override
    public void display() {
        System.out.println("我还是小鸭子");
    }
    //因为小鸭子和大鸭子的叫声不一样，所以重写叫声方法
    public void quack(){
        System.out.println("嘎~嘎~嘎");
    }
}

Lorsque vous utilisez le canard aux cheveux roux comme l'objet :

***Programme test canard***# 🎜🎜#我是红鸭Quackaqua

我可以飞#🎜 🎜#***Test terminé***

quand Lors de l'utilisation du canard vert comme objet :

public class Test {
    public static void main(String[] args) {
        System.out.println("***测试鸭子程序***");
        duck d = null;
		//这下面是轮流运行！！！！  
        d = new RedDuck();  //测试红色的鸭子
        d = new GreenDuck();  //测试绿色的鸭子
        d = new SamllDuck();  //测试小鸭子
        d.display();
        d.quack();
        d.fly();
        System.out.println("***测试完毕***");
    }
}

# 🎜🎜# Lors de l'utilisation du petit canard comme objet :

* **Test du programme canard***

我是小鸭

GA~GA~GAJe ne peux pas voler***Test terminé***

# 🎜🎜#

5. 🎜🎜#1. Lorsqu'un système doit sélectionner dynamiquement un algorithme parmi plusieurs, chaque algorithme peut être encapsulé dans une classe de stratégie# 🎜🎜#

2 Une classe définit plusieurs comportements, et ces comportements apparaissent sous la forme de. plusieurs instructions conditionnelles dans le fonctionnement de cette classe. Chaque branche conditionnelle peut être déplacée dans ses classes de stratégie respectives. Ces instructions conditionnelles

3. les détails de mise en œuvre d'algorithmes spécifiques doivent être cachés aux clients

4. Lorsque le système exige que les clients utilisant l'algorithme ne connaissent pas les données sur lesquelles ils opèrent, le modèle de stratégie peut être utilisé pour masquer les structures de données liées à l'algorithme

5. Plusieurs classes ne diffèrent que par leur comportement en termes de performances, et. le modèle de stratégie peut être utilisé pour sélectionner dynamiquement le comportement spécifique à exécuter au moment de l'exécution

.

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!