[GO] [Viererbande] Designmuster lernen - Brücke

Brücke-Brücke

** Inhaltsverzeichnis ** Normalerweise ist der Teil, der extrahiert werden kann, eine abstrakte Klasse, und die anderen Teile werden von einer konkreten Klasse implementiert, die die abstrakte Klasse erbt.

Dieses Muster trennt die abstrakte Klasse von der konkreten Klasse, sodass die Implementierung der abstrakten Klasse zur Laufzeit entschieden werden kann.

Nehmen Sie als Beispiel eine Symbolklasse, die Informationen zu Symbolen verwaltet. Erstens ** monochrome Symbolklasse (abstrakte Klasse) ** und ** große monochrome Symbolklasse (konkrete Klasse) ** zum Anzeigen von monochromen Symbolen in verschiedenen Größen **, ** mittlere monochrome Symbolklasse (konkrete Klasse) * *, ** Implementiere eine kleine monochrome Symbolklasse (konkrete Klasse) **. Aufgrund einer ungeplanten Spezifikationsänderung vom Client wurde es jedoch erforderlich, eine ** Farbsymbolklasse (abstrakte Klasse) ** zu implementieren, mit der RGB unterwegs frei eingestellt werden kann. Natürlich muss das Symbol die Spezifikationen für die Anzeige von drei Typen erfüllen, groß, mittel und klein, wie das monochrome Symbol.

Wenn die abstrakte Klasse und die konkrete Klasse dauerhaft durch Vererbung kombiniert werden, wird ** Farbsymbolklasse ** geerbt ** große Farbsymbolklasse **, ** mittlere Farbsymbolklasse ** ... weggelassen

Sie müssen alle großen bis kleinen Symbole erstellen, die die Farbsymbolklasse erben. Gehen Sie genauso vor, wenn Sie klarere Symbole hinzufügen ... Ausgelassen

Ist es eine ähnliche Idee, eine Zwischentabelle zu erstellen und eine Tabelle mit vielen-zu-vielen-Beziehungen in DB zu normalisieren?

Zweck

Trennen Sie die extrahierten Klassen und Implementierungen, damit sie unabhängig voneinander geändert werden können.

Komponente

・ Abstraktion abstrakte Klasse

• Eine Klasse, die die RefinedAbstraction Abstraction-Klasse erweitert ・ Konkrete Klasse des Implementierers
• Eine Klasse, die die ConcreteImplementor Implementor-Klasse erweitert

Implementierung

Implementieren Sie zunächst die monochrome Symbolklasse und die Farbsymbolklasse der abstrakten Klasse.

Abstraktion Abstrakte Klasse

Abstrakte Symbolklasse Diese Klasse ist das Herzstück des sogenannten Musters, der ** Brücke ** der abstrakten Klasse und der konkreten Klasse.

AbstIcon.kt

package bridge

abstract class AbstIcon(iconType: IconType) {
    enum class IconType(val value: String) {
        BlackAndWhite("Monochromes Symbol"),
        Color("Farbsymbol")
    }

    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
    }
}

Eine Klasse, die die RefinedAbstraction Abstraction-Klasse erweitert

Abstrakte Klasse der monochromen Ikone

AbstBlackAndWhiteIcon.kt

package bridge

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

    //Monochrome Symbol Originalverarbeitung verschiedene
}

Farbsymbol abstrakte Klasse

AbstColorIcon.kt

package bridge

class AbstColorIcon: AbstIcon(IconType.Color) {

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

    //Verschiedene Farbsymbole Originalverarbeitung
}

Erstellen Sie als Nächstes konkrete Klassen wie großes Symbol, mittleres Symbol und kleines Symbol.

Implementierer konkrete Klasse

Konkrete Symbolschnittstelle

ImpIcon.kt

package bridge

interface ImpIcon {
    enum class IconSize(val value: String) {
        Big("Großes Symbol"),
        Middle("Mittleres Symbol"),
        Small("Kleines Symbol")
    }

    fun getIcon(): String
}

Eine Klasse, die die ConcreteImplementor Implementor-Klasse erweitert

Große, mittlere, kleine Symbolklasse

BigIcon.kt

package bridge

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

    private val iconType = iconType

    override fun getIcon(): String {
        return "【Art】:" + iconType.value + "【Größe】:" + ImpIcon.IconSize.Big.value
    }

}

MiddleIcon.kt

package bridge

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

    private val iconType = iconType

    override fun getIcon(): String {
        return "【Art】:" + iconType.value + "【Größe】:" + ImpIcon.IconSize.Middle.value
    }
}

SmallIcon.kt

package bridge

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

    private val iconType = iconType

    override fun getIcon(): String {
        return "【Art】:" + iconType.value + "【Größe】:" + ImpIcon.IconSize.Small.value
    }
}

Die Person, die jedes Symbol verwendet

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())
    }
}

Damit ist die Implementierung des Beispielcodes mithilfe des Symbols abgeschlossen.

Ausgabeergebnis

[output]
Farbsymbol
[Typ]: Farbsymbol [Größe]: Großes Symbol
[Typ]: Farbsymbol [Größe]: Mittleres Symbol
[Typ]: Farbsymbol [Größe]: Kleines Symbol
Monochromes Symbol
[Typ]: Monochromes Symbol [Größe]: Großes Symbol
[Typ]: Monochromes Symbol [Größe]: Mittleres Symbol
[Typ]: Monochromes Symbol [Größe]: Kleines Symbol

Fügen wir nun ein klares Symbol mit transparentem Hintergrund hinzu. Bei der herkömmlichen Methode wird ** großes klares Auge ** ... abgekürzt, aber in diesem Muster kann es nur durch Implementieren der AbstClearIcon-Klasse realisiert werden, die die AbstIcon-Klasse erbt. ..

AbstClearIcon.kt

package bridge

class AbstClearIcon: AbstIcon(IconType.Clear) {

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

    //Löschen Sie Symbol Originalverarbeitung verschiedene
}

Fügen Sie der Client-Klasse den folgenden Code hinzu und versuchen Sie es erneut.

Client.kt

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

[output]
Farbsymbol
[Typ]: Farbsymbol [Größe]: Großes Symbol
[Typ]: Farbsymbol [Größe]: Mittleres Symbol
[Typ]: Farbsymbol [Größe]: Kleines Symbol
Monochromes Symbol
[Typ]: Monochromes Symbol [Größe]: Großes Symbol
[Typ]: Monochromes Symbol [Größe]: Mittleres Symbol
[Typ]: Monochromes Symbol [Größe]: Kleines Symbol
Symbol löschen
[Typ]: Symbol löschen [Größe]: Großes Symbol
[Typ]: Symbol löschen [Größe]: Mittleres Symbol
[Typ]: Symbol löschen [Größe]: Kleines Symbol

Es war leicht zu erweitern.

Dies ermöglicht eine einfache Implementierung, unabhängig davon, wie stark die abstrakte Klassenseite oder die konkrete Klassenseite zunimmt.