Effective Java を Kotlin で読む（６）：第7章 メソッド

![effectivekotlin.png](https://qiita-image-store.s3.amazonaws.com/0/191059/5d874c04-211c-ebca-da5e-5d1a4746517d.png)

# 章目次

[Effective Java を Kotlin で読む（１）：第2章 オブジェクトの生成と消滅](https://qiita.com/ref3000/items/7c896b45c54f1086f0a9) 
[Effective Java を Kotlin で読む（２）：第3章 すべてのオブジェクトに共通のメソッド](https://qiita.com/ref3000/items/0dba04cdcb32b7debdb6)
[Effective Java を Kotlin で読む（３）：第4章 クラスとインタフェース](https://qiita.com/ref3000/items/a6eaf0fb8740ac2aebd3)
[Effective Java を Kotlin で読む（４）：第5章 ジェネリックス](https://qiita.com/ref3000/items/4e0c57f67c905a81fa0a)
[Effective Java を Kotlin で読む（５）：第6章 enum とアノテーション](https://qiita.com/ref3000/items/8ea7008007b8eea315dc)
[Effective Java を Kotlin で読む（６）：第7章 メソッド](https://qiita.com/ref3000/items/9a588356dd8a8879d6a6)  👈この記事
[Effective Java を Kotlin で読む（７）：第8章 プログラミング一般](https://qiita.com/ref3000/items/2d458044fc5a4309de06)
Effective Java を Kotlin で読む（８）：第9章 例外
Effective Java を Kotlin で読む（９）：第10章 並行性
Effective Java を Kotlin で読む（１０）：第11章 シリアライズ

# 第7章 メソッド

## 項目38 パラメータの正当性を検査する

### 概要

メソッドやコンストラクタのパラメータは何らかの制約を持っている場合がある（例：null であってはならない等）。その場合、明確に文書化した上で、処理の始めに正当性検査を行うべきである。

もし正当性検査を怠った場合、処理の途中で訳のわからない例外で失敗したり、誤った結果を返したりする。最悪のケースとして、メソッドは正常にリターンするが内部状態を不正にしてしまい、全く関係の無い箇所でエラーを発生させる事もある。

public のメソッド・コンストラクタに関しては、制約が守られていない場合にスローされる例外を Javadoc の `@throw` タグを使用して文書化すべきである。

また、公開されないメソッド・コンストラクタに関してはアサーションを用いることで、開発中のみ検査を行うことができる（`-ea` オプションを有効にしない限り検査を行わない）。

### Kotlin で読む

Kotlin では標準ライブラリに正当性検査用のメソッドが用意されているので、これを使おう。

- [**require**](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/require.html)
    - 引数が false の場合 IllegalArgumentException をスローする
    - メソッドの引数をテストする時に使う
- [**check**](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/check.html)
    - 引数が false の場合 IllegalStateException をスローする
    - オブジェクトの状態をテストする時に使う
- [**assert**](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/assert.html)
    - 引数が false の場合 AssertionError をスローする
    - ただし `-ea` オプションを有効にしない限り検査を行わない

```kotlin
fun hoge(a: String) {
	require(a == "hoge") { "hoge じゃない！" }
}

var state = "invalid"
fun fuga() {
	check(state == "valid") { "状態が異常！" }
}

fun piyo() {
	assert(false) { "テスト時にのみ失敗" }
}
```

[Try Kotlin で確認](https://try.kotlinlang.org/#/UserProjects/mh5r5j9l413hdu0b9ms1abu140/d85n27fem1gdegm4sehorkd16j)

## 項目39 必要な場合には、防御的にコピーする

### 概要

クラスを設計する際は、**利用者は不変式を破壊するために徹底した努力をする**ことを想定し**防御的にプログラムするべき**である。

例えば、不変な期間を表現するクラスを考える。

```java
public final class Period {
	private final Date start, end;

	public Period(Date start, Date end) {
		this.start = start;
		this.end = end;
	}
	public Date start() { return start; }
	public Date end() { return end; }
}
```

このクラスには問題があり、以下のように不変式を破壊する事ができる。

```java
Date start = new Date();
Period period = new Period(start, new Date());

start.setTime(1000); // 不変式破壊！
period.end().setTime(2000); // 不変式破壊！
```

これは以下のように防御的にコピーを行うことで防ぐことができる。

```java
public class FixedPeriod {
	private final Date start, end;

	public FixedPeriod(Date start, Date end) {
		this.start = new Date(start.getTime());
		this.end = new Date(end.getTime());
	}
	public Date start() { return new Date(start.getTime()); }
	public Date end() { return new Date(start.getTime()); }
}
```

また書籍では、この本当の教訓は「可能であれば常に構成要素として不変オブジェクトを使うべき」であるとしている。

### Kotlin で読む

素直に Java の例を Kotlin で書けばこのようになるが…

```kotlin
class FixedPeriod(start: Date, end: Date) {
	var start: Date
		private set
		get() = Date(field.time)
	var end: Date
		private set
		get() = Date(field.time)

	init {
		this.start = Date(start.time)
		this.end = Date(end.time)
	}
}
```

書籍でも述べられているように、構成要素としては不変オブジェクトを使うべきであろう。

```kotlin
data class ImmutablePeriod(val startMs: Long, val endMs: Long)
```

[Try Kotlin で確認](https://try.kotlinlang.org/#/UserProjects/mh5r5j9l413hdu0b9ms1abu140/v8oua0gkf12vmgg77r34algkpl)

data class であれば copy メソッドが使えたりと、Kotlin では Java に比べて不変なオブジェクトの扱いが簡単になっている。
積極的に不変オブジェクトを使っていこう。

## 項目40 メソッドのシグニチャを注意深く設計する

### 概要

この項目は、独立した項目を作るほどではないAPI設計のヒント集である。

- **メソッド名を注意深く選ぶ**
    - 名前は常に標準命名規則（項目56）に従うべきである
    - 疑問があればJavaライブラリを参考にすると良い（ただし一部矛盾はある）
- **便利なメソッドを提供し過ぎたりしないようにする**
    - 個々のメソッドは「自分の役割を果たす」べき
    - メソッドが多いと、クラスの学習・使用・文書化・テスト・保守等を困難にする
- **長いパラメータのリストは避ける**
    - 4個以下を目標にすべき
    - *同じ型のパラメータが何個も続くのは特に有害である*
        - 分かり辛い上に、順序を間違えてもコンパイルできてしまう
- **パラメータ型に関しては、クラスよりインタフェースを選ぶ**
    - 柔軟性が増し、未来の型にも対応できる
    - 例： HashMap よりも Map　を利用する
- **boolean パラメータより２つの要素を持つ enum 型を使用する**
    - 後から３つめの要素が出てきても対応できる
    - 便利なメソッドを追加することもできる

### Kotlin で読む

それぞれの項目について Kotlin 視点で考える。

- **メソッド名を注意深く選ぶ**

"[Kotlin follows the Java naming conventions.](https://kotlinlang.org/docs/reference/coding-conventions.html#naming-rules)"
との事なので Java の標準命名規則に従えば良さそう。

- **便利なメソッドを提供し過ぎたりしないようにする**

Java 同様の意識で良さそう。
また、必要なら拡張関数を使えば利用者側でユーティリティを用意もできる。

- **長いパラメータのリストは避ける**

名前付き引数が使えるため、そこまで神経質にならなくても良いかなとは思う。
が、そもそもパラメータが増えすぎない設計を目指すべきではある。

- **パラメータ型に関しては、クラスよりインタフェースを選ぶ**

Java 同様の意識で良さそう。
また、特にパラメータに不変なものを使うと、項目39のようにTOCTOU攻撃を防げて良さそう。

- **boolean パラメータより２つの要素を持つ enum 型を使用する**

Java 同様の意識で良さそう。

## 項目41 オーバーロードを注意して使用する

### 概要

Java でクラスのメソッド選択は、オーバーロードでは静的に、オーバーライドでは動的に行われる。
以下が具体例である。

```java
public class Overload {
	public static String classify(List<?> obj) {
		return "List";
	}
	public static String classify(Collection<?> obj) {
		return "Collection";
	}
}
```

```java
public class OverrideParent {
	public String getClassName() {
		return "OverrideParent";
	}
}
```

```java
public class OverrideChild extends OverrideParent {
	@Override
	public String getClassName() {
		return "OverrideChild";
	}
}
```

```java
public class Main {
	public static void main(String[] args) {
		Collection<?> list = new ArrayList();
		System.out.println(Overload.classify(list)); // Collection

		OverrideParent child = new OverrideChild();
		System.out.println(child.getClassName()); // OverrideChild
	}
}
```

また、オートボクシングが絡むとどのメソッドが呼ばれるか分かり辛くなる。

```java
List<String> strList = new ArrayList<>();
strList.add("1");
strList.add("2");
strList.remove("1"); // 
System.out.println(strList); // 出力: [2]

List<Integer> intList = new ArrayList<>();
intList.add(1);
intList.add(2);
intList.remove(1);
System.out.println(intList); // 出力: [1]
```

これは、String の例では `List#remove(Object o)` が、 Integer の例では `List#remove(int index)` が呼ばれるためである。（リリース 1.5 までは基本データ型と参照型は根本的に異なっていたため問題にならなかった。）

どのオーバーロードされたメソッドが呼び出されるかは、[Java言語仕様](https://docs.oracle.com/javase/specs/)において33ページも占めるほど複雑である。
故に書籍では、保守的な方針として**同じパラメータ数の２つのオーバーロードされたメソッドを決して提供しないべきである**としている。

これを実現するにあたっては、メソッドに別名を利用したり、コンストラクタでは static ファクトリーメソッドを利用することができる。

### Kotlin で読む

Java と一緒でメソッド選択は、オーバーロードでは静的に、オーバーライドでは動的に行われる。

```kotlin
fun classify(a: Collection<*>): String {
	return "Collection"
}

fun classify(a: List<*>): String {
	return "List"
}

open class OverrideParent {
	open fun getClassName() = "OverrideParent"
}

class OverrideChild : OverrideParent() {
	override fun getClassName() = "OverrideChild"
}

fun main(args: Array<String>) {
	val list: Collection<*> = listOf("dummy")
	println(classify(list)) // Collection

	val child = OverrideChild()
	println(child.getClassName()) // OverrideChild
}
```

[Try Kotlin で確認](https://try.kotlinlang.org/#/UserProjects/mh5r5j9l413hdu0b9ms1abu140/b9362uag3j82b3ipondv5lj6h1)

名前付き引数が使えるため、同じパラメータ数のメソッドでも Java よりは区別は付きやすいが、わかりにくい事には違いないので Java 同様避けるようにした方が良いだろう。

またオートボクシングの例については Kotlin から Java のメソッドを呼ぶ際は Integer として扱われるので、以下の通りより直感的になる。

```kotlin
val strList = ArrayList<String>()
strList.add("1")
strList.add("2")
strList.remove("1")
println(strList) // 出力: [2]

val intList = ArrayList<Int>()
intList.add(1)
intList.add(2)
intList.remove(1)
println(intList) // 出力: [2]

val intList2 = ArrayList<Int>()
intList2.add(1)
intList2.add(2)
intList2.removeAt(1) // Index 指定で削除するメソッドは別名！
println(intList2) // 出力: [1]
```

[Try Kotlin で確認](https://try.kotlinlang.org/#/UserProjects/mh5r5j9l413hdu0b9ms1abu140/ujbci9re22makcdcgt9o2b5glq)

ちなみに以下のように名前付き引数でメソッドが特定できない場合はコンパイルエラーになる。

```kotlin
fun test(a: String, b: Int) = println("a")

fun test(b: Int, a: String) = println("b")

//　このように使う
test("abc", 123) // a
test(123, "abc") // b
test(a = "abc", b = 123) // コンパイルエラー
```

## 項目42 可変長引数を注意して使用する

### 概要

Java にはリリース1.5より**可変引数メソッド**が導入された。
可変長引数を利用する際はいくつかの場合に注意する必要がある。

- **N個以上の引数が必要な場合**

以下のように実行時に検査する実装をしてしまうと、コンパイル時にエラーを検出できない。

```java
// 1個以上の引数が必要なメソッド
void hoge(String... args) {
	if (args.length == 0) throw new IllegalArgumentException("Too few arguments");
	// 以下省略
}
// hoge(); のように呼ぶと実行時に IllegalArgumentException が投げられる
```

この場合、N個の引数に加えて可変長引数を持つメソッドとすべきである。

```java
// 1個以上の引数が必要なメソッド（改）
void hoge2(String a, String... args) {
	// 省略
}
// hoge2(); はコンパイルエラー
```

- **最後のパラメータとして配列を持つメソッドを修正する場合**

リリース1.4では以下のコードはエラーになる。

```java
int[] digits = { 3, 1, 4, 1, 5, 9, 2 };
Arrays.asList(digits);
```

これは `Arrays.asList` が `Object[]` を引数として受け取るよう宣言されていたためである。
が、リリース1.5で `Arrays.asList` は _不幸にも_ 可変長引数を受け取れるよう変更された。

[リリース 1.4（javadoc）](https://docs.oracle.com/javase/jp/1.4/api/java/util/Arrays.html#asList(java.lang.Object[]))
`public static List asList(Object[] a)`
[リリース 1.5（javadoc）](https://docs.oracle.com/javase/jp/1.5.0/api/java/util/Arrays.html#asList(T...))
`public static <T> List<T> asList(T... a)`

この変更により、今ではエラーにならず意図しない結果が得られるようになってしまった。

```java
int[] digits = { 3, 1, 4, 1, 5, 9, 2 };
Arrays.asList(digits); // List<Integer> では無く List<int[]> が返る…
```

このように型検査を失う結果となるため、**最後のパラメータとして配列を持つメソッドをすべて修正してはならない**。

- **パフォーマンスが必要な場合**

可変長引数のメソッド呼び出しには、配列生成と初期化のコストが余分にかかる。
この際、大抵のメソッド呼び出しで引数が３個以下とするならば
「０〜３個までのパラメータを持つメソッド + 可変長引数のメソッド」
を用意するというテクニックが使える。

実際 [EnumSet](https://docs.oracle.com/javase/jp/6/api/java/util/EnumSet.html) ではこの技法を使用している。
※ EnumSet はビットフィールドに対するパフォーマンスを損なわない置き換えを意図しているので、こうするのが適切

### Kotlin で読む

Kotlin の可変長引数は Java と若干記述が異なり [`vararg` 修飾子を利用する](https://kotlinlang.org/docs/reference/functions.html#variable-number-of-arguments-varargs)。

```kotlin
fun printNumbers(vararg numbers: Number) {
	// numbers は Array<out Number> として扱える
	println(numbers.joinToString())
}

// 使用例
printNumbers(1, 2.0, 3f) // 1, 2.0, 3.0
```

Java との違いとして Kotlin では可変長引数に配列をそのまま渡すことはできない。
Kotlin の配列は spread 演算子で引数展開できるため、他の可変長引数を持つメソッドは以下のように呼び出す必要がある。

```kotlin
fun printNumbers2(vararg numbers: Number) {
	println(listOf(*numbers))
}

// 使用例
printNumbers(1, 2.0, 3f) // [1, 2.0, 3.0]
```

[Try Kotlin で確認](https://try.kotlinlang.org/#/UserProjects/mh5r5j9l413hdu0b9ms1abu140/mhvvedv3eotulv5d2qld7b7i1)

そのため、元々配列を受け取るメソッドを、後から可変長引数を受け取るようにAPIを変えずに変更できない。よって `Arrays.asList` のような不幸な変更はそもそも起こりえないと言える。

また Java では可変長引数のメソッドに null を渡す際の挙動で以下のように直感に反する場合がある。

```java
void hoge(String... args) {
	System.out.println(args.length);
}

// 使用例
main.hoge(); // 0
String a = null;
main.hoge(a); // 1
main.hoge(null); // ぬるぽ
```

3番目で `NullPointerException` が発生する理由は `String[]` 型として null を渡しているためである。つまり以下の違い。

```java
main.hoge((String) null); // String... として扱われる -> String[]{null}
main.hoge((String[]) null); // String[] として扱われる -> null
```

Kotlin であれば配列は渡せないのでこの辺も安心！

## 項目43 null ではなく、空配列か空コレクションを返す

### 概要

配列やコレクションを返すメソッドで、要素が存在しなかった時などに null を返すコードを見かける事がある。しかし、空配列か空コレクションの代わりに null を返す理由は決して無い。

null を返さなければ、呼び出し元で null の処理する必要も無い事に加え、予め用意されたサイズ0のコレクションを返すようにすればパフォーマンスでも差は無いためである。

### Kotlin で読む

Kotlin も Java 同様 null を返さないようにすべきである。
標準ライブラリに空コレクションを返すメソッドがそれぞれ用意されている。

```kotlin
val list: List<Int> = emptyList()
val set: Set<String> = emptySet()
val map: Map<String, Int> = emptyMap()
```

ちなみに[引数無しの listOf](https://github.com/JetBrains/kotlin/blob/1.2.60/libraries/stdlib/src/kotlin/collections/Collections.kt#L83) 等はそもそも空コレクションを返す。

```kotlin
public inline fun <T> listOf(): List<T> = emptyList()
```

よって、パフォーマンス的には以下でも問題ない。

```kotlin
val list: List<Int> = listOf()
val set: Set<String> = setOf()
val map: Map<String, Int> = mapOf()
```

また、そもそも Kotlin の場合 nullable はしっかり型で区別されるため、自然とコレクションを null で返そうとは思わないのかもしれない。

ちなみに、この項目で言及されているのは配列やコレクションに関してであり、オブジェクトに関する話ではない。オブジェクトとして null を返したくない場合 [Null オブジェクトパターン(wikipedia)](https://en.wikipedia.org/wiki/Null_object_pattern) もあるが、ここでは扱わない。（個人的にはバグを見逃すデメリットの方が大きいので null としてきちんと扱った方が何かと良さそうに思っている。）

## 項目44 すべての公開 API 要素に対してドキュメントコメントを書く

### 概要

Java では Javadoc 形式のドキュメンテーションコメント（`/** */`）を書くことが一般的であり、これによりソースコードから API ドキュメントを生成できるようになる。

**API を適切に文書化するため、すべての公開されているクラス・インタフェース・コンストラクタ・メソッド・フィールド宣言の前にドキュメンテーションコメントを書かなければならない。**

書籍では細かく例が挙げられているが、ここではいくつかを簡潔に抜粋する。

- **メソッドに関するドキュメントコメント**
事前条件（呼び出し時に成立しているべき条件）、事後条件（呼び出し後に成立しているべき条件）に加えて、いかなる副作用も文書化すべき（例：スレッドを開始する場合）。
また、スレッド安全性（項目70）についても記述すべきである。

- **各ドキュメントコメント最初の１文（概要説明）**
概要説明は、それが要約しようとしている実体の機能を述べるために完結していなければならない。
メソッドやコンストラクタでは、それ自身が行う処理を説明している動詞句であるべきである。
クラス・インタフェース・フィールドに対しては、それ自身によって表される事柄を説明している名詞句であるべきである。

- **ジェネリック型・enum型・アノテーションの文書化**
公開要素はすべて文書化する必要がある。よって
ジェネリック型では __すべての型パラメータを文書化する__ ことを忘れてはならない。
enum型では __すべての定数を文書化する__ ことを忘れてはならない。
アノテーション型では __すべてのメンバーを文書化する__ ことを忘れてはならない。

### Kotlin で読む

JavaDoc に相当するものとして、 Kotlin では KDoc があり、 [Dokka](https://github.com/Kotlin/dokka) というツールを使ってドキュメント化する事ができる。

基本的には JavaDoc と同じように記述できるが、Kotlin 独自の概念などを表現するためにブロックタグが追加されていたり、Markdown が使えるようになったりと細かい改良が加えられている。

詳細は [Dokka の README.md](https://github.com/Kotlin/dokka/blob/master/README.md) を参照。

ドキュメントの内容に関しては Java 同様**すべての公開 API 要素に対してドキュメントコメントを書く**事を意識するようにしたい。

# おわり

- 前： [Effective Java を Kotlin で読む（５）：第6章 enum とアノテーション](https://qiita.com/ref3000/items/8ea7008007b8eea315dc)
- 次： [Effective Java を Kotlin で読む（７）：第8章 プログラミング一般](https://qiita.com/ref3000/items/2d458044fc5a4309de06)

# 参考資料等

- [Kotlin Reference](https://kotlinlang.org/docs/reference/)
- [Kotlin Language Documentation](https://kotlinlang.org/docs/kotlin-docs.pdf)
- Effective Java 第2版
- Kotlin イン・アクション
- [(Blog)10年の長きに渡り Java の可変長引数を過信していた話](http://etc9.hatenablog.com/entry/2017/06/22/222438)
- [(Qiita)KDoc 書き方メモ(Kotlin のドキュメンテーションコメント)](https://qiita.com/opengl-8080/items/fe43adef48e6162e6166)