Exemple concret du modèle de stratégie

Question

J'ai lu des articles sur le Principe de l'OCP et comment utiliser le modèle de stratégie pour y parvenir.

J'allais essayer d'expliquer cela à quelques personnes, mais le seul exemple auquel je peux penser est l'utilisation de différentes classes de validation en fonction du statut d'une "commande".

J'ai lu quelques articles en ligne, mais ils ne décrivent généralement pas une véritable raison d'utiliser la stratégie, comme la génération de rapports/factures/validation, etc...

Y a-t-il des exemples concrets où vous pensez qu'un modèle de stratégie est courant ?

Answer 1

Exemple pour calculer le total de la taxe sur la TPS de l'article

public interface TaxCalculation {

    public Double calculateTax(Double price);  
}

public class FivePercentage implements TaxCalculation {

    @Override
    public Double calculateTax(Double price) {

        Double dbl = (price*5)/100;
        return dbl;
    }

}

public class EighteenPercentage implements TaxCalculation {

    @Override
    public Double calculateTax(Double price) {
        Double dbl = (price*18)/100;
        return dbl;
    }

}

public class Item {

    public String name;
    public Double price;
    public int taxRate;
    public Double totalTax;

    public Item(String name, Double price, int taxRate) {
        super();
        this.name = name;
        this.price = price;
        this.taxRate = taxRate;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public int getTaxRate() {
        return taxRate;
    }

    public void setTaxRate(int taxRate) {
        this.taxRate = taxRate;
    }

    public Double getTotalTax() {
        return totalTax;
    }

    public void setTotalTax(Double totalTax) {
        this.totalTax = totalTax;
    }

    public void calculateTax(TaxCalculation taxcalulation, Double price) {
        this.totalTax = taxcalulation.calculateTax(price);
    }

    @Override
    public String toString() {
        return "Items [name=" + name + ", price=" + price + ", taxRate=" + taxRate + ", totalTax=" + totalTax + "]";
    }

}

public class CalculateTax {

    public static void main(String[] args) {

        List<Item> itemList = new ArrayList<>();

        Item item1 = new Item("Engine Oil", 320.0, 5);
        Item item2 = new Item("Painting", 3500.00, 18);

        itemList.add(item1);
        itemList.add(item2);

        itemList.stream().forEach(x-> {
            if(x.getTaxRate() == 5) {
                x.calculateTax(new FivePercentage(), x.getPrice());
            } else if(x.getTaxRate() == 18) {
                x.calculateTax(new EighteenPercentage(), x.getPrice());
            }
        });

        itemList.stream().forEach(x-> {
            System.out.println(x.toString());
        });
    }
}

Answer 2

De wikipedia

En programmation informatique, le modèle de stratégie (également connu sous le nom de modèle de politique) est un modèle de conception de logiciel comportemental qui permet de sélectionner un algorithme au moment de l'exécution. Au lieu d'implémenter directement un seul algorithme, le code reçoit des instructions d'exécution quant au choix de la famille d'algorithmes à utiliser.

Dans l'application Windows Paint, vous pouvez voir un modèle de stratégie où vous pouvez choisir la forme et la couleur indépendamment dans une section différente. Ici, la forme et la couleur sont des algorithmes qui peuvent être modifiés au moment de l'exécution.

Si vous voulez dessiner un cercle de couleur rouge, plutôt que de vous proposer l'option "RedCircle", ils vous laissent choisir le cercle et la couleur de votre choix.

Shape redCircle = new RedCircle(); // Without stretegy Pattern
Shaped redCircle = new Shape("red","circle"); // With Strategy pattern

Sans stratégie, le motif augmentera le nombre de classes avec le produit cartésien de la forme et de la couleur. De plus, l'interface change pour chaque implémentation.

Answer 3

Imaginez un jeu de tir avec des ennemis IA par exemple. Vous voulez qu'ils se battent continuellement de différentes manières en fonction de ce qui se passe . Avec le modèle de stratégie, vous pouvez continuellement boucler et changer dynamiquement la façon dont une action spécifique ou une action sera exécutée.

interface FightingStategy{
    public void fight();
}
public Defense implements FightingStrategy{
    public void figth(){
        ... hide behind wall to shoot
    }
}
public Berserker implements FightingStrategy{
    public void fight(){
        ... run towards you, headrolls and shoots
    }
}
public Dead implements FightingStrategy{
    public void fight(){
        ... is dead, doesn't move
    }
}

public AiShooter{

    FightingStrategy fightingStrategy;

    public AiShooter(){
        fightStrategy = new Berserker();
    }

    public void fight(){
        this.fightingStrategy.fight();
    }

    public void changeStrategy(FightingStrategy f){
        this.fightingStrategy = f;
    }
}

public static void main(){

    ... create list of AiShooters...
    while (condition){
        list.forEach(shooter -> shooter.fight());
    }
    ... you shoot back
    list.ForEach(shooter -> shooter.changeStrategy(new 
Defense()));

    ... you kill one
    list.get(n).changeStrategy(new Dead());
}

Answer 4

Cette réponse est pour quelqu'un qui est un débutant et qui veut comprendre ceci avec l'exemple le plus simple possible - (Référence : Headfirst Design Patterns)

#include<iostream>
using namespace std;

/*
    Where it is applicable?
    The selection of an algorithm is required from a family of algorithms.
    To avoid multiple conditional statements for selection of algorithms
    and to hide its algorithm data structures and complexity from client.
*/

class Fly {
public:
    virtual void fly() = 0;
};

//concrete Fly : rocketFly
class rocketFly : public Fly {
public:
    void fly() {
        cout <<"rocketFly::fly()" << endl;
    }
};

//concrete Fly : normalFly
class normalFly : public Fly {
public:
    void fly() {
        cout <<"normalFly::fly()" << endl;
    }
};

//Duck "HAS A" relationship with Fly
class Duck {
private:
    //Duck has a Fly behavour
    Fly* flyObj;
public:
    Duck(Fly* obj) : flyObj(obj) {

    }

    void DuckFly() {
        flyObj->fly();
    }
};

int main() {
    rocketFly* rObj = new rocketFly;
    Duck wildDuck(rObj);
    wildDuck.DuckFly();

    normalFly* nObj = new normalFly;
    Duck cityDuck(nObj);
    cityDuck.DuckFly();

    /*
        I didn't have to create classes like wildDuck which inherits from Duck and they implement their own
        fly, quack etc behaviour. There will be code duplication.
        So, instead of that, create an interface of fly, make concrete fly classes with different
        fly behaviour. Use objects to any of these concrete classes to inject to one generic duck
        class which will automatically call correct fly behaviour.
    */

return 0;
}