Dans les patrons de conception comportementaux, le patron État et le patron Stratégie sont des frères proches ; ils sont très similaires. Regardons d'abord leur diagramme de classes commun et comparons-les côte à côte, comme le montre la figure :

Ils se ressemblent beaucoup, n'est-ce pas ? Rien qu'en regardant cet UML, on ne peut pas faire la différence. Ensuite, combinons des exemples pour comparer les différences entre les deux. L'exemple ci-dessous provient de « Head First Design Patterns ».
Patron Stratégie
Le patron Stratégie définit une famille d'algorithmes, encapsule chacun d'eux et les rend interchangeables. Ce patron permet à l'algorithme de varier indépendamment des clients qui l'utilisent.
Une entreprise a développé un jeu de canards qui présente diverses sortes de canards : canards colverts, canards à tête rouge, canards en caoutchouc... Comment implémenter ces canards dans un programme ? Face à ce scénario, il est facile de penser à définir d'abord une superclasse Duck pour tous les canards et à y encapsuler les méthodes et propriétés communes. Par exemple, tous les canards peuvent nager, et tous les canards ont leur propre apparence :
Exemple
public void swim(){
System.out.println("Tous les canards peuvent nager !");
}
public abstract void display();
public void fly(){
System.out.println("Voler~~~");
}
public void quack(){
System.out.println("Coin coin coin~");
}
}
Mais bientôt, nous constatons un problème avec cette définition de superclasse. Tous les canards ne peuvent pas voler, et tous les canards ne font pas coin-coin (supposons que les canards en caoutchouc couinent). Tant qu'ils héritent de cette superclasse, tous les canards voleront, et tous les canards feront coin-coin.
Que faire ?
Solution 1
La première solution qui vient à l'esprit est la redéfinition de méthode dans les sous-classes. Simple : il suffit de redéfinir la méthode fly dans les sous-classes qui ne peuvent pas voler.
Mais l’inconvénient est évident : toutes les sous-classes qui ne volent pas ne devraient-elles pas la redéfinir ? Supposons que 50 types de canards ne puissent pas voler ; quelle serait l’ampleur de la charge de réécriture et de maintenance ?
Solution 2
D’accord, nous pensons donc à une deuxième méthode : continuer à concevoir des sous-classes abstraites, comme la sous-classe abstraite FlyNoQuackDuck qui peut voler mais pas cancaner, la sous-classe abstraite QuackNoFlyDuck qui peut cancaner mais pas voler, la sous-classe abstraite NoQuackNoFlyDuck qui ne peut ni cancaner ni voler, la sous-classe abstraite FlyAndQuackDuck qui peut à la fois voler et cancaner...
Au fur et à mesure que nous écrivons, nous constatons que cette méthode ne fonctionne pas non plus ; elle est trop peu flexible, et plus les parties qui changent sont nombreuses, plus nous devons définir de telles sous-classes abstraites.
Solution 3
Alors quelle méthode est bonne ? Nous réfléchissons au fait que le problème ci-dessus survient parce que nous essayons habituellement d’utiliser l’héritage pour implémenter les parties changeantes. En fait, nous pouvons extraire les parties changeantes et les implémenter par composition.
Trois principes de conception sont utilisés ici :
- Identifier les aspects de votre application susceptibles de varier et les séparer.
- Programmer vers une interface, pas vers une implémentation.
- Privilégier la composition à l’héritage.
En appliquant le premier principe de conception, nous séparons les méthodes changeantes fly() et quack() et les encapsulons dans deux interfaces de comportement. Ensuite, selon des besoins différents, nous concevons différentes classes de comportement qui implémentent les interfaces.

En appliquant les deuxième et troisième principes de conception, nous intégrons les deux interfaces sous forme de variables membres dans la classe Duck et les affectons dynamiquement dans les sous-classes.

Le "diagramme de classes" global est le suivant :

Résumé
Cette solution résout parfaitement notre problème. En utilisant l'idée du "patron de stratégie", nous extrayons les parties changeantes et les composons dans la classe. Selon les différentes sous-classes, nous pouvons "définir" différentes sous-classes de comportement pour modifier dynamiquement le comportement.
Implémentation du code
Deux classes d'interface de comportement
Exemple
public void fly();
}
public interface QuackBehavior {
public void quack();
}
Différentes classes de comportement implémentant l'interface de vol
Exemple
public void fly(){
System.out.println("I can't fly...");
}
}
public class FlyWithWings implements FlyBehavior{
public void fly(){
System.out.println("Voler~~~");
}
}
public class FlyWithRocket implements FlyBehavior{
public void fly(){
System.out.println("With a rocket launcher, fly~~~");
}
}
Différentes classes de comportement implémentant le cancanement
Exemple
public void quack(){
System.out.println("Coin coin coin~");
}
}
public class Squeak implements QuackBehavior{
public void quack(){
System.out.println("Couic couic couic~");
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
System.out.println("Je ne peux pas cancaner...");
}
}
La superclasse composée avec des interfaces d'implémentation
Exemple
protected FlyBehavior flyBehavior;
protected QuackBehavior quackBehavior;
public void swim(){
System.out.println("Tous les canards peuvent nager !");
}
public abstract void display();
/**
* Changer dynamiquement le comportement de vol
*/
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
/**
* Changer dynamiquement le comportement de cancanement
*/
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
public void performFly(){
flyBehavior.fly();
}
public void performQuack(){
quackBehavior.quack();
}
}
Différentes classes de canards
Exemple
* Canard colvert
*/
public class MallarDuck extends Duck{
public MallarDuck() {
//Peut voler
flyBehavior = new FlyWithWings();
//Cancane
quackBehavior = new Quack();
}
@Override
public void display() {
System.out.println("On dirait un canard colvert");
}
}
/**
* Canard à tête rouge
*/
public class RedHeadDuck extends Duck{
public RedHeadDuck() {
//Peut voler
flyBehavior = new FlyWithWings();
//Cancane
quackBehavior = new Quack();
}
@Override
public void display() {
System.out.println("On dirait un canard à tête rouge");
}
}
/**
* Canard en caoutchouc
*/
public class RubberDuck extends Duck{
public RubberDuck() {
//Ne peut pas voler
flyBehavior = new FlyNoWay();
//Couinements
quackBehavior = new Squeak();
}
@Override
public void display() {
System.out.println("On dirait un canard en caoutchouc");
}
}
Patron État
Le patron État permet à un objet de modifier son comportement lorsque son état interne change. L'objet semblera changer de classe.
Le patron État est très similaire au patron Stratégie. Il encapsule également l'« état » de la classe et effectue automatiquement des transitions lors de l'exécution d'actions, de sorte que la même action de la classe dans différents états montre des résultats différents. La différence avec le patron Stratégie est que cette transition est « automatique » et « inconsciente ».
Le diagramme de classes du patron État est le suivant

Le diagramme de classes du patron État est exactement le même que celui du patron Stratégie ; la différence réside dans leur intention. Le patron Stratégie contrôle la stratégie utilisée par l'objet, tandis que le patron État change automatiquement l'état. Vous devriez avoir une idée claire après avoir lu le cas ci-dessous.
Vous avez maintenant une exigence pour une machine à bonbons, et elle doit être implémentée en Java.
Analysons cela. La fonctionnalité de la machine à bonbons peut être divisée en quatre actions et quatre états comme le montre la figure ci-dessous :

Dans différents états, la même action produit des résultats différents. Par exemple, dans l'état « 25 cents insérés », tourner la manivelle distribuera un bonbon ; mais dans l'état « aucun 25 cents », tourner la manivelle vous demandera d'insérer d'abord une pièce.
Après une brève réflexion, nous écrivons le code d'implémentation suivant de la machine à bonbons
Exemple
/*
* Quatre états
*/
/**État sans pièce*/
private final static int NO_QUARTER = 0;
/**État pièce insérée*/
private final static int HAS_QUARTER = 1;
/**État vendu*/
private final static int SOLD = 2;
/**État épuisé*/
private final static int SOLD_OUT = 3;
private int state = SOLD_OUT;
private int candyCount = 0;
public NoPatternGumballMachine(int count) {
this.candyCount = count;
if(candyCount > 0)
state = NO_QUARTER;
}
/*
* Quatre actions
*/
/**
* Insérer une pièce
*/
public void insertQuarter() {
if(NO_QUARTER == state){
System.out.println("Insérez une pièce");
state = HAS_QUARTER;
}
else if(HAS_QUARTER == state){
System.out.println("Veuillez ne pas insérer de pièce à plusieurs reprises !");
returnQuarter();
}
else if(SOLD == state){
System.out.println("Pièce insérée, veuillez patienter pour le bonbon");
returnQuarter();
}else if(SOLD_OUT == state){
System.out.println("Les bonbons sont épuisés");
returnQuarter();
}
}
/**
* Rendre la pièce
*/
public void ejectQuarter() {
if(NO_QUARTER == state){
System.out.println("Aucune pièce, impossible d'éjecter");
}
else if(HAS_QUARTER == state){
returnQuarter();
state = NO_QUARTER;
}
else if(SOLD == state){
System.out.println("Impossible de rendre la pièce, distribution du bonbon en cours, veuillez patienter");
}else if(SOLD_OUT == state){
System.out.println("Aucune pièce insérée, impossible de rendre la pièce");
}
}
/**
* Tourner la manivelle pour distribuer le bonbon
*/
public void turnCrank() {
if(NO_QUARTER == state){
System.out.println("Veuillez d'abord insérer une pièce");
}
else if(HAS_QUARTER == state){
System.out.println("Tournez la manivelle, prêt à distribuer un bonbon");
state = SOLD;
}
else if(SOLD == state){
System.out.println("Vous avez déjà tourné la manivelle, veuillez patienter");
}else if(SOLD_OUT == state){
System.out.println("Les bonbons sont épuisés");
}
}
/**
* Distribuer un bonbon
*/
public void dispense() {
if(NO_QUARTER == state){
System.out.println("Aucune pièce insérée, impossible de distribuer un bonbon");
}
else if(HAS_QUARTER == state){
System.out.println("cette méthode n'est pas prise en charge");
}
else if(SOLD == state){
if(candyCount > 0){
System.out.println("Distribution d'un bonbon");
candyCount --;
state = NO_QUARTER;
}
else{
System.out.println("Désolé, le bonbon est épuisé");
state = SOLD_OUT;
}
}else if(SOLD_OUT == state){
System.out.println("Désolé, le bonbon est épuisé");
}
}
/**
* Rembourser la pièce
*/
protected void returnQuarter() {
System.out.println("Rendu de la pièce...");
}
}
Comme on peut le voir dans le code, la machine à bonbons présente des résultats différents pour les actions correspondantes en fonction de son état actuel. Ce code peut déjà répondre à nos exigences de base, mais avec un peu de réflexion, vous aurez l'impression que ce code d'implémentation semble trop compliqué, a une mauvaise extensibilité et manque d'un style orienté objet.
Supposons qu'une nouvelle exigence nous oblige à ajouter un état ; alors nous devons modifier chaque méthode d'action et ajouter une autre instruction else à chaque fois. Et si les exigences changent et qu'une action dans un certain état doit être modifiée, nous devons aussi modifier quatre méthodes en même temps. Un tel travail serait fastidieux et donnerait mal à la tête.
Que faire ? L'un des six principes de conception
Identifier les aspects de votre application susceptibles de varier et les séparer.
Dans la machine à bonbons, l'état est la partie qui change constamment ; des états différents ont des actions différentes. Nous pouvons certainement l'extraire.

La nouvelle idée de conception est la suivante :
Tout d'abord, nous définissons une interface State. Dans cette interface, chaque action de la machine à bonbons a une méthode correspondante.
Ensuite, implémentez une classe d'état pour chaque état de la machine. Ces classes seront responsables du comportement de la machine dans l'état correspondant.
Enfin, nous devons nous débarrasser de l'ancien code conditionnel et le remplacer en déléguant les actions aux classes d'état.
Définir une interface State
Exemple
/**
* Insérer une pièce
*/
public abstract void insertQuarter();
/**
* Rendre la pièce
*/
public abstract void ejectQuarter();
/**
* Tourner la manivelle pour distribuer le bonbon
*/
public abstract void turnCrank();
/**
* Distribuer un bonbon
*/
public abstract void dispense();
/**
* Rembourser la pièce
*/
protected void returnQuarter() {
System.out.println("Rendu de la pièce...");
}
}
Implémentez des classes d'état pour chaque état de la machine
Exemple
* État sans pièce
*/
public class NoQuarterState extends State{
GumballMachine gumballMachine;
public NoQuarterState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Vous avez inséré une pièce");
//Transition vers l'état pièce insérée
gumballMachine.setState(gumballMachine.hasQuarterState);
}
@Override
public void ejectQuarter() {
System.out.println("Aucune pièce, impossible d'éjecter");
}
@Override
public void turnCrank() {
System.out.println("Veuillez d'abord insérer une pièce");
}
@Override
public void dispense() {
System.out.println("Aucune pièce insérée, impossible de distribuer un bonbon");
}
}
/**
* État pièce insérée
*/
public class HasQuarterState extends State{
GumballMachine gumballMachine;
public HasQuarterState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Veuillez ne pas insérer de pièce à plusieurs reprises !");
returnQuarter();
}
@Override
public void ejectQuarter() {
returnQuarter();
gumballMachine.setState(gumballMachine.noQuarterState);
}
@Override
public void turnCrank() {
System.out.println("Tournez la manivelle, prêt à distribuer un bonbon");
gumballMachine.setState(gumballMachine.soldState);
}
@Override
public void dispense() {
System.out.println("cette méthode n'est pas prise en charge");
}
}
/**
* État vendu
*/
public class SoldState extends State{
GumballMachine gumballMachine;
public SoldState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Pièce insérée, veuillez patienter pour le bonbon");
returnQuarter();
}
@Override
public void ejectQuarter() {
System.out.println("Impossible de rendre la pièce, distribution du bonbon en cours, veuillez patienter");
}
@Override
public void turnCrank() {
System.out.println("Manivelle déjà tournée, veuillez patienter");
}
@Override
public void dispense() {
int candyCount = gumballMachine.getCandyCount();
if(candyCount > 0){
System.out.println("Distribution d'un bonbon");
candyCount--;
gumballMachine.setCandyCount(candyCount);
if(candyCount > 0){
gumballMachine.setState(gumballMachine.noQuarterState);
return;
}
}
System.out.println("Désolé, le bonbon est épuisé");
gumballMachine.setState(gumballMachine.soldOutState);
}
}
/**
* État épuisé
*/
public class SoldOutState extends State{
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Les bonbons sont épuisés");
returnQuarter();
}
@Override
public void ejectQuarter() {
System.out.println("Aucune pièce insérée, impossible de rendre la pièce");
}
@Override
public void turnCrank() {
System.out.println("Les bonbons sont épuisés");
}
@Override
public void dispense() {
System.out.println("Les bonbons sont épuisés");
}
}
Déléguer les actions de la machine à bonbons à la classe d'état
Exemple
public State noQuarterState = new NoQuarterState(this);
public State hasQuarterState = new HasQuarterState(this);
public State soldState = new SoldState(this);
public State soldOutState = new SoldOutState(this);
private State state = soldOutState;
private int candyCount = 0;
public GumballMachine(int count) {
this.candyCount = count;
if(count > 0)
setState(noQuarterState);
}
@Override
public void insertQuarter() {
state.insertQuarter();
}
@Override
public void ejectQuarter() {
state.ejectQuarter();
}
@Override
public void turnCrank() {
state.turnCrank();
}
@Override
public void dispense() {
state.dispense();
}
public void setState(State state) {
this.state = state;
}
public State getState() {
return state;
}
public void setCandyCount(int candyCount) {
this.candyCount = candyCount;
}
public int getCandyCount() {
return candyCount;
}
}
On peut voir qu'avec cette conception, la machine à bonbons n'a pas du tout besoin de connaître les changements d'état ; elle doit seulement appeler les méthodes de l'état. Les changements d'état se produisent à l'intérieur de l'état. C'est le « patron État ».
Si un autre état est ajouté à ce stade, la machine à bonbons n'a besoin d'aucune modification ; il suffit d'ajouter une autre classe d'état, puis d'ajouter le processus de transition dans les méthodes de la classe d'état concernée.
Vous ne comprenez pas ? Il y a aussi un article sur le patron État :https://dzone.com/articles/state-pattern-simplified
Lien original : https://blog.csdn.net/z55887/article/details/73198039
Lien original : https://blog.csdn.net/z55887/article/details/60608898