ジェネリックプログラミング入門

ジェネリックプログラミング入門
Java編
2018/12/7
第2事業部市岡岳彦

© 2018 SG Corporation 2
1. 動機
2. ジェネリックメソッド
3. ジェネリック型
4. ジェネリッククラス
5. 再帰型境界
6. まとめ
目次

◍ Collectionの末尾に指定された要素を追加する。
◍ String
◍ Integer
1. 動機
static void fill(Collection<String> c, String e, int size) {
for (int i = c.size(); i < size; i++) {
c.add(e);
}
}
static void fill(Collection<Integer> c, Integer e, int size) {
c.add(e);
}
}

◍ Objectでやる。
◍ 問題：どんな型でも受け付けてしまう。
1. 動機
static void fill(Collection<Object> c, Object e, int size) {
c.add(e);
}
}

◍ 型をパラメータ化して、呼ぶ方で型を決めればいい。
1. 動機
class MethodSample {
…
static <E> void fill(Collection<E> c, E e, int size) {
c.add(e);
}
}
MethodSample.<String>fill(strList, "banana", 10);
MethodSample.<Integer>fill(intList, 123, 10);

◍ メソッド呼び出し時に、パラメータに実際の値をバインドするのに似ている。
◍ 実行時ではなく、コンパイル時に型パラメータに実際の型をバインドする。
◍ 型を特定しない汎用的なアルゴリズムと静的型付けの安全性を両立。
1. 動機

◍ 型のパラメータ化
◍ メソッド定義時
◍ 実際の型のバインド
◍ メソッド呼び出し時
◍ 型推論
2. ジェネリックメソッド
static <E> void fill(Collection<E> c, E e, int size) {
…
}
MethodSample.<String>fill(strList, "banana", 10);
List<String> strList = new ArrayList<>();
MethodSample.fill(strList, "banana", 10);

◍ ジェネリック型変数の継承関係について
◍ スーパータイプの変数にはサブタイプの変数を代入可能
◍ 配列でも同じ
Object obj = …
String str = …
obj = str;
Object[] objArray = …
String[] strArray = …
objArray = strArray;

◍ List<String>はList<Object>のサブタイプではない。
◍ 代入不可能
◍ もし、代入可能だとしたら…
List<Object> objList = …
List<String> strList = …
objList = strList; // コンパイルエラー!
objList = strList;
objList.add(123);
// objListの実体はList<String>
// List<String>にIntegerを入れられてしまう。

◍ 動機
◍ ジェネリック型変数で継承関係を表現したい。
◍ 境界ワイルドカード型を使う。

◍ 境界ワイルドカード型
◍ 下限ワイルドカード：IN方向のみ可能
◍ 上限ワイルドカード：OUT方向のみ可能
List<? super String> superStrList = strList;
superStrList.add("orange");
String str = superStrList.get(0); // コンパイルエラー!
List<? extends String> subStrList = strList;
String str = subStrList.get(0);
subStrList.add("grape"); // コンパイルエラー!

◍ 下限ワイルドカード：IN方向のみ可能
◍ Stringのスーパータイプであれば、許容するList。
◍ IN方向はStringのスーパータイプであれば、適用可能。
◍ OUT方向はStringである保証ができないため、コンパイルエラーとなる。
List<? super String> superStrList = strList;
superStrList.add("orange");
String str = superStrList.get(0); // コンパイルエラー!

◍ 下限ワイルドカード境界型パラメータの例
static <E> void fill(Collection<? super E> c, E e, int size) {
c.add(e);
}
}
…
List<Object> l = new ArrayList<>();
fill(l, "banana", 10);

◍ 上限ワイルドカード：OUT方向のみ可能
◍ Stringのサブタイプであれば、許容するList。
◍ OUT方向はStringのサブタイプであれば、適用可能。
◍ IN方向は任意のサブタイプである保証ができないため、コンパイルエラーとな
る。
List<? extends String> subStrList = strList;
String str = subStrList.get(0);
subStrList.add("grape"); // コンパイルエラー!

◍ 上限ワイルドカード境界型パラメータの例
◍ Collectionを連結する。
static <E> void concat(Collection<? super E> dst,
Collection<? extends E> src) {
for (E e : src) {
dst.add(e);
}
}
…
List<Number> ln = …
List<Integer> li = …
concat(ln, li);

◍ 上限ワイルドカード境界型パラメータの例
◍ Listを逆転する。
◍ 戻り値を境界ワイルドカードにすると、メソッド使用者の負担になる。
static <E> List<? super E> reverse(List<? extends E> l) {
List<E> rev = new ArrayList<>(l.size());
for (int i = l.size() - 1; i >= 0; i--) {
rev.add(l.get(i));
}
return rev;
}
List<? super String> s = reverse(l);
List<Object> o = reverse(l); // コンパイルエラー!

◍ 動機
◍ ジェネリック型のスーパータイプが欲しい
◍ 非境界ワイルドカード型を使う。

◍ 非境界ワイルドカード型の例
◍ <Object>とも違い、何型でもないので、null以外代入できない。
◍ 取得側は必ずObjectに代入する。
◍ 型安全性は保証される。
List<?> unknownList = strList;
Object obj = unknownList.get(0);
unknownList.add(null);
unknownList.add("apple"); // コンパイルエラー!

◍ 非境界ワイルドカード型は何に使うのか。
◍ Listをローテーションする。
static void rotate(List<?> l, int size) {
rotateHelper(l, size);
}
private static <E> void rotateHelper(List<E> l, int size) {
size %= l.size();
for (int i = 0; i < size; i++) {
l.add(l.get(0));
l.remove(0);
}
}

◍ 非境界ワイルドカード型は何に使うのか。
の方が
よりも
APIを使う側にとって、より簡潔。
…と、Effective Javaに書いてあったが、よくわからない。そうなのか？
static void rotate(List<?> l, int size)
static <E> void rotate(List<E> l, int size)

◍ 当たり前のようにCollection<E>とか使ってたけど。
◍ ところで、ジェネリック型のクラスをどのように作るのか？

◍ 範囲を表すクラスを考えてみる。
◍ 開始と終了をフィールドとして持つ。
◍ 開始と終了は同じ型。
◍ 開始と終了はComparableのサブタイプであれば、なんでもいい。

◍ 範囲を表すクラスを考えてみる。
class Range<E extends Comparable<E>> {
private E begin;
private E end;
Range(E begin, E end) {
this.begin = begin;
this.end = end;
}
…
}

◍ 型のパラメータ化
◍ クラス定義時
◍ 実際の型のバインド
◍ 変数宣言時
◍ 継承時
…
}
Range<Integer> range = new Range<>(1, 10);
class LongRange extends Range<Long> {
LongRange(Long begin, Long end) {
super(begin, end);
…

◍ 型パラメータの範囲を限定する。
◍ Comparableのサブタイプのみバインド可能
…
Range<Number> numberRange = …
// コンパイルエラー!

◍ 範囲といえば、日付型。
◍ java.time.LocalDateはComparable<LocalDate>型ではなく、
Comparable<ChronoLocalDate>型。
Range<LocalDate> dateRange = new Range<>(LocalDate.of(2018, 1, 1),
LocalDate.of(2018, 3, 31));
// コンパイルエラー!
ChronoLocalDate implements Comparable<ChronoLocalDate>
LocalDate implements ChronoLocalDate

◍ Comparableにバインドする型を下限境界にする。
class Range<E extends Comparable<? super E>> {
private E begin;
private E end;
Range(E begin, E end) {
this.begin = begin;
this.end = end;
}
…
}
Range<LocalDate> dateRange = new Range<>(LocalDate.of(2018, 1, 1),
LocalDate.of(2018, 3, 31));
// OK!

◍ 継承時の型バインドは多段継承と相性が悪い。

◍ java.lang.Enum<E>
◍ これは何か。
◍ 型パラメータが宣言しているタイプのサブタイプであることを強制する。
→Enum<Foo>のFooは必ずEnumのサブタイプである。
◍ スーパークラスの型ではなく、個々の型で変数宣言することを前提とする。
◍ 一般的にインターフェース、抽象クラスで使う。
5. 再帰型境界
Enum<E extends Enum<E>>
Enum<Foo> foo = … // という使い方はしない。
Foo foo = … // として使う。

◍ 動機
◍ ジェネリッククラスのメソッドの引数の型を特定の型に限定したい。
◍ 範囲型再登場
◍ 範囲が重複しているかをチェックするメソッドを追加。
5. 再帰型境界
abstract class Range<E extends Comparable<? super E>> {
protected E begin;
protected E end;
boolean overlap(Range<E> t) {
return begin.compareTo(t.end) <= 0 &&
t.begin.compareTo(end) <= 0;
}
…

◍ 範囲が重複しているか。
◍ 比較相手はRange<E>のサブタイプではあるが、自分と同じ型とは限らない。
5. 再帰型境界
abstract class Range<E extends Comparable<? super E>> {
protected E begin;
protected E end;
boolean overlap(Range<E> t) {
}
…
class LongRange extends Range<Long>
class AnotherLongRange extends Range<Long>

5. 再帰型境界
abstract class Range<E extends Comparable<? super E>,
T extends Range<E,T>> {
protected E begin;
protected E end;
boolean overlap(T t) {
}
…
class LongRange extends Range<Long, LongRange>
class AnotherLongRange extends Range<Long, AnotherLongRange>

◍ 具体的な型をサブタイプ実装時まで保留できる。
◍ 比較する相手が自分と同じ型であることを保証する。
5. 再帰型境界
abstract class Range<E extends Comparable<? super E>,
T extends Range<E,T>> {
protected E begin;
protected E end;
boolean overlap(T t) {
}
…

◍ 型のパラメータ化とバインドのタイミングを理解しよう。
◍ 境界ワイルドカード型で役割を表現しよう。
◍ 戻り値は境界ワイルドカードにしない。
◍ 非境界ワイルドカード型のメソッドはヘルパーメソッドを作ろう。
◍ 継承時の型バインドは多段継承と相性が悪い。
◍ 型パラメータがサブタイプであって欲しい時は再起型境界を使おう。
6. まとめ

◍ Effective Java 第2版
 Joshua Bloch 著
 柴田芳樹訳
 丸善出版
参考文献

◍ https://blog.sgnet.co.jp
◍ https://www.slideshare.net/t_ichioka_sg/
こちらもどうぞ

顧客と社員に信頼されるエス・ジー

ジェネリックプログラミング入門

Recommended

Recommended

More Related Content

Featured

Featured (20)

ジェネリックプログラミング入門