[GO] Ich habe ein Designmuster in Kotlin geschrieben, das von Iterator bearbeitet wurde

Erlernen des Konzepts der Schnittstelle und der Wiederverwendbarkeit von Objekten, die für die Objektorientierung wichtig sind ["Einführung in in Java-Sprache erlernte Entwurfsmuster"](https://www.amazon.co.jp/%E5%A2%97% E8% A3% 9C% E6% 94% B9% E8% A8% 82% E7% 89% 88Java% E8% A8% 80% E8% AA% 9E% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3% E5% 85% A5% E9% 96% 80-% E7% B5% 90% E5% 9F% 8E-% E6% B5% A9 / dp / 4797327030 / ref = sr_1_1? __Mk_ja_JP =% E3% 82% AB % E3% 82% BF% E3% 82% AB% E3% 83% 8A & Schlüsselwörter = Java% E8% A8% 80% E8% AA% 9E% E3% 81% A7% E5% AD% A6% E3% 81% B6 % E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3% E5 Ich habe% 85% A5% E9% 96% 80 & qid = 1559563427 & s = gateway & sr = 8-1) kennengelernt und mich entschieden, in Kotlin zu schreiben, während ich in Java war. Zunächst werde ich Iterator zusammenfassen.

• Vielen Dank auch an @sdkei für die Überprüfung dieses Mal im Kommentarbereich. Ich habe den überarbeiteten Inhalt basierend auf der Überprüfung reflektiert, daher werde ich ihn auch basierend auf diesem Punkt schreiben.

Was ist Iterator?

Es ist ein Muster, das die Elemente einer Menge wie List von Anfang an in der richtigen Reihenfolge scannt, was auf Japanisch "Wiederholer" bedeutet.

Aggregierte Schnittstelle

Die Agreagate-Schnittstelle hat die Rolle eines Aggregats, das gezählt werden kann. Die Schnittstelle wird nicht vererbt, sondern erzwingt die Implementierung der Methode.

Aggregate.java

interface Aggregate {
	public abstract Iterator iterator(); 
}

Aggregate.kt

interface Aggregate {
    fun iterator(): Iterator
}

Iterator-Schnittstelle

Eine Schnittstelle mit einer Methode zum Bearbeiten von Elementen, da sie beim Zählen von Elementen eine Rolle spielt Hier ist die Bewegung der nächsten Methode wichtig, und es ist notwendig, das Element zu erfassen und den Index voranzutreiben, damit das nächste Element erfasst werden kann. Nach einer Überprüfung dieser Iterator-Schnittstelle wurde außerdem angegeben, dass der Objekttyp in Java Any? In Kotlin entspricht. Der Unterschied zwischen Any und Any besteht darin, ob Null zugelassen werden soll oder nicht, und die API wurde so geändert, dass Null verschiedene Implementierungen zulässt.

Iterator.java

interface Iterator {
	public abstract boolean hasNext();
	public abstract Object next();
}

Iterator.kt

interface Iterator {
    fun hasNext(): Boolean
    fun next(): Any?
}

Mitgliederklasse

Erstellen Sie eine Klasse, die als Element abgerufen wird. Mit kotlin können Sie es mit member.name abrufen, ohne getter / setter zu implementieren.

Member.java

class Member {
	private String name;
	public Member(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}

Member.kt

class Member(val name: String)

Mitarbeiterklasse

Erstellen Sie eine Staff-Klasse als Implementierung von Aggregate und machen Sie die Staff-Klasse zu einer Sammlung von Mitgliedern. Implementieren Sie die in der Schnittstelle definierte Iterator-Methode.

Staff.java

class Staff implements Aggregate{
	private Member[] members;
	private int last;
	
	public Staff(int maxsize) {
		this.members = new Member[maxsize];
	}

	public Member getMemberAt(int index) {
		return members[index];
	}
	public void appendMember(Member member) {
		this.members[last] = member;
		last++;
	}
	public int getLength() {
		return last;
	}
	public Iterator iterator() {
		return new StaffIterator(this);
	}
}

Staff.kt

class Staff internal constructor(private val maxSize: Int): Aggregate {
    private val members: Array<Member?> = arrayOfNulls(maxSize)
    private var last: Int = 0

    fun getMemberAt(index: Int): Member? = members[index]

    fun appendMember(member: Member) {
        members[this.last] = member
        this.last++
    }

    fun getLength():Int = this.last

    override fun iterator(): Iterator = StaffIterator(this)
}

StaffIterator-Klasse

Erstellen Sie die StaffIterator-Klasse als Implementierung von Iteraltor und implementieren Sie die Methoden, damit Staff gescannt werden kann. Bei der nächsten Methode wird das Element erfasst und der Index zum nächsten erweitert. In der For-Syntax spielt es die Rolle von i ++. Außerdem habe ich Null mit der nächsten Methode C Any? Der Iterator-Schnittstelle zugelassen, aber ich hatte nicht vor, das Member-Objekt als null zurückzugeben, also habe ich Any, das nicht Null ist, als Rückgabewert festgelegt.

StaffIterator.java

class StaffIterator implements Iterator{
	private Staff staff;
	private int index;
	public StaffIterator(Staff staff) {
		this.staff = staff;
		this.index = 0;
	}
	public boolean hasNext() {
		if(index < staff.getLength()) {
			return true;
		}else {
			return false;			
		}
	}
	public Object next() {
		Member member = staff.getMemberAt(index);
		index++;
		return member;
	}
}

StaffIterator.kt

class StaffIterator(private val staff: Staff): Iterator {
    private var index: Int = 0
    override fun hasNext(): Boolean = index < staff.getLength()

    override fun next(): Any {
        val member: Member = staff.getMemberAt(index) as Member
        index++
        return member
    }
}

Hauptklasse

Dies ist die Hauptklasse, die die obige Klasse tatsächlich betreibt. Der Punkt hier ist, dass die Implementierung des Personals die while-Anweisung nicht beeinträchtigt.

IteratorSample.java

public class IteratorSample {
	public static void main(String[] args) {
		Staff staff = new Staff(3);
		staff.appendMember(new Member("sato"));
		staff.appendMember(new Member("suzuki"));
		staff.appendMember(new Member("saito"));
		Iterator it = staff.iterator();
		while(it.hasNext()) {
			Member member = (Member)it.next();
			System.out.println(member.getName());
		}
	}
}

IteratorSample.kt

fun main(args: Array<String>){
    val staff = Staff(3).apply {
        appendMember(Member("sato"))
        appendMember(Member("suzuki"))
        appendMember(Member("saito"))
    }
    val it: Iterator = staff.iterator()
    while (it.hasNext()) {
        val member: Member = it.next() as Member
        println(member.name)
    }
}

Ausführungsergebnis

sato
suzuki
saito

Klassen Diagramm

Impressionen

• Da die Verarbeitung der while-Anweisung nicht von der Implementierung der Unterklasse abhängt, habe ich gelernt, dass die Implementierung der while-Anweisung auch dann keine Auswirkungen hat, wenn sich die implementierte Methode ändert.
• Mit kotlin wird die Codemenge erheblich reduziert und ist leicht zu erkennen
• Zum ersten Mal habe ich gelernt, dass eine Unterklasse, die Iterator erbt, mit Objekten in einer Instanz von Interface gefüllt werden kann.
• Bei kotlin scheinen null und nullable noch nicht behandelt zu werden. Daher wäre es hilfreich, wenn Sie einen Kommentar abgeben oder darauf hinweisen könnten.

Problem 1-1

Das Staff Class Array wurde in Vector geändert. Als Ergebnis der tatsächlichen Implementierung konnte ich bestätigen, dass der Einflussbereich der Änderung innerhalb der Staff-Klasse liegt, und die Bedeutung einer geringen Abhängigkeit kennenlernen.

package practice.design_pattern_java;

import java.util.Vector;

interface Aggregate {
	public abstract Iterator iterator(); 
}

interface Iterator {
	public abstract boolean hasNext();
	public abstract Object next();
}

class Member {
	private String name;
	public Member(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}

class StaffIterator implements Iterator{
	private Staff staff;
	private int index;
	public StaffIterator(Staff staff) {
		this.staff = staff;
		this.index = 0;
	}
	public boolean hasNext() {
		if(index < staff.getLength()) {
			return true;
		}else {
			return false;			
		}
	}
	public Object next() {
		Member member = staff.getMemberAt(index);
		index++;
		return member;
	}
}

class Staff implements Aggregate{
	private Vector<Member> members = new Vector<Member>();
	private int last;

	public Member getMemberAt(int index) {
		return members.get(index);
	}
	public void appendMember(Member member) {
		this.members.addElement(member);;
		last++;
	}
	public int getLength() {
		return last;
	}
	public Iterator iterator() {
		return new StaffIterator(this);
	}
}

public class IteratorVectorSample {
	public static void main(String[] args) {
		Staff staff = new Staff();
		staff.appendMember(new Member("sato"));
		staff.appendMember(new Member("suzuki"));
		staff.appendMember(new Member("saito"));
		Iterator it = staff.iterator();
		while(it.hasNext()) {
			Member member = (Member)it.next();
			System.out.println(member.getName());
		}
	}
}

Referenz

Es war sehr leicht zu lesen und zu verstehen, wenn man sich auf Folgendes bezog.

Einführung in Kotlin für Java-Programmierer

Für Kotlins Any bezog ich mich auf Folgendes. Wo Java-Programmierer dazu neigen, über Kotlin zu stolpern