[GO] [Gang of Four] Apprentissage des modèles de conception - Stratégie

Stratégie --Stratégie

** Table des matières ** Il n'y a aucun moyen de l'exprimer autrement que ce qui est écrit à cet effet, mais pour le mettre plus en détail, c'est comme faire abstraction des parties qui peuvent être partagées par l'algorithme et implémenter le comportement dans une classe concrète.

Objectif

Définissez un ensemble d'algorithmes, encapsulez chaque algorithme et rendez-les interchangeables. Le modèle de stratégie permet à l'algorithme d'être modifié indépendamment des clients qui l'utilisent.

Composant

・ Stratégie Classe abstraite de la partie commune ・ ConcreateStrategy Classe de béton de la partie commune ・ Partie d'algorithme de contexte

la mise en oeuvre

Implémentons le tri par bulles et le tri par shaker, qui sont des algorithmes de tri des tableaux.

Stratégie Classe abstraite de la partie commune

Sort.kt

package strategy

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

ConcreateStrategy Une classe concrète de parties communes

Pour les tableaux de type 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>
    }
}

Partie d'algorithme de contexte

Mettre en œuvre à partir du tri à bulles.

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

Vient ensuite le tri par shaker

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

Faisons le tri maintenant.

Les personnes qui utilisent

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

        //Tri à bulles
        BubbleSort(intSort).sort(array1)

        println("Résultat du tri à bulles")
        array1.forEach {
            println("$it")
        }

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

        println("Résultat du tri Shaker")
        array2.forEach {
            println("$it")
        }
    }
}

[out-put]
Résultat du tri à bulles
1
2
7
22
22
35
533
567
9913
43212
Résultat du tri Shaker
3
11
25
32
77
880
834534

C'est un modèle qui permet une implémentation flexible par un code conforme à DIP.

Créez non seulement un tableau de type Int, mais également un DoubleSort '' qui implémente l'interface de tri '', par exemple. Je change juste le type du tableau défini par la méthode setArray ...

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

        //Tri à bulles
        BubbleSort(doubleSort).sort(array1)

        println("Résultat du tri à bulles")
        array1.forEach {
            println("$it")
        }

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

        println("Résultat du tri Shaker")
        array2.forEach {
            println("$it")
        }
    }
}

Résultat de sortie

[out-put]
Résultat du tri à bulles
5.0
5.4
33.5
225.3
225.4
Résultat du tri Shaker
10.1
10.2
10.3
10.4
10.5
10.6

Méthode d'usine Cela ressemble à un modèle qui va très bien avec le modèle. intsortOudoublesortSi la classe de méthode d'usine génère la classe, il semble qu'un module très pratique puisse être créé.

c'est tout