[JAVA] [Gang of Four] Apprentissage des modèles de conception - Méthode du modèle

Modèle de méthode-modèle

Table des matières C'est un modèle qui fait abstraction de la partie commune de l'algorithme et implémente la partie avec un comportement différent dans la classe concrète. Si vous ne lisez que l'explication, c'est la même chose que le modèle Stratégie, mais il est réalisé par délégation là-bas et héritage ici.

L'héritage rend la dépendance plus forte, donc je pense personnellement que le modèle Strategy est meilleur. Je pense.

Cependant, cela nécessite moins de classes à implémenter.

Objectif

Nous définirons le squelette de l'algorithme pour une opération, et laisserons quelques étapes à la définition dans la sous-classe. Le modèle de méthode de modèle redéfinit une étape dans un algorithme avec une sous-classe sans changer la structure de l'algorithme.

Composant

・ Partie commune AbstractClass ・ ConcreteClass Pas commun

la mise en oeuvre

Stratégie Implémentez un programme qui trie les tableaux, similaire au modèle.

Partie commune de la classe abstraite

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
}

Pièces de ConcreteClass qui ne sont pas courantes

Classe de béton de type int

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

}

Classe de béton à matrice double

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

Eh bien, cela peut également être réalisé dans une classe en utilisant Generics ...

Les personnes qui utilisent

Client.kt

package templatemethod

class Client {
    init {
        val intArray = arrayOf(332, 1, 13, 3232, 456, 22, 5)
        println("Avant de trier le tableau Int")
        intArray.forEach {
            println(it)
        }
        //Tri
        IntBubbleSort().sort(intArray)
        println("Après le tri du tableau Int")
        intArray.forEach {
            println(it)
        }

        val doubleArray = arrayOf(10.01, 10.5, 10.4123, 10.12, 10.87)
        println("Double avant le tri")
        doubleArray.forEach {
            println(it)
        }
        //Tri
        DoubleBubbleSort().sort(doubleArray)
        println("Après le tri par double tableau")
        doubleArray.forEach {
            println(it)
        }
    }
}

Résultat de sortie

[out-put]
Avant de trier le tableau Int
332
1
13
3232
456
22
5
Après le tri du tableau Int
1
5
13
22
332
456
3232
Double avant le tri
10.01
10.5
10.4123
10.12
10.87
Après le tri par double tableau
10.01
10.12
10.4123
10.5
10.87

C'est un modèle assez basique. Je pense qu'il sera utilisé partout.

c'est tout