[JAVA] [Gang of Four] Apprentissage des modèles de conception - Itérateur

Itérateur-Itérateur

** Table des matières ** Si vous utilisez un langage moderne, c'est un modèle que vous ne prendriez pas la peine de mettre en œuvre.

Mais allez-vous suivre les traces de nos prédécesseurs alors qu'il n'y avait pas de tels modules dans la bibliothèque standard? Je vais le mettre en œuvre avec.

Objectif

Fournit un moyen d'accéder aux éléments d'un objet agrégé en séquence sans exposer la représentation interne sous-jacente.

(Si vous définissez fermement List, cela s'exprimera comme ceci ...)

Composant

-Classe abstraite pour accéder aux éléments Iterator dans l'ordre ・ Classe de béton de la classe ConcreteIterator Iterator -Classe abstraite pour créer une instance de type Aggregate Iterator -Concrete Aggregate Classe de béton

la mise en oeuvre

Implémentons quelque chose comme Iterator de Java. Quelle mise en œuvre et quand utiliser ** Aggregate ** et ** Concrete Aggregate **? Je pense que ce n'est pas nécessaire si Iterator est implémenté dans le type générique.

Classe abstraite pour l'accès séquentiel aux éléments Iterator

Iterator.kt

package iterator

interface Iterator<T> {
    var index: Int
    var list: ArrayList<T>

    /**
     *Récupère l'élément indexth
     */
    fun elementAt(index: Int): T

    /**
     *Vérifiez s'il reste des éléments
     */
    fun hasNext(): Boolean

    /**
     *Obtenez l'élément suivant
     */
    fun next(): T

    /**
     *Ajouter un élément
     */
    fun add(element: T)

    /**
     *Supprimer l'élément indexth
     */
    fun remove(index: Int)
}

ConcreteIterator Classe Iterator Classe de béton

ConcreteIterator.kt

package iterator

class ConcreteIterator<T>(vararg elements: T): Iterator<T> {

    override var index = 0
    override var list = ArrayList<T>()

    init {
        list.addAll(elements)
    }

    override fun elementAt(index: Int): T {
        return list[index]
    }

    override fun hasNext(): Boolean {
        return index != list.size
    }

    override fun next(): T {
        return list[index++]
    }

    override fun add(element: T) {
        list.add(element)
    }

    override fun remove(index: Int) {
        list.removeAt(index)
    }
}s

Les personnes qui utilisent

Client.kt

package iterator

class Client {
    init {
        val strIterator = makeStrIterator()
        while(strIterator.hasNext()) {
            println(strIterator.next())
        }

        val intIterator = makeIntIterator()
        while (intIterator.hasNext()) {
            println(intIterator.next())
        }
    }

    private fun makeStrIterator(): Iterator<String> {
        val iterator = ConcreteIterator("Ichi", "À", "M.")
        iterator.add("Yon")

        return iterator
    }

    private fun makeIntIterator(): Iterator<Int> {
        return ConcreteIterator(1, 2, 3)
    }
}

Résultat de sortie

[out-put]
Ichi
À
M.
Yon
1
2
3

Avec ce qui précède, j'ai pu connaître les difficultés de mes prédécesseurs.