Quel est le mode décorateur?
Ajoutez dynamiquement quelques responsabilités supplémentaires à un objet. En termes d'ajout de fonctions, le mode décorateur est plus flexible que la génération de sous-classes.
1. Structure
Composant: définit une interface d'objet qui peut ajouter dynamiquement des responsabilités à ces objets.
Interface Component {public void Operation ();} ConcreteComponent: Implémentez l'interface définie par le composant. class ConcreteComponent implémente composant {@Override public void opération () {System.out.println ("comportement initial"); }} Décorateur: décorer la classe abstraite, hérite du composant, étend les fonctions de la classe de composants à partir de classes externes, mais pour la composante, il n'est pas nécessaire de connaître l'existence du décorateur.
Class Decorator implémente le composant {// maintenir un objet de composant et former une relation d'agrégation avec composant de composant protégé par composant; // Passez dans l'objet pour être davantage modifié du décorateur public (composant composant) {this.component = composant; } @Override // Appelez la méthode d'origine à modifier l'opération du public public () {Component.Operation (); }} ConcreteDeCorator: Des objets décoratifs spécifiques jouent la fonction d'ajouter des responsabilités à la composante.
Class ConcreteDeCoratora étend le décorateur {private String Addstate = "new Property 1"; public ConcreteDeCoratora (composant composant) {super (composant); } public void opération () {super.operation (); System.out.println ("Ajouter l'attribut:" + AddState); }} classe ConcreteDeCoratorB étend Decorator {public ConcreteDeCoratorB (composant composant) {super (composant); } public void opération () {super.operation (); AddingBehavior (); } public void AdddBehavior () {System.out.println ("Ajouter un comportement"); }} Code de test
classe publique DecoratorPattern {public static void main (String [] args) {composant composant = new CONCRETEComponent (); Component.Operation (); System.out.println("================================================================================================== =====================================================================. =====================================================================. =====================================================================. =====================================================================. =====================================================================. =====================================================================. System.out.println("================================================================================================ System.out.output(); }} Résultats en cours d'exécution
Initial comportement ==================================================================================================================================== ============================================================================. ============================================================================. ============================================================================.
2. Scénarios d'application
1. Vous devez ajouter des responsabilités à un objet dynamiquement et transparent, c'est-à-dire qu'il n'affecte pas d'autres objets.
2. Vous devez ajouter dynamiquement des fonctions à un objet, et ces fonctions peuvent être annulées dynamiquement.
3. Il est nécessaire d'ajouter un grand nombre de fonctions générées par la disposition et la combinaison de certaines fonctions de base, de sorte que la relation d'héritage devient irréaliste.
4. Lorsque la méthode de génération de sous-classes ne peut pas être utilisée pour l'expansion. Un scénario est qu'il peut y avoir un grand nombre d'extensions indépendantes, ce qui produira un grand nombre de sous-classes pour soutenir chaque combinaison, ce qui fait exploser le nombre de sous-classes. Un autre cas peut être dû au fait que la définition de classe est masquée, ou la définition de classe ne peut pas être utilisée pour générer des sous-classes.
3. Points clés
1. Les objets décoratifs et les objets réels ont la même interface. De cette façon, l'objet client peut interagir avec l'objet décoratif de la même manière que l'objet réel.
2. L'objet décoratif contient une référence à un objet réel.
3. L'objet décoratif accepte toutes les demandes du client. Il transmet ces demandes à l'objet réel.
4. Les objets décoratifs peuvent ajouter des fonctions supplémentaires avant ou après le transfert de ces demandes. Cela garantit qu'à l'exécution, des fonctions supplémentaires peuvent être ajoutées à l'extérieur sans modifier la structure d'un objet donné. Dans la conception orientée objet, les extensions fonctionnelles d'une classe donnée sont généralement obtenues grâce à l'héritage.
Ce qui précède est une introduction au contenu pertinent sur le mode décorateur Java, j'espère que cela sera utile à l'apprentissage de tous.