[JAVA] [Gang of Four] Apprentissage des modèles de conception - Décorateur

Décorateur-Décorateur

** Table des matières ** Soudain, l'histoire tourne mal, mais quand je lis des livres sur les modèles de conception et l'orientation des objets, j'entends souvent les mots ** responsabilité ** et ** responsabilité ** pour les objets. Cela indique ce que l'objet doit être capable de faire. Il y a aussi le principe de la responsabilité unique, qui stipule qu'il devrait y avoir une raison de changer de classe.

Par exemple, les classes suivantes ont deux raisons de modifier.

• ** Transition d'écran ** Je souhaite ajouter un traitement → Raison du changement lié à l'écran
• ** Soustraction ** Traitement ajouté → Raison du changement concernant le calcul

Calcul d'écran.kt

calcul d'écran d'interface{
dessin amusant(): Boolean
ajout amusant(num1: Int, num2: Int): Int
}

Selon le principe de la responsabilité unique, elle doit être séparée comme suit.

écran.kt

écran d'interface{
dessin amusant(): Boolean
transition d'écran amusante(): Boolean
}

Calcul.kt

calcul d'interface{
ajout amusant(num1: Int, num2: Int): Int
soustraction amusante(num2: Int, num2: Int): Int
}

Je comprends que ce principe de responsabilité unique est également une idée pour répondre avec souplesse aux changements. C'est tout pour l'histoire parallèle.

Ensuite, le sujet principal est ** d'ajouter dynamiquement la responsabilité ** à l'objectif, c'est donc un modèle qui ajoute des fonctions aux objets (instances) à un moment arbitraire sans utiliser l'héritage.

Objectif

Ajoutez dynamiquement des responsabilités à l'objet. Le modèle Decorator fournit une méthode d'extension plus flexible que le sous-classement.

Composant

· Component Une classe abstraite qui définit une interface qui peut dynamiquement ajouter des responsabilités -ConcreteComponent classe de composants classe de béton Une classe abstraite qui définit une interface qui ajoute la responsabilité à la classe de composant Decorator ・ Classe de béton de la classe de décorateur de décorateur de béton

la mise en oeuvre

Implémentez un programme qui peut ajouter diverses fonctions au moment de la création d'une instance de vue de texte.

Component Une classe abstraite qui définit une interface qui vous permet d'ajouter dynamiquement des responsabilités

Une classe abstraite qui définit une interface qui ajoute la responsabilité à la classe de composant Decorator

Afficher l'interface du composant

ViewComponent.kt

package decorator

interface ViewComponent {
    fun draw()
}

ConcreteComponent, classe de composant, classe de béton

Affichage

TextView.kt

package decorator

class TextView: ViewComponent {
    override fun draw() {
        print("[Affichage]")
    }
}

ConcreteDecorator Classe de décorateur Classe de béton

Décorateur qui projette une ombre

ShadowDecorator.kt

package decorator

class ShadowDecorator(viewComponent: ViewComponent): ViewComponent {
    val viewComponent = viewComponent

    override fun draw() {
        viewComponent.draw()
        addShadow()
    }

    private fun addShadow() {
        print(": Avec ombre")
    }
}

Décorateur à faire défiler

ScrollDecorator.kt

package decorator

class ScrollDecorator(viewComponent: ViewComponent): ViewComponent {
    val viewComponent = viewComponent

    override fun draw() {
        viewComponent.draw()
        addScroll()
    }

    private fun addScroll() {
        print(": Défilable")
    }

}

Toutes les pièces sont prêtes. Utilisons-le.

** Utilisateur **

ComponentManager.kt

package decorator

class ComponentManager {
    init {
        //Affichage du texte ombré déroulant
        val scrollShadowTextView = ScrollDecorator(ShadowDecorator(TextView()))
        //Affichage du texte déroulant
        val scrollTextView = ScrollDecorator(TextView())

        //dessin
        scrollShadowTextView.draw()
        print("\n")
        scrollTextView.draw()
    }
}

Résultat de sortie

Une fois exécuté, ce sera comme suit.

[output]
[Affichage texte]: Ombré: défilable
[Affichage texte]: défilable