Javaジェネリックス-クイックガイド
整数配列、文字列配列、または順序付けをサポートする任意の型の配列の要素を並べ替えることができる単一の並べ替えメソッドを作成できれば便利です。
Javaジェネリックメソッドとジェネリッククラスを使用すると、プログラマは、単一のメソッド宣言で関連するメソッドのセットを指定するか、単一のクラス宣言で関連するタイプのセットをそれぞれ指定できます。
ジェネリックスは、プログラマーがコンパイル時に無効な型をキャッチできるようにするコンパイル時の型安全性も提供します。
Java Genericの概念を使用して、オブジェクトの配列を並べ替えるための汎用メソッドを記述し、次に整数配列、二重配列、文字列配列などを使用して汎用メソッドを呼び出し、配列要素を並べ替えることができます。
ローカル環境のセットアップ
JUnitはJavaのフレームワークであるため、最初の要件はJDKをマシンにインストールすることです。
システム要件
| JDK | 1.5以上。 |
|---|---|
| 記憶 | 最小要件はありません。 |
| ディスクスペース | 最小要件はありません。 |
| オペレーティング・システム | 最小要件はありません。 |
ステップ1：マシンへのJavaのインストールを確認する
まず、コンソールを開き、作業しているオペレーティングシステムに基づいてJavaコマンドを実行します。
| OS | 仕事 | コマンド |
|---|---|---|
| ウィンドウズ | コマンドコンソールを開く | c：\> java -version |
| Linux | コマンドターミナルを開く | $ java -version |
| マック | オープンターミナル | マシン：<joseph $ java -version |
すべてのオペレーティングシステムの出力を確認しましょう-
| OS | 出力 |
|---|---|
| ウィンドウズ | Javaバージョン "1.6.0_21" Java（TM）SEランタイム環境（ビルド1.6.0_21-b07） Java HotSpot（TM）クライアントVM（ビルド17.0-b17、混合モード、共有） |
| Linux | Javaバージョン "1.6.0_21" Java（TM）SEランタイム環境（ビルド1.6.0_21-b07） Java HotSpot（TM）クライアントVM（ビルド17.0-b17、混合モード、共有） |
| マック | Javaバージョン "1.6.0_21" Java（TM）SEランタイム環境（ビルド1.6.0_21-b07） Java HotSpot（TM）64ビットサーバーVM（ビルド17.0-b17、混合モード、共有） |
システムにJavaがインストールされていない場合は、次のリンクからJavaソフトウェア開発キット（SDK）をダウンロードしてください。 https://www.oracle.com。このチュートリアルのインストールバージョンとして、Java1.6.0_21を想定しています。
ステップ2：JAVA環境を設定する
をセットする JAVA_HOMEJavaがマシンにインストールされているベースディレクトリの場所を指す環境変数。例えば。
| OS | 出力 |
|---|---|
| ウィンドウズ | 環境変数JAVA_HOMEをC：\ Program Files \ Java \ jdk1.6.0_21に設定します |
| Linux | export JAVA_HOME = / usr / local / java-current |
| マック | export JAVA_HOME = / Library / Java / Home |
Javaコンパイラの場所をシステムパスに追加します。
| OS | 出力 |
|---|---|
| ウィンドウズ | 文字列を追加します C:\Program Files\Java\jdk1.6.0_21\bin システム変数の最後に、 Path。 |
| Linux | エクスポートパス= $PATH:$JAVA_HOME / bin / |
| マック | 必要ありません |
コマンドを使用してJavaのインストールを確認します java -version 上で説明したように。
ジェネリッククラス宣言は、クラス名の後に型パラメーターセクションが続くことを除いて、非ジェネリッククラス宣言のように見えます。
ジェネリッククラスの型パラメーターセクションには、コンマで区切った1つ以上の型パラメーターを含めることができます。これらのクラスは、1つ以上のパラメーターを受け入れるため、パラメーター化クラスまたはパラメーター化タイプと呼ばれます。
構文
public class Box<T> {
private T t;
}どこ
Box −ボックスはジェネリッククラスです。
T−ジェネリッククラスに渡されるジェネリック型パラメーター。任意のオブジェクトを取ることができます。
t −ジェネリック型Tのインスタンス。
説明
Tは、汎用クラスBoxに渡される型パラメーターであり、Boxオブジェクトの作成時に渡される必要があります。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
GenericsTester.java
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}これにより、次の結果が得られます。
出力
Integer Value :10
String Value :Hello World慣例により、型パラメーター名は単一の大文字で命名されるため、型パラメーターは通常のクラス名またはインターフェース名で簡単に区別できます。以下は、一般的に使用されるタイプパラメータ名のリストです-
E −要素であり、主にJavaコレクションフレームワークによって使用されます。
K −キー。主に、マップのキーのパラメータタイプを表すために使用されます。
V −値。主に、マップの値のパラメータタイプを表すために使用されます。
N −数値であり、主に数値を表すために使用されます。
T −型。主に、最初のジェネリック型パラメーターを表すために使用されます。
S −型。主に、2番目のジェネリック型パラメーターを表すために使用されます。
U −型。主に、3番目のジェネリック型パラメーターを表すために使用されます。
V −型。主に、4番目のジェネリック型パラメーターを表すために使用されます。
次の例では、上記の概念を紹介します。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
GenericsTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer, String> box = new Box<Integer, String>();
box.add(Integer.valueOf(10),"Hello World");
System.out.printf("Integer Value :%d\n", box.getFirst());
System.out.printf("String Value :%s\n", box.getSecond());
Pair<String, Integer> pair = new Pair<String, Integer>();
pair.addKeyValue("1", Integer.valueOf(10));
System.out.printf("(Pair)Integer Value :%d\n", pair.getValue("1"));
CustomList<Box> list = new CustomList<Box>();
list.addItem(box);
System.out.printf("(CustomList)Integer Value :%d\n", list.getItem(0).getFirst());
}
}
class Box<T, S> {
private T t;
private S s;
public void add(T t, S s) {
this.t = t;
this.s = s;
}
public T getFirst() {
return t;
}
public S getSecond() {
return s;
}
}
class Pair<K,V>{
private Map<K,V> map = new HashMap<K,V>();
public void addKeyValue(K key, V value) {
map.put(key, value);
}
public V getValue(K key) {
return map.get(key);
}
}
class CustomList<E>{
private List<E> list = new ArrayList<E>();
public void addItem(E value) {
list.add(value);
}
public E getItem(int index) {
return list.get(index);
}
}これにより、次の結果が得られます。
出力
Integer Value :10
String Value :Hello World
(Pair)Integer Value :10
(CustomList)Integer Value :10型推論は、メソッド呼び出しとそれに対応する宣言を調べて型引数をチェックおよび決定するJavaコンパイラーの機能を表します。推論アルゴリズムは引数の型をチェックし、利用可能な場合は、割り当てられた型が返されます。推論アルゴリズムは、すべての型パラメーターを満たすことができる特定の型を見つけようとします。
型推論が使用されない場合、コンパイラはチェックされていない変換警告を生成します。
構文
Box<Integer> integerBox = new Box<>();どこ
Box −ボックスはジェネリッククラスです。
<> −ダイヤモンド演算子は、型推論を示します。
説明
コンパイラーは、diamond演算子を使用して、パラメーターのタイプを判別します。この演算子は、Java SE7バージョン以降で使用できます。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
GenericsTester.java
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
//type inference
Box<Integer> integerBox = new Box<>();
//unchecked conversion warning
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}これにより、次の結果が得られます。
出力
Integer Value :10
String Value :Hello Worldさまざまなタイプの引数を使用して呼び出すことができる単一のジェネリックメソッド宣言を記述できます。ジェネリックメソッドに渡される引数のタイプに基づいて、コンパイラは各メソッド呼び出しを適切に処理します。一般的なメソッドを定義するためのルールは次のとおりです-
すべてのジェネリックメソッド宣言には、メソッドの戻り値の型（次の例では<E>）の前に山括弧（<および>）で区切られた型パラメーターセクションがあります。
各型パラメーターセクションには、コンマで区切られた1つ以上の型パラメーターが含まれます。型変数とも呼ばれる型パラメーターは、ジェネリック型名を指定する識別子です。
型パラメーターを使用して、戻り値の型を宣言し、実際の型引数と呼ばれる、汎用メソッドに渡される引数の型のプレースホルダーとして機能できます。
ジェネリックメソッドの本体は、他のメソッドと同じように宣言されます。型パラメーターは、プリミティブ型（int、double、charなど）ではなく、参照型のみを表すことができることに注意してください。
例
次の例は、単一のジェネリックメソッドを使用して異なるタイプの配列を出力する方法を示しています。
public class GenericMethodTest {
// generic method printArray
public static < E > void printArray( E[] inputArray ) {
// Display array elements
for(E element : inputArray) {
System.out.printf("%s ", element);
}
System.out.println();
}
public static void main(String args[]) {
// Create arrays of Integer, Double and Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println("Array integerArray contains:");
printArray(intArray); // pass an Integer array
System.out.println("\nArray doubleArray contains:");
printArray(doubleArray); // pass a Double array
System.out.println("\nArray characterArray contains:");
printArray(charArray); // pass a Character array
}
}これにより、次の結果が生成されます-
出力
Array integerArray contains:
1 2 3 4 5
Array doubleArray contains:
1.1 2.2 3.3 4.4
Array characterArray contains:
H E L L Oジェネリッククラスは、複数のタイプのパラメーターを持つことができます。次の例では、上記の概念を紹介します。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
GenericsTester.java
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer, String> box = new Box<Integer, String>();
box.add(Integer.valueOf(10),"Hello World");
System.out.printf("Integer Value :%d\n", box.getFirst());
System.out.printf("String Value :%s\n", box.getSecond());
Box<String, String> box1 = new Box<String, String>();
box1.add("Message","Hello World");
System.out.printf("String Value :%s\n", box1.getFirst());
System.out.printf("String Value :%s\n", box1.getSecond());
}
}
class Box<T, S> {
private T t;
private S s;
public void add(T t, S s) {
this.t = t;
this.s = s;
}
public T getFirst() {
return t;
}
public S getSecond() {
return s;
}
}これにより、次の結果が得られます。
出力
Integer Value :10
String Value :Hello World
String Value :Message
String Value :Hello Worldジェネリッククラスは、型パラメーターをパラメーター化された型に置き換えることができるパラメーター化された型を持つことができます。次の例では、上記の概念を紹介します。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
GenericsTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer, List<String>> box
= new Box<Integer, List<String>>();
List<String> messages = new ArrayList<String>();
messages.add("Hi");
messages.add("Hello");
messages.add("Bye");
box.add(Integer.valueOf(10),messages);
System.out.printf("Integer Value :%d\n", box.getFirst());
System.out.printf("String Value :%s\n", box.getSecond());
}
}
class Box<T, S> {
private T t;
private S s;
public void add(T t, S s) {
this.t = t;
this.s = s;
}
public T getFirst() {
return t;
}
public S getSecond() {
return s;
}
}これにより、次の結果が得られます。
出力
Integer Value :10
String Value :[Hi, Hello, Bye]生の型は、その型引数が作成中に渡されない場合、ジェネリッククラスまたはインターフェイスのオブジェクトです。次の例では、上記の概念を紹介します。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
GenericsTester.java
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> box = new Box<Integer>();
box.set(Integer.valueOf(10));
System.out.printf("Integer Value :%d\n", box.getData());
Box rawBox = new Box();
//No warning
rawBox = box;
System.out.printf("Integer Value :%d\n", rawBox.getData());
//Warning for unchecked invocation to set(T)
rawBox.set(Integer.valueOf(10));
System.out.printf("Integer Value :%d\n", rawBox.getData());
//Warning for unchecked conversion
box = rawBox;
System.out.printf("Integer Value :%d\n", box.getData());
}
}
class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T getData() {
return t;
}
}これにより、次の結果が得られます。
出力
Integer Value :10
Integer Value :10
Integer Value :10
Integer Value :10タイプパラメータに渡すことができるタイプの種類を制限したい場合があります。たとえば、数値を操作するメソッドは、数値またはそのサブクラスのインスタンスのみを受け入れたい場合があります。これが、有界型パラメーターの目的です。
有界型パラメーターを宣言するには、型パラメーターの名前、extendsキーワード、およびその上限をリストします。
例
次の例は、extendsが一般的な意味でどのように使用されているかを示しています。この例は、3つの比較可能なオブジェクトの最大のものを返すジェネリックメソッドです-
public class MaximumTest {
// determines the largest of three Comparable objects
public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
T max = x; // assume x is initially the largest
if(y.compareTo(max) > 0) {
max = y; // y is the largest so far
}
if(z.compareTo(max) > 0) {
max = z; // z is the largest now
}
return max; // returns the largest object
}
public static void main(String args[]) {
System.out.printf("Max of %d, %d and %d is %d\n\n",
3, 4, 5, maximum( 3, 4, 5 ));
System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));
System.out.printf("Max of %s, %s and %s is %s\n","pear",
"apple", "orange", maximum("pear", "apple", "orange"));
}
}これにより、次の結果が生成されます-
出力
Max of 3, 4 and 5 is 5
Max of 6.6,8.8 and 7.7 is 8.8
Max of pear, apple and orange is pearタイプパラメータは複数の境界を持つことができます。
構文
public static <T extends Number & Comparable<T>> T maximum(T x, T y, T z)どこ
maximum −最大値は一般的な方法です。
T−ジェネリックメソッドに渡されるジェネリック型パラメーター。任意のオブジェクトを取ることができます。
説明
Tは、汎用クラスBoxに渡される型パラメーターであり、Numberクラスのサブタイプである必要があり、Comparableインターフェイスを実装する必要があります。クラスがバインドされた状態で渡される場合は、インターフェイスの前に最初に渡される必要があります。そうしないと、コンパイル時エラーが発生します。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
System.out.printf("Max of %d, %d and %d is %d\n\n",
3, 4, 5, maximum( 3, 4, 5 ));
System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));
}
public static <T extends Number
& Comparable<T>> T maximum(T x, T y, T z) {
T max = x;
if(y.compareTo(max) > 0) {
max = y;
}
if(z.compareTo(max) > 0) {
max = z;
}
return max;
}
// Compiler throws error in case of below declaration
/* public static <T extends Comparable<T>
& Number> T maximum1(T x, T y, T z) {
T max = x;
if(y.compareTo(max) > 0) {
max = y;
}
if(z.compareTo(max) > 0) {
max = z;
}
return max;
}*/
}これにより、次の結果が生成されます-
出力
Max of 3, 4 and 5 is 5
Max of 6.6,8.8 and 7.7 is 8.8Javaは、リストインターフェイスで一般的なサポートを提供しています。
構文
List<T> list = new ArrayList<T>();どこ
list −リストインターフェイスのオブジェクト。
T −リスト宣言中に渡されるジェネリック型パラメーター。
説明
Tは、汎用インターフェイスListとその実装クラスArrayListに渡される型パラメーターです。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericsTester {
public static void main(String[] args) {
List<Integer> integerList = new ArrayList<Integer>();
integerList.add(Integer.valueOf(10));
integerList.add(Integer.valueOf(11));
List<String> stringList = new ArrayList<String>();
stringList.add("Hello World");
stringList.add("Hi World");
System.out.printf("Integer Value :%d\n", integerList.get(0));
System.out.printf("String Value :%s\n", stringList.get(0));
for(Integer data: integerList) {
System.out.printf("Integer Value :%d\n", data);
}
Iterator<String> stringIterator = stringList.iterator();
while(stringIterator.hasNext()) {
System.out.printf("String Value :%s\n", stringIterator.next());
}
}
}これにより、次の結果が生成されます-
出力
Integer Value :10
String Value :Hello World
Integer Value :10
Integer Value :11
String Value :Hello World
String Value :Hi WorldJavaは、Setインターフェースで一般的なサポートを提供しています。
構文
Set<T> set = new HashSet<T>();どこ
set − SetInterfaceのオブジェクト。
T −セット宣言中に渡されるジェネリック型パラメーター。
説明
Tは、汎用インターフェイスSetとその実装クラスHashSetに渡される型パラメーターです。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
package com.tutorialspoint;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class GenericsTester {
public static void main(String[] args) {
Set<Integer> integerSet = new HashSet<Integer>();
integerSet.add(Integer.valueOf(10));
integerSet.add(Integer.valueOf(11));
Set<String> stringSet = new HashSet<String>();
stringSet.add("Hello World");
stringSet.add("Hi World");
for(Integer data: integerSet) {
System.out.printf("Integer Value :%d\n", data);
}
Iterator<String> stringIterator = stringSet.iterator();
while(stringIterator.hasNext()) {
System.out.printf("String Value :%s\n", stringIterator.next());
}
}
}これにより、次の結果が生成されます-
出力
Integer Value :10
Integer Value :11
String Value :Hello World
String Value :Hi WorldJavaは、マップインターフェイスで一般的なサポートを提供しています。
構文
Set<T> set = new HashSet<T>();どこ
set − SetInterfaceのオブジェクト。
T −セット宣言中に渡されるジェネリック型パラメーター。
説明
Tは、汎用インターフェイスSetとその実装クラスHashSetに渡される型パラメーターです。
例
任意のエディタを使用して、次のJavaプログラムを作成します。
package com.tutorialspoint;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class GenericsTester {
public static void main(String[] args) {
Map<Integer,Integer> integerMap
= new HashMap<Integer,Integer>();
integerMap.put(1, 10);
integerMap.put(2, 11);
Map<String,String> stringMap = new HashMap<String,String>();
stringMap.put("1", "Hello World");
stringMap.put("2","Hi World");
System.out.printf("Integer Value :%d\n", integerMap.get(1));
System.out.printf("String Value :%s\n", stringMap.get("1"));
// iterate keys.
Iterator<Integer> integerIterator = integerMap.keySet().iterator();
while(integerIterator.hasNext()) {
System.out.printf("Integer Value :%d\n", integerIterator.next());
}
// iterate values.
Iterator<String> stringIterator = stringMap.values().iterator();
while(stringIterator.hasNext()) {
System.out.printf("String Value :%s\n", stringIterator.next());
}
}
}これにより、次の結果が生成されます-
出力
Integer Value :10
String Value :Hello World
Integer Value :1
Integer Value :2
String Value :Hello World
String Value :Hi World疑問符（？）はワイルドカードを表し、ジェネリックスの不明なタイプを表します。タイプパラメータに渡すことができるタイプの種類を制限したい場合があります。たとえば、数値を操作するメソッドは、数値またはそのサブクラスのインスタンスのみを受け入れたい場合があります。
上限のワイルドカードパラメータを宣言するには、？、extendsキーワード、上限の順にリストします。
例
次の例は、extendsを使用して上限ワイルドカードを指定する方法を示しています。
package com.tutorialspoint;
import java.util.Arrays;
import java.util.List;
public class GenericsTester {
public static double sum(List<? extends Number> numberlist) {
double sum = 0.0;
for (Number n : numberlist) sum += n.doubleValue();
return sum;
}
public static void main(String args[]) {
List<Integer> integerList = Arrays.asList(1, 2, 3);
System.out.println("sum = " + sum(integerList));
List<Double> doubleList = Arrays.asList(1.2, 2.3, 3.5);
System.out.println("sum = " + sum(doubleList));
}
}これにより、次の結果が生成されます-
出力
sum = 6.0
sum = 7.0疑問符（？）はワイルドカードを表し、ジェネリックスの不明なタイプを表します。Objectクラスで提供される機能を使用してメソッドを実装できる場合、またはコードがtypeパラメーターに依存しない場合は、任意のオブジェクトを使用できる場合があります。
Unbounded Wildcardパラメーターを宣言するには、？をリストします。のみ。
例
次の例は、extendsを使用して無制限のワイルドカードを指定する方法を示しています。
package com.tutorialspoint;
import java.util.Arrays;
import java.util.List;
public class GenericsTester {
public static void printAll(List<?> list) {
for (Object item : list)
System.out.println(item + " ");
}
public static void main(String args[]) {
List<Integer> integerList = Arrays.asList(1, 2, 3);
printAll(integerList);
List<Double> doubleList = Arrays.asList(1.2, 2.3, 3.5);
printAll(doubleList);
}
}これにより、次の結果が生成されます-
出力
1
2
3
1.2
2.3
3.5疑問符（？）はワイルドカードを表し、ジェネリックスの不明なタイプを表します。タイプパラメータに渡すことができるタイプの種類を制限したい場合があります。たとえば、数値を操作するメソッドは、整数のインスタンスまたは数値などのスーパークラスのみを受け入れたい場合があります。
下限のワイルドカードパラメータを宣言するには、？、superキーワード、下限の順にリストします。
例
次の例は、superを使用して下限ワイルドカードを指定する方法を示しています。
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
public class GenericsTester {
public static void addCat(List<? super Cat> catList) {
catList.add(new RedCat());
System.out.println("Cat Added");
}
public static void main(String[] args) {
List<Animal> animalList= new ArrayList<Animal>();
List<Cat> catList= new ArrayList<Cat>();
List<RedCat> redCatList= new ArrayList<RedCat>();
List<Dog> dogList= new ArrayList<Dog>();
//add list of super class Animal of Cat class
addCat(animalList);
//add list of Cat class
addCat(catList);
//compile time error
//can not add list of subclass RedCat of Cat class
//addCat(redCatList);
//compile time error
//can not add list of subclass Dog of Superclass Animal of Cat class
//addCat.addMethod(dogList);
}
}
class Animal {}
class Cat extends Animal {}
class RedCat extends Cat {}
class Dog extends Animal {}これにより、次の結果が生成されます-
Cat Added
Cat Addedワイルドカードは3つの方法で使用できます-
Upper bound Wildcard−？Typeを拡張します。
Lower bound Wildcard−？スーパータイプ。
Unbounded Wildcard −？
どのタイプのワイルドカードが条件に最も適しているかを判断するために、最初にメソッドに渡されるパラメーターのタイプを次のように分類しましょう。 in そして out パラメータ。
in variable− in変数は、コードにデータを提供します。たとえば、copy（src、dest）です。ここで、srcは、コピーされるデータである変数のように機能します。
out variable− out変数は、コードによって更新されたデータを保持します。たとえば、copy（src、dest）です。ここで、destは、データをコピーした変数のように機能します。
ワイルドカードのガイドライン。
Upper bound wildcard −変数が in カテゴリでは、ワイルドカードを使用してextendsキーワードを使用します。
Lower bound wildcard −変数が out カテゴリ、ワイルドカードでスーパーキーワードを使用します。
Unbounded wildcard − Objectクラスのメソッドを使用して変数にアクセスできる場合は、バインドされていないワイルドカードを使用します。
No wildcard −コードが両方の変数にアクセスしている場合 in そして out カテゴリはワイルドカードを使用しません。
例
次の例は、上記の概念を示しています。
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
public class GenericsTester {
//Upper bound wildcard
//in category
public static void deleteCat(List<? extends Cat> catList, Cat cat) {
catList.remove(cat);
System.out.println("Cat Removed");
}
//Lower bound wildcard
//out category
public static void addCat(List<? super RedCat> catList) {
catList.add(new RedCat("Red Cat"));
System.out.println("Cat Added");
}
//Unbounded wildcard
//Using Object method toString()
public static void printAll(List<?> list) {
for (Object item : list)
System.out.println(item + " ");
}
public static void main(String[] args) {
List<Animal> animalList= new ArrayList<Animal>();
List<RedCat> redCatList= new ArrayList<RedCat>();
//add list of super class Animal of Cat class
addCat(animalList);
//add list of Cat class
addCat(redCatList);
addCat(redCatList);
//print all animals
printAll(animalList);
printAll(redCatList);
Cat cat = redCatList.get(0);
//delete cat
deleteCat(redCatList, cat);
printAll(redCatList);
}
}
class Animal {
String name;
Animal(String name) {
this.name = name;
}
public String toString() {
return name;
}
}
class Cat extends Animal {
Cat(String name) {
super(name);
}
}
class RedCat extends Cat {
RedCat(String name) {
super(name);
}
}
class Dog extends Animal {
Dog(String name) {
super(name);
}
}これにより、次の結果が生成されます-
Cat Added
Cat Added
Cat Added
Red Cat
Red Cat
Red Cat
Cat Removed
Red Catジェネリックは、コンパイル時の厳密な型チェックとジェネリックプログラミングの提供に使用されます。一般的な動作を実装するために、Javaコンパイラは型消去を適用します。型消去は、コンパイラーがジェネリックパラメーターを実際のクラスまたはブリッジメソッドに置き換えるプロセスです。型消去では、コンパイラーは余分なクラスが作成されないこと、および実行時のオーバーヘッドがないことを保証します。
型消去ルール
有界型パラメーターが使用されている場合は、ジェネリック型の型パラメーターをそれらの有界型に置き換えます。
無制限の型パラメーターが使用されている場合は、ジェネリック型の型パラメーターをObjectに置き換えます。
型の安全性を維持するために型キャストを挿入します。
拡張ジェネリック型でポリモーフィズムを維持するためのブリッジメソッドを生成します。
バインドされたタイプパラメータが使用されている場合、Javaコンパイラはジェネリックタイプのタイプパラメータをバインドされたタイプに置き換えます。
例
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<Double> doubleBox = new Box<Double>();
integerBox.add(new Integer(10));
doubleBox.add(new Double(10.0));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("Double Value :%s\n", doubleBox.get());
}
}
class Box<T extends Number> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}この場合、JavaコンパイラはTをNumberクラスに置き換え、型消去後、コンパイラは次のコードのバイトコードを生成します。
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box integerBox = new Box();
Box doubleBox = new Box();
integerBox.add(new Integer(10));
doubleBox.add(new Double(10.0));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("Double Value :%s\n", doubleBox.get());
}
}
class Box {
private Number t;
public void add(Number t) {
this.t = t;
}
public Number get() {
return t;
}
}どちらの場合も、結果は同じです-
出力
Integer Value :10
Double Value :10.0無制限の型パラメーターが使用されている場合、Javaコンパイラーはジェネリック型の型パラメーターをObjectに置き換えます。
例
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}この場合、JavaコンパイラはTをObjectクラスに置き換え、型消去後、コンパイラは次のコードのバイトコードを生成します。
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box integerBox = new Box();
Box stringBox = new Box();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
class Box {
private Object t;
public void add(Object t) {
this.t = t;
}
public Object get() {
return t;
}
}どちらの場合も、結果は同じです-
出力
Integer Value :10
String Value :Hello WorldJavaコンパイラは、ジェネリック型の型パラメータを、制限のない型パラメータが使用されている場合はObjectに、バインドされたパラメータがメソッドパラメータとして使用されている場合はtypeに置き換えます。
例
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
printBox(integerBox);
printBox1(stringBox);
}
private static <T extends Box> void printBox(T box) {
System.out.println("Integer Value :" + box.get());
}
private static <T> void printBox1(T box) {
System.out.println("String Value :" + ((Box)box).get());
}
}
class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}この場合、JavaコンパイラはTをObjectクラスに置き換え、型消去後、コンパイラは次のコードのバイトコードを生成します。
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box integerBox = new Box();
Box stringBox = new Box();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
printBox(integerBox);
printBox1(stringBox);
}
//Bounded Types Erasure
private static void printBox(Box box) {
System.out.println("Integer Value :" + box.get());
}
//Unbounded Types Erasure
private static void printBox1(Object box) {
System.out.println("String Value :" + ((Box)box).get());
}
}
class Box {
private Object t;
public void add(Object t) {
this.t = t;
}
public Object get() {
return t;
}
}どちらの場合も、結果は同じです-
出力
Integer Value :10
String Value :Hello Worldジェネリックスを使用すると、プリミティブ型を型パラメーターとして渡すことはできません。以下の例では、intプリミティブ型をboxクラスに渡すと、コンパイラは文句を言います。同じことを軽減するには、intプリミティブ型の代わりにIntegerオブジェクトを渡す必要があります。
例
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
//compiler errror
//ReferenceType
//- Syntax error, insert "Dimensions" to complete
ReferenceType
//Box<int> stringBox = new Box<int>();
integerBox.add(new Integer(10));
printBox(integerBox);
}
private static void printBox(Box box) {
System.out.println("Value: " + box.get());
}
}
class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}これにより、次の結果が生成されます-
出力
Value: 10タイプパラメータを使用して、メソッド内でそのオブジェクトをインスタンス化することはできません。
public static <T> void add(Box<T> box) {
//compiler error
//Cannot instantiate the type T
//T item = new T();
//box.add(item);
}このような機能を実現するには、リフレクションを使用します。
public static <T> void add(Box<T> box, Class<T> clazz)
throws InstantiationException, IllegalAccessException{
T item = clazz.newInstance(); // OK
box.add(item);
System.out.println("Item added.");
}例
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args)
throws InstantiationException, IllegalAccessException {
Box<String> stringBox = new Box<String>();
add(stringBox, String.class);
}
public static <T> void add(Box<T> box) {
//compiler error
//Cannot instantiate the type T
//T item = new T();
//box.add(item);
}
public static <T> void add(Box<T> box, Class<T> clazz)
throws InstantiationException, IllegalAccessException{
T item = clazz.newInstance(); // OK
box.add(item);
System.out.println("Item added.");
}
}
class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}これにより、次の結果が生成されます-
Item added.ジェネリックスを使用すると、型パラメーターを静的にすることはできません。静的変数はオブジェクト間で共有されるため、コンパイラーは使用するタイプを判別できません。静的型パラメーターが許可されている場合は、次の例を検討してください。
例
package com.tutorialspoint;
public class GenericsTester {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
printBox(integerBox);
}
private static void printBox(Box box) {
System.out.println("Value: " + box.get());
}
}
class Box<T> {
//compiler error
private static T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}stringBoxとintegerBoxはどちらも開始された静的型変数を持っているため、その型を判別できません。したがって、静的タイプのパラメーターは許可されません。
パラメータ化された型へのキャストは、無制限のワイルドカードによってパラメータ化されていない限り許可されていません。
Box<Integer> integerBox = new Box<Integer>();
Box<Number> numberBox = new Box<Number>();
//Compiler Error: Cannot cast from Box<Number> to Box<Integer>
integerBox = (Box<Integer>)numberBox;同じことを実現するために、無制限のワイルドカードを使用できます。
private static void add(Box<?> box) {
Box<Integer> integerBox = (Box<Integer>)box;
}コンパイラは型消去を使用するため、ランタイムは型パラメータを追跡しません。したがって、実行時にBox <Integer>とBox <String>の違いをinstanceOf演算子を使用して検証することはできません。
Box<Integer> integerBox = new Box<Integer>();
//Compiler Error:
//Cannot perform instanceof check against
//parameterized type Box<Integer>.
//Use the form Box<?> instead since further
//generic type information will be erased at runtime
if(integerBox instanceof Box<Integer>) { }パラメータ化された型の配列は許可されていません。
//Cannot create a generic array of Box<Integer>
Box<Integer>[] arrayOfLists = new Box<Integer>[2];コンパイラは型消去を使用するため、typeパラメータはObjectに置き換えられ、ユーザーは任意のタイプのオブジェクトを配列に追加できます。また、実行時に、コードはArrayStoreExceptionをスローできません。
// compiler error, but if it is allowed
Object[] stringBoxes = new Box<String>[];
// OK
stringBoxes[0] = new Box<String>();
// An ArrayStoreException should be thrown,
//but the runtime can't detect it.
stringBoxes[1] = new Box<Integer>();ジェネリッククラスは、Throwableクラスを直接的または間接的に拡張することはできません。
//The generic class Box<T> may not subclass java.lang.Throwable
class Box<T> extends Exception {}
//The generic class Box<T> may not subclass java.lang.Throwable
class Box1<T> extends Throwable {}メソッドは、型パラメーターのインスタンスをキャッチすることはできません。
public static <T extends Exception, J>
void execute(List<J> jobs) {
try {
for (J job : jobs) {}
// compile-time error
//Cannot use the type parameter T in a catch block
} catch (T e) {
// ...
}
}タイプパラメータはthrows句で許可されます。
class Box<T extends Exception> {
private int t;
public void add(int t) throws T {
this.t = t;
}
public int get() {
return t;
}
}クラスは、型消去後に同じシグネチャを持つことができる2つのオーバーロードされたメソッドを持つことはできません。
class Box {
//Compiler error
//Erasure of method print(List<String>)
//is the same as another method in type Box
public void print(List<String> stringList) { }
public void print(List<Integer> integerList) { }
}