Modèle de décorateur en Java

introduction

Présentation des modèles de conception de [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Introduction aux modèles de conception appris dans le langage Java augmenté et révisé"]( https://www.amazon.co.jp/ Édition révisée supplémentaire Introduction aux modèles de conception appris en langage Java-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP) Je vais résumer sur.

Motif décorateur

Qu'est-ce que le décorateur

Traduit en japonais, cela signifie «décorateur». ** Un modèle qui étend la fonction en décorant de plus en plus l'objet original ** est appelé un ** modèle de décorateur **. En appliquant ce modèle, vous pouvez étendre la fonctionnalité de manière flexible sans changer la classe à partir de laquelle elle est étendue.

Personnage

Le modèle Decorator est utilisé par les classes qui apparaissent dans le diagramme de classes ci-dessous.

Classe abstraite

• Component
  Représente la classe abstraite sous-jacente à décorer (étendue).

• Decorator
  Une classe abstraite qui hérite de la classe Component et est la classe de base de la classe de décoration. Il est à noter que le champ a la classe Component à décorer **.

Classe d'implémentation

• ConcreteComponent Une classe d'implémentation pour la classe Component. Implémente toutes les méthodes abstraites de la classe Component.

• ConcreteDecorator Une classe d'implémentation de la classe Decorator. Puisque la classe Decorator hérite de la classe Component, il est nécessaire d'implémenter la méthode abstraite de la classe Component.

Exemple concret

À titre d'exemple concret, nous expliquerons en nous basant sur la classe suivante.

Classe abstraite

• ** Classe SpongeCake **

SpongeCake.java

public abstract class SpongeCake {
	public abstract String getName(); //Obtenez un nom

	public abstract int getPrice(); //Obtenez le prix

	public void show() { //Afficher le nom et le prix
		System.out.println(getName() + ":" + getPrice() + "Cercle");
	}
}

La classe SpongeCake définit une méthode pour obtenir le nom et le prix en tant que méthode abstraite, et une méthode pour les afficher comme une méthode concrète. C'est juste une génoise sans aucune décoration. Le traitement réel de la classe abstraite sera implémenté dans la sous-classe décrite plus loin. Il n'y a rien de particulièrement difficile.

• ** Classe de décorateur **

Decorator.java

public abstract class Decorator extends SpongeCake {
	protected SpongeCake spongeCake; //Fait référence au "contenu" dans lequel ce cadre décoratif est enveloppé

	protected Decorator(SpongeCake spongeCake) { //Spécifiez "contenu" comme argument lors de la création d'une instance
		this.spongeCake = spongeCake;
	}
}

La classe Decorator hérite de la classe SpongeCake décrite ci-dessus, mais c'est une classe abstraite car elle ne remplace pas la méthode abstraite. ** Le fait est que l'objet SpongeCake à décorer est conservé dans le champ et spécifié comme argument lorsque l'objet est créé par le constructeur **.

Classe d'implémentation

• ** Cours ShortCake **

ShortCake.java

public class ShortCake extends SpongeCake {

	@Override
	public String getName() { //Remplacez la méthode pour obtenir le nom de la classe parent
		return "Shortcake";
	}

	@Override
	public int getPrice() { //Remplacez la méthode pour obtenir le prix de la classe parente
		return 500;
	}

}

• ** Cours de ChocolateCake **

ChocolateCake.java

public class ChocolateCake extends SpongeCake {

	@Override
	public String getName() { //Remplacez la méthode pour obtenir le nom de la classe parent
		return "Gateau au chocolat";
	}

	@Override
	public int getPrice() { //Remplacez la méthode pour obtenir le prix de la classe parente
		return 700;
	}

}

La classe ShortCake et la classe ChocolateCake sont des classes d'implémentation de la classe SpongeCake. C'est une image d'un gâteau plus concret en décorant légèrement un gâteau avec seulement une éponge. Il remplace les méthodes abstraites getName () et getPrice (), et retourne respectivement le nom et le prix. Il n'y a rien de particulièrement difficile ici non plus.

• ** Classe de décorateur fraise **

StrawberryDecorator.java

public class StrawberryDecorator extends Decorator {

	public StrawberryDecorator(SpongeCake spongeCake) { //Passer la cible de décoration dans le constructeur
		super(spongeCake);
	}

	@Override
	public String getName() { //Fraise ajoutée au début du nom du contenu
		return "fraise" + spongeCake.getName();
	}

	@Override
	public int getPrice() { //Le prix du contenu plus 100
		return spongeCake.getPrice() + 100;
	}

}

• ** Classe de décorateur banane **

BananaDecorator.java

public class BananaDecorator extends Decorator {

	public BananaDecorator(SpongeCake spongeCake) { //Passer la cible de décoration dans le constructeur
		super(spongeCake);
	}

	@Override
	public String getName() { //Banane ajoutée au début du nom du contenu
		return "banane" + spongeCake.getName();
	}

	@Override
	public int getPrice() { //Le prix du contenu plus 300
		return spongeCake.getPrice() + 300;
	}

}

La classe StrawberryDecorator et la classe BananaDecorator sont des classes d'implémentation de la classe Decorator. Ajoutez des fraises et des bananes au génoise (ou à ses sous-classes) spécifiées dans le constructeur comme décorations respectivement. Ajoutez également le prix de la même manière.

Le fait est que ** l'argument du constructeur est de type SpongeCake **. À partir de là, nous pouvons voir que les arguments qui peuvent être passés au constructeur sont la classe SpongeCake, ou ses sous-classes ShortCake et ChocolateCake. Gardez également à l'esprit que la classe Decorator est également une sous-classe de la classe SpongeCake. En d'autres termes, ** la classe StrawberryDecorator et la classe BananaDecorator qui héritent de la classe Decorator peuvent être spécifiées comme arguments du constructeur de la classe StrawberryDecorator qui effectue la décoration **. Cela permet d'ajouter plus de décoration à l'objet décoré.

Classe d'exécution

• ** Classe principale **

Main.java

public class Main {
	public static void main(String[] args) {
		//Génération de gâteau court
		SpongeCake s1 = new ShortCake();
		SpongeCake s2 = new StrawberryDecorator(s1);
		SpongeCake s3 = new BananaDecorator(s1);
		SpongeCake s4 = new StrawberryDecorator(new ShortCake());
		SpongeCake s5 = new StrawberryDecorator(new BananaDecorator(new ShortCake()));
		s1.show();
		s2.show();
		s3.show();
		s4.show();
		s5.show();
		System.out.println("--------------------------------------------");
		//Génération de gâteau au chocolat
		SpongeCake c1 = new ChocolateCake();
		SpongeCake c2 = new StrawberryDecorator(c1);
		SpongeCake c3 = new BananaDecorator(c1);
		SpongeCake c4 = new StrawberryDecorator(new ChocolateCake());
		SpongeCake c5 = new StrawberryDecorator(new BananaDecorator(new ChocolateCake()));
		c1.show();
		c2.show();
		c3.show();
		c4.show();
		c5.show();
	}
}

Nous avons créé des instances de la classe ShortCake et de la classe ChocolateCake et les avons décorées respectivement. Comme mentionné dans l'explication de la classe StrawberryDecorator et de la classe BananaDecorator, le fait est que ** Puisque la classe à décorer peut être spécifiée dans l'argument du constructeur, il est possible d'effectuer plusieurs décorations. C'est **.

Aussi,

4,5ème ligne

SpongeCake s1 = new ShortCake();
SpongeCake s2 = new StrawberryDecorator(s1);

Quand

7ème ligne

SpongeCake s4 = new StrawberryDecorator(new ShortCake());

Spécifie uniquement le ShortCake à décorer dans le constructeur, et bien que la méthode d'écriture soit différente, il s'agit en fait du même processus.

Résultat d'exécution

Le résultat de l'exécution de Main.java est le suivant. Vous pouvez voir que le gâteau court et le gâteau au chocolat d'origine sont de plus en plus décorés.

Résultat d'exécution

Shortcake:500 yens
Tarte sablée à la fraise:600 yens
Gâteau court aux bananes:800 yens
Tarte sablée à la fraise:600 yens
Gâteau court aux fraises et bananes:900 yens
--------------------------------------------
Gateau au chocolat:700 yens
Gâteau au chocolat aux fraises:800 yens
Gâteau aux bananes et au chocolat:1000 yens
Gâteau au chocolat aux fraises:800 yens
Gâteau au chocolat et aux fraises et aux bananes:1100 yens

mérite

Les avantages du modèle Decorator sont les suivants. ** 1. ** Des fonctions peuvent être ajoutées sans changer la classe héritée. ** 2. ** Diverses fonctions peuvent être ajoutées en combinant les pièces nécessaires.

Résumé

J'ai découvert le motif Decorator, qui est une série de décorations sur des objets. L'exemple de code est téléchargé ci-dessous, veuillez donc vous y référer si vous le souhaitez.

• Exemple de code de décorateur

En outre, d'autres modèles de conception sont résumés ci-dessous, veuillez donc vous y référer également.

• [Mis à jour de temps en temps] Résumé des modèles de conception en Java

Les références

• [Introduction aux modèles de conception appris dans le langage Java augmenté et révisé](https://www.amazon.co.jp/ Introduction aux modèles de conception appris dans le langage Java augmenté et révisé-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)