[Java] Modifier le traitement en fonction de la situation avec le modèle de stratégie

J'ai découvert l'un des modèles de conception, le modèle de stratégie, alors je vais le résumer.

Quel est le modèle de stratégie?

Qu'est-ce que le modèle de stratégie? [Modèle de conception] du GoF (https://ja.wikipedia.org/wiki/%E3%83%87%E3%82%B6%E3%82%A4%E3%83%B3%E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3_ (% E3% 82% BD% E3% 83% 95% E3% 83% 88% E3% 82% A6% E3% 82 C'est l'un des% A7% E3% 82% A2)).

Stratégie signifie ** «stratégie» **, Le modèle de stratégie est un modèle de conception pour ** changer le comportement d'un objet en fonction de la situation **.

Avantages du modèle de stratégie

• La séparation du traitement améliore la facilité de maintenance
• Si vous souhaitez ajouter une nouvelle stratégie, ajoutez simplement une classe qui hérite de l'interface Stratégie.
• En encapsulant le processus, l'appelant peut l'utiliser sans être conscient du contenu spécifique du processus.

En fait utiliser

Cette fois, je prendrai Pikachu de Pokemon comme exemple et changerai la technique (stratégie, comportement) en fonction de la situation.

Le modèle de stratégie exige que chaque stratégie ait une ** interface commune **.

Préparez l'interface AtackStrategy ci-dessous.

AttackStrategy.java

/**
*Interface d'attaque
*/
public interface AttackStrategy {
    public void attack();
}

Ensuite, préparez une classe qui implémente l'interface ci-dessus pour chaque stratégie.

Remplacez la méthode décrite dans l'interface et décrivez le traitement réel.

Cette fois, seule la sortie standard est utilisée, mais il est possible de décrire un traitement plus compliqué.

ToGoodTypeConcreteStrategy.java

/**
*Stratégie lorsque l'ennemi est un bon attribut
*/
public class ToGoodTypeConcreteStrategy implements AttackStrategy {

    @Override
    public void attack() {
        System.out.println("100 000 volts!");
    }
}

ToBadTypeConcreteStrategy.java

/**
*Stratégie lorsque l'ennemi n'est pas bon dans ce domaine
*/
public class ToBadTypeConcreteStrategy implements AttackStrategy {

    @Override
    public void attack() {
        System.out.println("C'est un alter ego de l'ombre!");
    }
}

Ensuite, préparez une classe Pikachu qui a la variable _attackStrategy de l'interface AttackStrategy préparée ci-dessus comme champ.

La classe Pikachu définit un constructeur et un setter pour initialiser _attackStrategy.

Aussi, définissez ʻattack () pour appeler ʻAttackStrategy # attack (). (transfert)

C'est le point du modèle de stratégie, et même si seul ʻattack () `est défini dans la classe PikachuContex, le contenu du traitement réel peut être changé en fonction de la situation.

PikachuContext.java

public class PikachuContext {
    private AttackStrategy _attackStrategy;

    public Pikachu(AttackStrategy strategy) {
        setStrategy(strategy);
    }

    public void attack() {
        _attackStrategy.attack();
    }
}

C'est tout pour la préparation. Je vais vraiment l'utiliser.

Main.java

public class Main {

    public static void main(String[] args) {

        PikachuContext pikachu;

        //Quand l'ennemi est un bon attribut
        pikachu= new PikachuContext(new ToGoodTypeConcreteStrategy());
        pikachu.attack(); // "100 000 volts!"Est sortie

        //Si l'ennemi n'est pas doué pour ça
        pikachu = new PikachuContext(new ToBadTypeConcreteStrategy());
        pikachu.attack(); // "C'est un alter ego de l'ombre!"Est sortie
    }
}