|
在定義泛型時，可以定義型態的邊界（Bound）。例如：
class Animal {}
class Human extends Animal {}
class Toy {}
class Duck<T extends Animal> {}
public class Main {
public static void main(String[] args) {
Duck<Animal> ad = new Duck<Animal>();
Duck<Human> hd = new Duck<Human>();
Duck<Toy> hd = new Duck<Toy>(); // 編譯錯誤
}
}
在上例中，使用 extends 定義指定泛型真正型態時，必須是Animal的子類，你可以使用Animal與Human來指定型態，但不可以使用Toy指定型態，因為Toy不是Animal的子類。
一個實際應用可以用 快速排序法 中的例子來說明：
class Sort {
public void quick(int[] number) {
sort(number, 0, number.length-1);
}
private void sort(int[] number, int left, int right) {
if(left < right) {
int q = partition(number, left, right);
sort(number, left, q-1);
sort(number, q+1, right);
}
}
private int partition(int number[], int left, int right) {
int i = left - 1;
for(int j = left; j < right; j++) {
if(number[j] <= number[right]) {
i++;
swap(number, i, j);
}
}
swap(number, i+1, right);
return i+1;
}
private void swap(int[] number, int i, int j) {
int t = number[i];
number[i] = number[j];
number[j] = t;
}
}
在這個例子中，是以int來示範演算法的實作，如果要讓這個類別更一般化，可以排序任何型態的物件，則該型態必須具備可比較物件大小的方法，一個方式是要求要排序的物件實作java.lang.Comparable<T>介面。所以可以修改類別定義如下：
class Sort<T extends Comparable<T>> {
void quick(T[] array) {
sort(array, 0, array.length-1);
}
private void sort(T[] array, int left, int right) {
if(left < right) {
int q = partition(array, left, right);
sort(array, left, q-1);
sort(array, q+1, right);
}
}
private int partition(T[] array, int left, int right) {
int i = left - 1;
for(int j = left; j < right; j++) {
if(array[j].compareTo(array[right]) <= 0) {
i++;
swap(array, i, j);
}
}
swap(array, i+1, right);
return i + 1;
}
private void swap(T[] array, int i, int j) {
T t = array[i];
array[i] = array[j];
array[j] = t;
}
}
只要你定義的類別實作了java.lang.Comparable<T>，就可以使用這個類別來進行排序，例如字串就實作了java.lang.Comparable<T>：
public class Main {
public static void main(String[] args) {
Sort<String> sort = new Sort<String>();
String[] strs = {"3", "2", "5", "1"};
sort.quick(strs);
for(String s : strs) {
System.out.println(s);
}
}
}
若extends之後指定了類別或介面後，想再指定其它介面，可以使用&連接。例如：
public class Some<T extends Iterable<T> & Comparable<T>> {
...
}
|