[JAVA] [Gang of Four] Apprentissage des modèles de conception - Pont

Pont-Pont

** Table des matières ** Normalement, la partie qui peut être extraite est une classe abstraite, et les autres parties sont implémentées par une classe concrète qui hérite de la classe abstraite.

Ce modèle sépare la classe abstraite de la classe concrète afin que l'implémentation de la classe abstraite puisse être décidée au moment de l'exécution.

Prenez une classe d'icônes qui gère les informations sur les icônes à titre d'exemple. Premièrement, ** classe d'icônes monochromes (classe abstraite) ** et ** grande classe d'icônes monochromes (classe concrète) ** pour afficher des icônes monochromes de différentes tailles **, ** classe d'icônes monochromes moyenne (classe concrète) * *, ** Implémenter une petite classe d'icônes monochromes (classe concrète) **. Cependant, en raison d'un changement de spécification imprévu du client, il est devenu nécessaire d'implémenter la ** classe d'icônes de couleur (classe abstraite) ** qui permet de définir librement RVB en cours de route. Bien entendu, l'icône doit répondre aux spécifications d'affichage de trois types, grand, moyen et petit, comme l'icône monochrome.

Lorsque la classe abstraite et la classe concrète sont combinées de manière permanente par héritage, ** classe d'icône de couleur ** héritée ** classe d'icône de grande couleur **, ** classe d'icône de couleur moyenne ** ... omis

Vous devrez créer toutes les grandes et petites icônes qui héritent de la classe d'icônes de couleur. Lorsque vous ajoutez des icônes plus claires, faites de même ... Omis

Est-ce une idée similaire de créer une table intermédiaire et de normaliser une table avec des relations plusieurs-à-plusieurs dans DB?

Objectif

Séparez les classes et les implémentations extraites afin qu'elles puissent être modifiées indépendamment.

Composant

・ Classe abstraite d'abstraction -Une classe qui étend la classe d'abstraction RefinedAbstraction ・ Mettre en œuvre la classe de béton -Une classe qui étend la classe ConcreteImplementor Implementor

la mise en oeuvre

Tout d'abord, implémentez la classe d'icônes monochrome et la classe d'icônes de couleur de la classe abstraite.

Classe abstraite d'abstraction

Classe d'icône abstraite Cette classe est le cœur du soi-disant pattern, le ** bridge ** de la classe abstraite et de la classe concrète.

AbstIcon.kt

package bridge

abstract class AbstIcon(iconType: IconType) {
    enum class IconType(val value: String) {
        BlackAndWhite("Icône monochrome"),
        Color("Icône de couleur")
    }

    private var bigIcon: ImpIcon = BigIcon(iconType)
    private var middleIcon: ImpIcon = MiddleIcon(iconType)
    private var smallIcon: ImpIcon = SmallIcon(iconType)

    abstract fun getType(): String

    fun getBigIcon(): ImpIcon {
        return bigIcon
    }

    fun getMiddleIcon(): ImpIcon {
        return middleIcon
    }

    fun getSmallIcon(): ImpIcon {
        return smallIcon
    }
}

Une classe qui étend la classe d'abstraction RefinedAbstraction

Classe abstraite icône monochrome

AbstBlackAndWhiteIcon.kt

package bridge

class AbstBlackAndWhiteIcon: AbstIcon(IconType.BlackAndWhite) {
    override fun getType(): String {
        return AbstIcon.IconType.BlackAndWhite.value
    }

    //Traitement original de l'icône monochrome divers
}

Classe abstraite icône couleur

AbstColorIcon.kt

package bridge

class AbstColorIcon: AbstIcon(IconType.Color) {

    override fun getType(): String {
        return AbstIcon.IconType.Color.value
    }

    //Traitement original de diverses icônes de couleur
}

Ensuite, créez des classes concrètes telles qu'une grande icône, une icône moyenne et une petite icône.

Mettre en œuvre la classe concrète

Interface d'icône en béton

ImpIcon.kt

package bridge

interface ImpIcon {
    enum class IconSize(val value: String) {
        Big("Grande icône"),
        Middle("Icône moyenne"),
        Small("Petite icône")
    }

    fun getIcon(): String
}

Une classe qui étend la classe ConcreteImplementor Implementor

Classe d'icônes grande, moyenne et petite

BigIcon.kt

package bridge

class BigIcon(iconType: AbstIcon.IconType): ImpIcon {

    private val iconType = iconType

    override fun getIcon(): String {
        return "【type】:" + iconType.value + "【Taille】:" + ImpIcon.IconSize.Big.value
    }

}

MiddleIcon.kt

package bridge

class MiddleIcon(iconType: AbstIcon.IconType): ImpIcon {

    private val iconType = iconType

    override fun getIcon(): String {
        return "【type】:" + iconType.value + "【Taille】:" + ImpIcon.IconSize.Middle.value
    }
}

SmallIcon.kt

package bridge

class SmallIcon(iconType: AbstIcon.IconType): ImpIcon {

    private val iconType = iconType

    override fun getIcon(): String {
        return "【type】:" + iconType.value + "【Taille】:" + ImpIcon.IconSize.Small.value
    }
}

La personne qui utilise chaque icône

Client.kt

package bridge

class Client {
    init {
        val colorIcon = AbstColorIcon()
        println(colorIcon.getType())
        println(colorIcon.getBigIcon().getIcon())
        println(colorIcon.getMiddleIcon().getIcon())
        println(colorIcon.getSmallIcon().getIcon())

        val blackAndWhiteIcon = AbstBlackAndWhiteIcon()
        println(blackAndWhiteIcon.getType())
        println(blackAndWhiteIcon.getBigIcon().getIcon())
        println(blackAndWhiteIcon.getMiddleIcon().getIcon())
        println(blackAndWhiteIcon.getSmallIcon().getIcon())
    }
}

Cela termine l'implémentation de l'exemple de code à l'aide de l'icône.

Résultat de sortie

[output]
Icône de couleur
[Type]: Icône de couleur [Taille]: Grande icône
[Type]: Icône de couleur [Taille]: Icône moyenne
[Type]: Icône de couleur [Taille]: Petite icône
Icône monochrome
[Type]: icône monochrome [Taille]: grande icône
[Type]: icône monochrome [Taille]: icône moyenne
[Type]: icône monochrome [Taille]: petite icône

Ajoutons maintenant une icône claire avec un fond transparent. Dans la méthode conventionnelle, ** grand oeil clair ** ... est abrégé, mais dans ce modèle, il ne peut être réalisé qu'en implémentant AbstClearIcon class` `` qui hérite de AbstIcon class` ``. ..

AbstClearIcon.kt

package bridge

class AbstClearIcon: AbstIcon(IconType.Clear) {

    override fun getType(): String {
        return AbstIcon.IconType.Clear.value
    }

    //Icône claire traitement original divers
}

Ajoutez le code suivant à la classe Client et réessayez.

Client.kt

    val clearIcon = AbstClearIcon()
    println(clearIcon.getType())
    println(clearIcon.getBigIcon().getIcon())
    println(clearIcon.getMiddleIcon().getIcon())
    println(clearIcon.getSmallIcon().getIcon())

[output]
Icône de couleur
[Type]: Icône de couleur [Taille]: Grande icône
[Type]: Icône de couleur [Taille]: Icône moyenne
[Type]: Icône de couleur [Taille]: Petite icône
Icône monochrome
[Type]: icône monochrome [Taille]: grande icône
[Type]: icône monochrome [Taille]: icône moyenne
[Type]: icône monochrome [Taille]: petite icône
Icône claire
[Type]: Effacer l'icône [Taille]: Grande icône
[Type]: icône d'effacement [Taille]: icône moyenne
[Type]: icône d'effacement [Taille]: petite icône

C'était facile à développer.

Cela permet de l'implémenter facilement, peu importe combien le côté de la classe abstraite augmente ou le côté de la classe concrète augmente.