[GO] [Viererbande] Design Pattern Learning - Template-Methode

Template Method-Template

Inhaltsverzeichnis Es ist ein Muster, das den gemeinsamen Teil des Algorithmus abstrahiert und den Teil mit unterschiedlichem Verhalten in einer konkreten Klasse implementiert. Wenn Sie nur die Erklärung lesen, entspricht dies dem Muster Strategie, wird jedoch durch Delegation dort und Vererbung hier realisiert.

Durch die Vererbung wird die Abhängigkeit stärker, daher denke ich persönlich, dass das Muster Strategie besser ist. Ich denke.

Dies erfordert jedoch die Implementierung weniger Klassen.

Zweck

Wir werden das Grundgerüst des Algorithmus für eine Operation definieren und einige Schritte der Definition in der Unterklasse überlassen. Das Muster der Vorlagenmethode definiert einen Schritt in einem Algorithmus mit einer Unterklasse neu, ohne die Struktur des Algorithmus zu ändern.

Komponente

・ Gemeinsamer Teil von AbstractClass ・ ConcreteClass Nicht üblich

Implementierung

Strategie Implementieren Sie ein Programm, das Arrays ähnlich dem Muster sortiert.

AbstractClass gemeinsamer Teil

BubbleSort.kt

package templatemethod

abstract class BubbleSort {
    private var operations = 0
    protected var length = 0

    protected fun doSort(): Int {
        operations = 0
        if (length <= 1) return operations

        for (nextToLast in length - 1 downTo 0) {
            for (index in 0 until nextToLast) {
                if (outOfOrder(index)) swap(index)
                operations++
            }
        }
        return operations
    }

    protected abstract fun swap(index: Int)
    protected abstract fun outOfOrder(index: Int): Boolean
}

ConcreteClass-Teile, die nicht üblich sind

Konkrete Klasse vom Typ Int Array

IntBubbleSort.kt

package templatemethod

class IntBubbleSort: BubbleSort() {

    private lateinit var array: Array<Int>

    fun sort(theArray: Array<Int>): Int {
        array = theArray
        length = theArray.size
        return doSort()
    }

    override fun swap(index: Int) {
        val temp = array[index]
        array[index] = array[index + 1]
        array[index + 1] = temp
    }

    override fun outOfOrder(index: Int): Boolean {
        return array[index] > array[index + 1]
    }

}

Doppelte Array-Betonklasse

DoubleBubbleSort.kt

package templatemethod

class DoubleBubbleSort: BubbleSort() {

    private lateinit var array: Array<Double>

    fun sort(theArray: Array<Double>): Int {
        array = theArray
        length = theArray.size
        return doSort()
    }

    override fun swap(index: Int) {
        val temp = array[index]
        array[index] = array[index + 1]
        array[index + 1] = temp
    }

    override fun outOfOrder(index: Int): Boolean {
        return array[index] > array[index + 1]
    }
}

Nun, dies kann auch in einer Klasse mit Generika erreicht werden ...

Menschen, die verwenden

Client.kt

package templatemethod

class Client {
    init {
        val intArray = arrayOf(332, 1, 13, 3232, 456, 22, 5)
        println("Vor dem Sortieren des Int-Arrays")
        intArray.forEach {
            println(it)
        }
        //Sortierung
        IntBubbleSort().sort(intArray)
        println("Nach dem Sortieren des Int-Arrays")
        intArray.forEach {
            println(it)
        }

        val doubleArray = arrayOf(10.01, 10.5, 10.4123, 10.12, 10.87)
        println("Double Vor dem Sortieren")
        doubleArray.forEach {
            println(it)
        }
        //Sortierung
        DoubleBubbleSort().sort(doubleArray)
        println("Nach doppelter Array-Sortierung")
        doubleArray.forEach {
            println(it)
        }
    }
}

Ausgabeergebnis

[out-put]
Vor dem Sortieren des Int-Arrays
332
1
13
3232
456
22
5
Nach dem Sortieren des Int-Arrays
1
5
13
22
332
456
3232
Double Vor dem Sortieren
10.01
10.5
10.4123
10.12
10.87
Nach doppelter Array-Sortierung
10.01
10.12
10.4123
10.5
10.87

Es ist ein ziemlich einfaches Muster. Ich denke, es wird überall verwendet.

das ist alles