Analyse d'exemple de modèle de stratégie de modèle de conception Java

1. Introduction de base

1) Dans Strategy Pattern, les familles d'algorithmes (groupes de stratégies) sont définies et encapsulées séparément afin qu'elles puissent être remplacées les unes par les autres. Ce mode rend les modifications d'algorithme indépendantes des clients qui utilisent l'algorithme

2. ) Cet algorithme incarne plusieurs principes de conception. Premièrement, il sépare le code modifié du code inchangé ; deuxièmement, il est programmé pour des interfaces plutôt que des classes spécifiques (les interfaces stratégiques sont définies ; troisièmement, des combinaisons polyvalentes/Agrégation, utilisent moins d'héritage (clients) ; utiliser des stratégies en combinaison)

Par exemple : pour les économies d'énergie environnementales, trois méthodes d'économie d'énergie sont proposées : économie d'énergie de la carte de base, économie d'énergie SPC, économie d'énergie du produit, différentes méthodes d'économie d'énergie, traitement spécifique des équipements environnementaux. Le processus est différent

2. Méthode traditionnelle

(1) Diagramme de classes

(2) Implémentation du codage

1) Définir une classe abstraite EsPolicy et définir la méthode esPolicyHandler

public abstract class EsPolicy {
    public void esPolicyHandler() {
    }
}

2) BbEsPolicy hérite d'EsPolicy et remplace la méthode esPolicyHandler.

public class BbEsPolicy extends EsPolicy {
    @Override
    public void esPolicyHandler() {
        System.out.println("===处理基带板节能策略===");
    }
}

3) SpcEsPolicy hérite d'EsPolicy et remplace la méthode esPolicyHandler

public class SpcEsPolicy extends EsPolicy {
    @Override
    public void esPolicyHandler() {
        System.out.println("===Spc节能策略处理===");
    }
}

4) ProdEsPolicy hérite d'EsPolicy et remplace la méthode esPolicyHandler

public class ProdEsPolicy extends EsPolicy {
    @Override
    public void esPolicyHandler() {
        System.out.println("===产品节能策略处理===");
    }
}

5) Test

public class EsPolicyTest {
    public static void main(String[] args) {
        EsPolicy bbEsPolicy = new BbEsPolicy();
        bbEsPolicy.esPolicyHandler();
        SpcEsPolicy spcEsPolicy = new SpcEsPolicy();
        spcEsPolicy.esPolicyHandler();
        ProdEsPolicy prodPolicy = new ProdEsPolicy();
        prodPolicy.esPolicyHandler();
    }
}

Résultats d'exécution

=== Traitement de la carte de base Stratégie d'économie d'énergie = = =
===Traitement de la stratégie d'économie d'énergie Spc====
===Traitement de la stratégie d'économie d'énergie du produit===

Problème : La méthode traditionnelle consiste à hériter de la classe parent via la sous-classe et à écraser la classe parent méthode pour faire la différence entre les différentes sous-classes. Le comportement, les changements locaux apportés aux classes, en particulier les changements locaux apportés aux superclasses, affecteront d'autres parties et auront des effets de débordement

3. Adopter un modèle de stratégie

(1) Diagramme de classe

( 2) Implémentation du codage

1) Définir l'interface de politique et définir la méthode abstraite

public interface EsPolicyHandler {
    void esPolicyHandler();
}

2) BbEsPolicyHandler implémente l'interface de politique et implémente la méthode esPolicyHandler

public class BbEsPolicyHandler implements EsPolicyHandler {
    @Override
    public void esPolicyHandler() {
        System.out.println("===基带板节能策略处理===");
    }
}

3) SpcEsPolicyHandler implémente l'interface de politique et implémente la méthode esPolicyHandler

public class SpcEsPolicyHandler implements EsPolicyHandler {
    @Override
    public void esPolicyHandler() {
        System.out.println("===Spc节能策略处理===");
    }
}

4) ProdEsPolicyHandler implémente l'interface de stratégie et implémente la méthode esPolicyHandler

public class ProdEsPolicyHandler implements EsPolicyHandler {
    @Override
    public void esPolicyHandler() {
        System.out.println("===产品节能策略处理===");
    }
}

5) Définir la classe abstraite EsPolicy et injecter EsPolicyHandler comme attribut

public abstract class EsPolicy {
    EsPolicyHandler esPolicyHandler;
    public void setEsPolicyHandler(EsPolicyHandler esPolicyHandler) {
        this.esPolicyHandler = esPolicyHandler;
    }
    public void esPolicyHandler() {
        if (null != esPolicyHandler) {
            esPolicyHandler.esPolicyHandler();
        }
    }
}

6) BbEsPolicy hérite d'EsPolicy et instancie la propriété d'interface esPolicyHandler dans le constructeur

public class BbEsPolicy extends EsPolicy {
    public BbEsPolicy() {
        esPolicyHandler = new BbEsPolicyHandler();
    }
}

7 ) PolitiqueSpcEs hérite d'EsPolicy et l'instancie dans les propriétés de l'interface du constructeur esPolicyHandler

public class SpcEsPolicy extends EsPolicy {
    public SpcEsPolicy() {
        esPolicyHandler = new SpcEsPolicyHandler();
    }
}

8) ProdEsPolicy hérite d'EsPolicy et instancie les propriétés de l'interface esPolicyHandler dans la méthode du constructeur

public class ProdEsPolicy extends EsPolicy {
    public ProdEsPolicy() {
        esPolicyHandler = new ProdEsPolicyHandler();
    }
}

9) Test

public class EsPolicyTest {
    public static void main(String[] args) {
        BbEsPolicy bbEsPolicy = new BbEsPolicy();
        bbEsPolicy.esPolicyHandler();
        SpcEsPolicy spcEsPolicy = new SpcEsPolicy();
        spcEsPolicy.esPolicyHandler();
        ProdEsPolicy prodEsPolicy = new ProdEsPolicy();
        prodEsPolicy.esPolicyHandler();
    }
}

10) Résultats de l'exécution

===Base de traitement bande stratégies d'économie d'énergie du tableau ===
= ==Spc Energy Saving Strategy Processing===
===Produit Energy Saving Strategy Processing===

4. au modèle de stratégie est : analyser les parties changeantes et les parties inchangées du projet Partie

2) L'idée centrale du modèle de stratégie est : utiliser plus de combinaison/agrégation et moins d'héritage ; utiliser une combinaison de classes de comportement au lieu de l'héritage de comportement ; , qui est plus flexible ;

3) incarne le principe "fermé à la modification, ouvert à l'extension", le client ajoute un comportement sans modifier le code d'origine. Il lui suffit d'ajouter une stratégie (ou un comportement), évitant ainsi l'utilisation de transferts multiples. déclarations (if...else if...else)

4) Fournit un héritage remplaçable Méthode relationnelle : le modèle de stratégie encapsule l'algorithme dans une classe de stratégie indépendante afin que vous puissiez le modifier indépendamment de son contexte, ce qui facilite le changement , facile à comprendre et facile à étendre

5) Il convient de noter que : chaque fois que vous ajoutez une stratégie, vous devez ajouter une classe, cela entraînera un grand nombre de classes s'il y a trop de stratégies

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!