Appliquez votre premier design pattern

Dans le chapitre précédent, vous avez rendu des collaborateurs interchangeables grâce à un contrat, au polymorphisme, à la composition et à l’injection de dépendances. Ces mécanismes ne suffisent toutefois pas à justifier un pattern : il faut d’abord reconnaître un problème de variation réel.

Vous allez maintenant les transférer à un nouveau cas métier pour appliquer Strategy. Vous partirez d’un calcul rempli de conditions, le refactorerez progressivement, puis vérifierez que la nouvelle structure facilite réellement son évolution.

Partez d’un problème comportant plusieurs comportements

Une application RH calcule une prime selon le type de contrat :

classe CalculateurPrime
    méthode calculer(salarie)
        si salarie.typeContrat = "CDI"
            retourner salarie.salaireMensuel * 0,10
        sinon si salarie.typeContrat = "CDD"
            retourner salarie.salaireMensuel * 0,06
        sinon si salarie.typeContrat = "alternance"
            retourner 300
        sinon
            retourner 0

Cette version peut convenir au début. Mais les règles évoluent désormais séparément : la prime des CDI dépend aussi de l’ancienneté, celle des CDD est plafonnée et celle des personnes en alternance dépend de la durée du contrat. Une nouvelle catégorie doit bientôt être prise en charge.

La méthode grandit à mesure que les calculs se différencient. Pour modifier une règle, vous intervenez dans une classe qui contient toutes les autres. Les tests doivent couvrir l’ensemble de la condition et plusieurs personnes risquent de modifier la même méthode.

Le problème n’est donc pas la présence de toute condition. Il apparaît lorsque la condition sélectionne des comportements significatifs qui évoluent indépendamment. Le besoin peut se formuler ainsi :

Faire varier le calcul d’une prime indépendamment du service qui demande ce calcul.

Vous ne cherchez pas encore le nom d’un pattern : vous décrivez d’abord ce qui doit pouvoir varier sans entraîner le reste du code.

Identifiez les rôles du pattern Strategy

Le pattern Strategy encapsule plusieurs façons d’effectuer une même opération et permet de les rendre interchangeables. Chaque façon de faire devient une stratégie distincte.

Strategy organise les objets autour de trois rôles.

Le contexte utilise un comportement

Le contexte porte le cas d’usage principal. Ici,ServicePrimedemande le calcul d’une prime, mais il ne doit pas connaître les formules propres à chaque type de contrat :

classe ServicePrime
    attribut politique : PolitiquePrime

    méthode attribuerPrime(salarie)
        montant = politique.calculer(salarie)
        enregistrerPrime(salarie, montant)

Le contexte peut conserver les règles communes, comme vérifier que le dossier est actif ou enregistrer le montant. Seul le calcul variable est confié à la stratégie.

Le contrat définit l’opération attendue

Le contrat de stratégie décrit l’opération commune :

contrat PolitiquePrime
    méthode calculer(salarie)

Le contexte dépend de cette capacité, et non d’une formule concrète. Le nomcalculerexprime ici l’intention partagée sans imposer sa réalisation.

Les stratégies concrètes réalisent le comportement

Chaque stratégie concrète contient une variante du calcul :

classe PrimeCDI respecte PolitiquePrime
    méthode calculer(salarie)
        retourner calculerSelonAnciennete(salarie)

classe PrimeCDD respecte PolitiquePrime
    méthode calculer(salarie)
        retourner minimum(salarie.salaireMensuel * 0,06, plafond)

classe PrimeAlternance respecte PolitiquePrime
    méthode calculer(salarie)
        retourner calculerSelonDureeContrat(salarie)

Chaque classe change désormais pour une raison précise. Une évolution du plafond des CDD concernePrimeCDD, sans toucher aux autres calculs ni au contexte.

Schéma montrant le contexte ServicePrime qui délègue via le contrat PolitiquePrime à trois stratégies concrètes : PrimeCDI, PrimeCDD et PrimeAlternance, toutes tenues de respecter ce contrat.
Les rôles du pattern Strategy dans l’exemple du calcul des primes.

Refactorez progressivement le code avec Strategy

Un refactoring consiste à réorganiser le code pour le rendre plus facile à comprendre, à modifier et à tester, sans changer son comportement observable. Ici, vous allez séparer les règles de calcul des primes : pour les mêmes données, le montant calculé doit rester identique.

Repérez ce qui reste stable et ce qui varie

L’intention reste stable : déterminer une prime. Les formules, plafonds et données nécessaires varient selon le type de contrat. Regroupez dans une même stratégie les règles propres à un type de contrat : par exemple, la formule de calcul et le plafond de la prime des CDD.

Créez le contrat et une première stratégie

Créez le contratPolitiquePrime, puis une classePrimeCDIqui respecte ce contrat et reprend le calcul initial des CDI :

contrat PolitiquePrime
    méthode calculer(salarie)

classe PrimeCDI respecte PolitiquePrime
    méthode calculer(salarie)
        retourner salarie.salaireMensuel * 0,10

Dans l’ancienne méthode, remplacez uniquement le calcul des CDI par un appel à cette stratégie. Conservez les autres branches pour le moment :

classe CalculateurPrime
    méthode calculer(salarie)
        si salarie.typeContrat = "CDI"
            politique = nouveau PrimeCDI()
            retourner politique.calculer(salarie)
        sinon si salarie.typeContrat = "CDD"
            retourner salarie.salaireMensuel * 0,06
        sinon si salarie.typeContrat = "alternance"
            retourner 300
        sinon
            retourner 0

Vérifiez que le résultat n’a pas changé : pour un salaire mensuel de 2 000 €, la prime d’un CDI reste de 200 €. Cette étape est transitoire : vous déplacerez ensuite les autres calculs et fournirez la stratégie au contexte depuis l’extérieur.

Faites dépendre le contexte du contrat

Le contexte reçoit une stratégie par son constructeur :

classe ServicePrime
    attribut politique : PolitiquePrime

    constructeur(politique)
        cetObjet.politique = politique

    méthode attribuerPrime(salarie)
        verifierDossierActif(salarie)
        montant = politique.calculer(salarie)
        enregistrerPrime(salarie, montant)

Le choix se fait à l’extérieur :

politique = nouveau PrimeCDI()
service = nouveau ServicePrime(politique)
service.attribuerPrime(salarie)

L’injection rend la collaboration explicite : le contexte utilise une politique sans connaître sa formule.

Extrayez les autres comportements

Sur le même modèle quePrimeCDI, déplacez les calculs des CDD et des personnes en alternance dans les classesPrimeCDDetPrimeAlternanceprésentées plus haut. Vérifiez à chaque étape les montants obtenus. Le refactoring est terminé lorsque le contexte ne connaît plus les classes concrètes.

Décidez où choisir la stratégie

Strategy ne supprime pas nécessairement toute condition : la décision peut être déplacée vers l’endroit qui connaît le type de contrat.

si typeContrat = "CDI"
    politique = primeCDI
sinon si typeContrat = "CDD"
    politique = primeCDD
sinon
    politique = primeAlternance

Cette condition reste acceptable si elle se limite à sélectionner un objet. Les formules demeurent encapsulées dans les stratégies. Un framework pourra plus tard effectuer cette association.

Faites évoluer et testez la solution

L’équipe ajoute une prime pour un nouveau type de contrat. Avec la structure initiale, vous auriez ajouté une branche àCalculateurPrime. Avec Strategy, vous créez une nouvelle politique :

classe PrimeInterim respecte PolitiquePrime
    méthode calculer(salarie)
        retourner calculerSelonHeuresTravaillees(salarie)

Le contexte, le contrat et les stratégies existantes ne changent pas. Le point de configuration devra connaître cette nouvelle option, mais les calculs déjà validés restent intacts.

Les tests deviennent également plus ciblés :

  • testez chaque politique avec ses cas limites ;

  • testezServicePrimeavec une fausse politique pour vérifier la validation et la délégation ;

  • testez séparément le composant qui sélectionne la politique.

Vous localisez ainsi plus facilement une erreur : un dépassement du plafond CDD concerne probablementPrimeCDD, et non le contexte ou les autres politiques.

Strategy peut aussi permettre de remplacer un calcul pendant l’exécution. Ne rendez toutefois cette stratégie modifiable que si le besoin existe : ajouter cette flexibilité « au cas où » créerait une complexité inutile.

Justifiez le choix du pattern

Reconnaître la structure de Strategy ne suffit pas. Vous devez expliquer pourquoi elle améliore ce code précis.

Strategy est généralement pertinent lorsque plusieurs indices se combinent :

  • plusieurs comportements répondent à la même intention ;

  • une condition choisit entre eux ;

  • chaque branche possède une logique significative ou évolue indépendamment ;

  • de nouvelles variantes sont susceptibles d’apparaître ;

  • les comportements doivent être testés séparément.

Ces indices sont présents dans le calcul des primes : les politiques partagent la même intention, mais leurs règles et leurs cas limites évoluent séparément.

À l’inverse, une condition courte et stable peut rester préférable :

si utilisateur.estActif
    afficher "Compte actif"
sinon
    afficher "Compte inactif"

Pour argumenter votre choix :

  1. Décrivez le problème : « La méthode contient plusieurs calculs qui évoluent indépendamment. »

  2. Expliquez l’apport de Strategy : « Chaque politique devient interchangeable derrière un contrat commun. »

  3. Nommez le bénéfice vérifiable : « Nous pouvons ajouter la prime d’intérim et la tester sans modifier le service ni les politiques existantes. »

Partez toujours du problème observé, et non du nom du pattern.

À vous de jouer

Vous avez étudié les rôles de Strategy à partir du calcul des primes. Transférez maintenant cette grille de lecture à un autre problème : le calcul de frais de livraison. Une boutique propose une livraison standard et une livraison express, dont les règles évoluent séparément. Un retrait gratuit en magasin doit bientôt être ajouté.

Choisissez la version correspondant à votre stack. Dans les trois cas, vous devez :

  1. repérer le contexte et les calculs variables ;

  2. définir le contrat de stratégie ;

  3. extraire les calculs standard et express dans deux stratégies concrètes ;

  4. injecter une stratégie dans le calculateur ;

  5. supprimer la condition du contexte ;

  6. ajouter une stratégie de retrait en magasin sans modifier le contexte ;

  7. expliquer en trois phrases pourquoi Strategy est pertinent.

Version Java

public class ShippingCostService {
    public double calculate(Order order, String mode) {
        if (mode.equals("standard")) {
            return 4.90 + order.getWeight() * 0.50;
        } else if (mode.equals("express")) {
            return 9.90 + order.getWeight() * 0.90;
        }
        throw new IllegalArgumentException("Unknown delivery mode");
    }
}

Version Python

class ShippingCostService:
    def calculate(self, order, mode):
        if mode == "standard":
            return 4.90 + order.weight * 0.50
        if mode == "express":
            return 9.90 + order.weight * 0.90
        raise ValueError("Unknown delivery mode")

Version C#

public class ShippingCostService
{
    public decimal Calculate(Order order, string mode)
    {
        if (mode == "standard")
            return 4.90m + order.Weight * 0.50m;
        if (mode == "express")
            return 9.90m + order.Weight * 0.90m;
        throw new ArgumentException("Unknown delivery mode");
    }
}

En résumé

  • Strategy rend interchangeables plusieurs comportements qui partagent une intention mais évoluent indépendamment.

  • Le contexte porte le cas d’usage et délègue le comportement variable à une stratégie, choisie à l’extérieur du contexte ou dans un composant dédié.

  • Le contrat définit l’opération commune ; les stratégies concrètes en proposent différentes implémentations.

  • Une nouvelle stratégie peut être ajoutée sans modifier le contexte ni les stratégies existantes.

  • Une condition courte et stable peut rester plus lisible qu’un pattern. Strategy doit répondre à un besoin réel, pas à une recherche d’abstraction.

Vous savez maintenant partir d’un problème de conception, appliquer Strategy et justifier ce choix. Il vous reste à consolider ces décisions : répondez au quiz pour vérifier que vous savez reconnaître un couplage fort, choisir entre composition et héritage et distinguer un pattern utile d’une sur-ingénierie.

Et si vous obteniez un diplôme OpenClassrooms ?
  • Formations jusqu’à 100 % financées
  • Date de début flexible
  • Projets professionnalisants
  • Mentorat individuel
Trouvez la formation et le financement faits pour vous