[GO] [Viererbande] Design Pattern Learning - Strategie

Strategie - Strategie

** Inhaltsverzeichnis ** Es gibt keine andere Möglichkeit, es auszudrücken als das, was für diesen Zweck geschrieben wurde. Um es genauer auszudrücken, ist es so, als würde man die Teile abstrahieren, die vom Algorithmus gemeinsam genutzt werden können, und das Verhalten in einer konkreten Klasse implementieren.

Zweck

Definieren Sie eine Reihe von Algorithmen, kapseln Sie jeden Algorithmus und machen Sie sie austauschbar. Das Strategiemuster ermöglicht es, den Algorithmus unabhängig von den Clients zu ändern, die ihn verwenden.

Komponente

・ Strategie Gemeinsame Teil abstrakte Klasse ・ ConcreateStrategy Konkrete Klasse des gemeinsamen Teils ・ Teil des Kontextalgorithmus

Implementierung

Lassen Sie uns die Blasensortierung und die Shaker-Sortierung implementieren, die Algorithmen zum Sortieren von Arrays sind.

Strategie Gemeinsamer Teil abstrakte Klasse

Sort.kt

package strategy

interface Sort {
    fun swap(index: Int)
    fun outOfOrder(index: Int): Boolean
    fun length(): Int
    fun setArray(array: Any)
}

ConcreateStrategy Eine konkrete Klasse gemeinsamer Teile

Für Arrays vom Typ Int.

IntSort.kt

package strategy

class IntSort: Sort {
    private lateinit var array: Array<Int>

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

    override fun length(): Int {
        return array.size
    }

    override fun setArray(array: Any) {
        this.array = array as Array<Int>
    }
}

Teil des Kontextalgorithmus

Aus Blasensortierung implementieren.

BubbleSort.kt

package strategy

class BubbleSort(private val sort: Sort) {
    private var operations = 0
    private var length = 0

    fun sort(array: Any): Int {
        sort.setArray(array)
        length = sort.length()
        operations = 0

        if (length <= 1) {
            return operations
        }

        for (nextToLast in length - 2 downTo 0) {
            for (index in 0..nextToLast) {
                if (sort.outOfOrder(index)) {
                    sort.swap(index)
                }
                operations++
            }
        }

        return operations
    }
}

Als nächstes kommt Shaker Sort

ShakerSort.kt

package strategy

class ShakerSort(private val sort: Sort) {

    fun sort(array: Any): Int {
        sort.setArray(array)
        var length = sort.length()
        var operations = 0

        if (length <= 1) {
            return operations
        }

        var thisPassInOrder = false

        loop@ for (nextToLast in length - 2 downTo 0) {
            if (thisPassInOrder) {
                break@loop
            }

            thisPassInOrder = true
            for (index in 0..nextToLast) {
                if (sort.outOfOrder(index)) {
                    sort.swap(index)
                    thisPassInOrder = false
                }
                operations++
            }
        }
        return operations
    }
}

Lass es uns jetzt sortieren.

Menschen, die verwenden

Client.kt

package strategy

class Client {
    init {
        val array1 = arrayOf(22,533,43212,1,567,7,22,2,35,9913)
        val array2 = arrayOf(25,77,834534,32,11,3,880)

        val intSort = IntSort()

        //Blasensorte
        BubbleSort(intSort).sort(array1)

        println("Blasensortierungsergebnis")
        array1.forEach {
            println("$it")
        }

        //Shaker sortieren
        ShakerSort(intSort).sort(array2)

        println("Ergebnis der Shaker-Sortierung")
        array2.forEach {
            println("$it")
        }
    }
}

[out-put]
Blasensortierungsergebnis
1
2
7
22
22
35
533
567
9913
43212
Ergebnis der Shaker-Sortierung
3
11
25
32
77
880
834534

Es ist ein Muster, das eine flexible Implementierung durch Code ermöglicht, der DIP entspricht.

Erstellen Sie nicht nur ein Array vom Typ Int, sondern auch ein DoubleSort-Array, das beispielsweise die Sortierschnittstelle implementiert. Ich ändere nur den Typ des Arrays, das mit der setArray-Methode festgelegt wurde ...

DoubleSort.kt

package strategy

class DoubleSort: Sort {
    private lateinit var array: Array<Double>

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

    override fun length(): Int {
        return array.size
    }

    override fun setArray(array: Any) {
        this.array = array as Array<Double>
    }
}

Client.kt

package strategy

class Client {
    init {
        val array1 = arrayOf(33.5, 5.4, 5.0, 225.4, 225.3)
        val array2 = arrayOf(10.4, 10.2, 10.5, 10.1, 10.3, 10.6)

        val doubleSort = DoubleSort()

        //Blasensorte
        BubbleSort(doubleSort).sort(array1)

        println("Blasensortierungsergebnis")
        array1.forEach {
            println("$it")
        }

        //Shaker sortieren
        ShakerSort(doubleSort).sort(array2)

        println("Ergebnis der Shaker-Sortierung")
        array2.forEach {
            println("$it")
        }
    }
}

Ausgabeergebnis

[out-put]
Blasensortierungsergebnis
5.0
5.4
33.5
225.3
225.4
Ergebnis der Shaker-Sortierung
10.1
10.2
10.3
10.4
10.5
10.6

Factory-Methode Es sieht aus wie ein Muster, das sehr gut zum Muster passt. intsortOderdoublesortWenn die Factory-Methodenklasse die Klasse generiert, kann anscheinend ein sehr praktisches Modul erstellt werden.

das ist alles