[GO] [Viererbande] Designmusterlernen --Iterator

Iterator-Iterator

** Inhaltsverzeichnis ** Wenn Sie eine moderne Sprache verwenden, müssen Sie dieses Muster nicht implementieren.

Aber werden Sie in die Fußstapfen unserer Vorgänger treten, wenn es in der Standardbibliothek keine solchen Module gab? Ich werde es mit implementieren.

Zweck

Bietet eine Möglichkeit, nacheinander auf Elemente eines Aggregatobjekts zuzugreifen, ohne die zugrunde liegende interne Darstellung verfügbar zu machen.

(Wenn Sie List fest definieren, wird dies folgendermaßen ausgedrückt ...)

Komponente

-Abstraktklasse für den Zugriff auf Iterator-Elemente in der angegebenen Reihenfolge ・ Konkrete Klasse der ConcreteIterator Iterator-Klasse

-Concrete Aggregate Aggregate-Klasse konkrete Klasse

Implementierung

Lassen Sie uns so etwas wie Javas Iterator implementieren. Welche Implementierung und wann sollten ** Aggregat ** und ** Betonaggregat ** verwendet werden? Ich denke, dass es unnötig ist, wenn Iterator im generischen Typ implementiert ist.

Abstrakte Klasse für den sequentiellen Zugriff auf Iterator-Elemente

Iterator.kt

package iterator

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

    /**
     *Holen Sie sich das indexth Element
     */
    fun elementAt(index: Int): T

    /**
     *Überprüfen Sie, ob noch Elemente vorhanden sind
     */
    fun hasNext(): Boolean

    /**
     *Holen Sie sich das nächste Element
     */
    fun next(): T

    /**
     *Fügen Sie ein Element hinzu
     */
    fun add(element: T)

    /**
     *Löschen Sie das indexth-Element
     */
    fun remove(index: Int)
}

ConcreteIterator Iterator-Klasse Betonklasse

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

Menschen, die verwenden

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", "Zu", "Herr.")
        iterator.add("Yon")

        return iterator
    }

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

Ausgabeergebnis

[out-put]
Ichi
Zu
Herr.
Yon
1
2
3

Mit dem oben Gesagten konnte ich die Nöte meiner Vorgänger kennenlernen.