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

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#🎜 🎜#

• 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.

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 :

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

flying et cannot fly

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("我会飞");
    }
}

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

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

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

/**
 * 小鸭子，还不会飞
 */
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

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("***测试完毕***");
    }
}