[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.

Recommended Posts

[Gang of Four] Apprentissage des modèles de conception - Itérateur
[Gang of Four] Apprentissage des modèles de conception
[Gang of Four] Apprentissage des modèles de conception - Décorateur
[Gang of Four] Apprentissage des modèles de conception - Visiteur
[Gang of Four] Apprentissage des modèles de conception - Médiateur
[Gang of Four] Apprentissage des modèles de conception - Façade
[Gang of Four] Apprentissage des modèles de conception - Composite
[Gang of Four] Apprentissage des modèles de conception - Prototype
[Gang of Four] Apprentissage des modèles de conception --Mémento
[Gang of Four] Apprentissage des modèles de conception - État
[Gang of Four] Apprentissage des modèles de conception - Interprétation
[Gang of Four] Apprentissage des modèles de conception - Constructeur
[Gang of Four] Apprentissage des modèles de conception - Pont
[Gang of Four] Apprentissage des modèles de conception - Proxy
[Gang of Four] Apprentissage des modèles de conception - Stratégie
[Gang of Four] Apprentissage des modèles de conception - Adaptateur
[Gang of Four] Apprentissage des modèles de conception --Observer
[Gang of Four] Apprentissage des modèles de conception - Commande
[Gang of Four] Apprentissage des modèles de conception - Poids du vol
[Gang of Four] Apprentissage des modèles de conception - Usine abstraite
[Gang of Four] Apprentissage des modèles de conception - Méthode d'usine
[Gang of Four] Apprentissage des modèles de conception - Chaîne de responsabilité
[Gang of Four] Apprentissage des modèles de conception - Méthode du modèle
Modèles Gang of Four (GoF) en Python
Apprenez le modèle de conception "Iterator" avec Python
Modèle de conception #Builder
Modèle de conception #Decorator
Apprentissage de la reconnaissance de formes en vidéo Partie 1 Champ de reconnaissance de formes
Modèle de conception #Observer
Modèle de conception #Facade
Modèle de conception #Strategy
Modèle de conception #Singleton
Modèle de conception #Proxy
J'ai écrit un modèle de conception en kotlin, édité par Iterator
Apprenez le modèle de conception «Chaîne de responsabilité» en Python
Design Pattern #Factory, méthode
Modèle d'itérateur en Java
Deep learning 1 Pratique du deep learning
Design Pattern #Template, méthode
L'histoire selon laquelle les modèles de conception du GoF ne sont rien de plus qu'une «introduction de couches abstraites»