Mode stratégie
origine
Le mode STRATÉGIE de Delphi est étendu sur la base de STRATÉGIE. Pour plus d'informations sur le mode STRATÉGIE, veuillez vous référer à "Design Pattern Page 208"
But
Définissez une série d'algorithmes, encapsulez-les un par un et rendez-les interchangeables. Ce modèle rend l'algorithme indépendant des changements intervenus chez le client qui l'utilise.
motivation
? Différentes stratégies peuvent être transformées de manière dynamique selon les besoins. ? Mieux encapsuler plusieurs comportements et structures d'algorithmes sans permettre aux programmes clients d'interférer directement ? Sélectionnez la méthode de comportement correcte via des instructions conditionnelles pertinentes. La méthode
Template utilise l'héritage pour transformer des parties de l'algorithme. Les stratégies utilisent des proxys et des combinaisons pour transformer tous les algorithmes et prendre en charge les transformations dynamiques. À l'avenir, l'objet contextuel sera utilisé pour allouer dynamiquement des algorithmes spécifiques au moment de l'exécution. De même, en utilisant l'objet contexte, la classe client sera séparée de l'interface d'algorithme dépendante, et des interfaces plus généralisées pourront être fournies via l'objet contexte. Dans le même sens, grâce
aux interfaces contextuelles et
stratégiques , des algorithmes liés à l'ensemble du système peuvent être conçus et fournis à l'avenir pour mettre en œuvre des applications spécifiques sans modifier les interfaces.
Les stratégies vous permettent également de créer un cadre de classe unique, simple et maintenable. Les frameworks de classes reposent sur l'héritage.
application
Mise en œuvre
L'exemple suivant calcule le taux d'intérêt mensuel d'une carte de crédit.
Le mode stratégie encapsule et accède aux interfaces via la classe abstraite unique TfinanzeCharge et fournit différents algorithmes pour calculer les taux d'intérêt mensuels. TregularCharge et TPReferredCharge encapsulent différents algorithmes spécifiques pour le calcul du taux d'intérêt mensuel des cartes de crédit. TmonthlyCharge implémente l'interface TcontextCharge et configure différents objets de stratégie. TconntextCharge devient le moteur intermédiaire des objets clients et des objets de stratégie, ce qui contribue à réduire la dépendance des objets clients et des stratégies/objets.
// Interface de stratégie ( classe abstraite) TFinanzeCharge
= class public //Renvoie le résultat calculé function getCharge(const Balance
: double
) : double virtual; Balance: double): double; override end;
// Stratégie spécifique TPreferredCharge = class(TFinanzeCharge) public
function getCharge(const Balance: double); end;Le programme client s'appuie sur l'interface contextuelle pour planifier la stratégie spécifiée. Cependant, puisque l'interface contextuelle est générée pour le programme client, le programme client doit connaître les politiques/objets disponibles. Si le contexte ne peut pas renvoyer une instance valide, vous pouvez éventuellement choisir une implémentation de méthode avec une stratégie par défaut.
// Interface contextuelle TChargeContext = class public
function ComputeCharges(const Balance: double): double end; abstract ; // La classe contextuelle spécifique TmonthlyCharges sert de moteur intermédiaire pour l'objet client et l'objet stratégie, et est transmise dans son constructeur Une instance spécifique de calcul de taux d'intérêt est mise en place.
Cette classe agit comme médiateur entre le client et les classes de stratégie et est configurée en utilisant la composition et en transmettant une instance de charge financière concrète dans son constructeur.
TMonthlyCharges = class(TChargeContext) private FFinanzeCharge : TFinanzeCharge ; public//
Fonction d'interface accessible par le programme client ComputeCharges(const Balance : double ); // le constructeur configure le constructeur d'objet contextuel Create(aFinanzeCharge : TFinanzeCharge virtuel ); Détruire ; remplacer ; fin ;---implémentation
// Fonction TRegularCharge TRegularCharge.getCharge(const Balance: double): double;begin result := Balance * (REG_RATE / 12);end;
// Fonction TPreferredCharge TPreferredCharge.getCharge(const Balance: double): double;begin // cela pourrait être un complexe algorithme qui prend en compte // les habitudes d'achat du titulaire de la carte de crédit et les points de récompense accumulés result := Balance * (PREFERRED_RATE / 12);end
// Concrete; Context // Constructeur TMonthlyCharges TMonthlyCharges.Create(aFinanzeCharge: TFinanzeCharge);begin hérité Create; // aFinanzeCharge configure l'objet de contexte // cette classe prend possession d'aFinanzeCharge (le détruira) FFinanzeCharge := aFinanzeCharge;end;destructor TMonthlyCharges.Destroy; commencer FFinanzeCharge.Free hérité; Détruire;fin;fonction TMonthlyCharges.ComputeCharges(const Balance: double): double;commencer le résultat := FFinanzeCharge.getCharge(Balance);end;
Exemple Delphes
