デザインパターンをkotlinで書いてみた　Iterator編

オブジェクト指向で大切になるInterfaceの考え方やオブジェクトの再利用性を学ぶために[「Java言語で学ぶデザインパターン入門」](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&keywords=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%85%A5%E9%96%80&qid=1559563427&s=gateway&sr=8-1)について学び、Javaとついでにkotlinで書いてみることにしました。
最初はIteratorについてまとめます。

※また、今回コメント欄にレビューをいただきました[@sdkei](https://qiita.com/sdkei)さんありがとうございます。
レビューを元に修正しました内容を反映させましたので、その点も踏まえて書いていこうと思います。

##Iteratorとは
List等の集合の要素を最初から順番にスキャンするパターンで、日本語だと「反復子」という意味。

##Aggregateインターフェース
数え上げる事のできる集合体という役割をAggreagateインターフェースで持たせます。
インターフェースは継承ではなく、役割を持たせて強制的にメソッドを実装させる役割があります。

```java:Aggregate.java
interface Aggregate {
	public abstract Iterator iterator(); 
}
```
```kotlin:Aggregate.kt
interface Aggregate {
    fun iterator(): Iterator
}
```

##Iteratorインターフェース
要素を数え上げる役割を果たすので、要素操作するメソッドを持たせるインターフェース
ここでnextメソッドの動きが大切で、要素を取得する、次の要素を取得できるようにindexを進める処理が必要。
また、こちらのIteratorインターフェースについてレビューをいただきましてJavaでいうObject型はKotlinでいうAny?に相当するとのことでした。
AnyとAny?の違いはNullを許容するかどうかの違いになり、APIでは様々な実装ができるようNullを許容するAny?に修正しました。

```java:Iterator.java
interface Iterator {
	public abstract boolean hasNext();
	public abstract Object next();
}
```
```kotlin:Iterator.kt
interface Iterator {
    fun hasNext(): Boolean
    fun next(): Any?
}
```

##Memberクラス
要素として取得されるクラスを作成。
kotlinだとgetter/setterを実装しなくてもmember.nameで取得できます。

```java:Member.java
class Member {
	private String name;
	public Member(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}
```
```kotlin:Member.kt
class Member(val name: String)
```

##Staffクラス
Aggregateの実装としてStaffクラスを作成し、StaffクラスをMemberの集合体とします。
インターフェースで定義したIteratorメソッドを実装します。

```java: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);
	}
}
```
```kotlin: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クラス
Iteraltorの実装としてStaffIteratorクラスを作成し、Staffをスキャンできるようにメソッドを実装します。
nextメソッドでは要素の取得と、indexを次に進める実装をしており、For構文でいうi++の役目を持たせます。
また、IteratorインターフェースのnextメソッドハAny?を使用してNullを許容しているのですが、memberオブジェクトをnullで返すのは意図していないのでNon-NullであるAnyを戻り値としました。

```java: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;
	}
}
```
```kotlin: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
    }
}
```

##Mainクラス
上記クラスを実際に動作させるMainクラスです。
ここでのポイントはwhile文にStaffの実装が干渉しない事がメリット。

```java: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());
		}
	}
}
```
```kotlin: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)
    }
}

```

```console:実行結果
sato
suzuki
saito
```

##クラス図
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/326131/e4260a15-9769-7377-bdc9-d53fe43d05cd.png)


##所感
+ while文の処理ではサブクラスの実装に依存しないので、実装したメソッド内で変更があった場合でもwhile文の処理に影響を与えない事を学んだ。
+ kotlinだと、コードの量をかなり抑えられて見やすい
+ Iteratorを継承したサブクラスをInterfaceのインスタンスにオブジェクトをつめれるのが何気に初めて知りました。
+ kotlinだとnullとnullableの扱いがまだまだできていなさそうなので、コメントやご指摘をいただけると助かります。

##問題1-1
Staffクラスの配列をVectorに変更。
実際に実装してみた結果、変更による影響範囲がStaffクラス内に収まることを確認でき、依存性の低さの大切さを学んだ。

~~~java
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());
		}
	}
}
~~~

##参考
下記を参考にさせて頂き、大変読みやすく、理解しやすかったです。

[JavaプログラマのためのKotlin入門](https://qiita.com/koher/items/bcc58c01c6ff2ece658f)

KotlinのAnyについては下記を参考にいたしました。
[JavaプログラマがKotlinでつまづきがちなところ](https://qiita.com/koher/items/d9411a00986f14683a3f)