What and Why
There may be times when you want to restrict the types that can be used as type arguments in a parameterized type. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for.
How
To declare a bounded type parameter, list the type parameter's name, followed by the extends keyword, followed by its upper bound.
注意： In this context, extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces)
public class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
public <U extends Number> void inspect(U u){
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
integerBox.set(new Integer(10));
integerBox.inspect("some text"); // error: this is still String!
}
}
In addition to limiting the types you can use to instantiate a generic type, bounded type parameters allow you to invoke methods defined in the bounds:
public class NaturalNumber<T extends Integer> {
private T n;
public NaturalNumber(T n) { this.n = n; }
public boolean isEven() {
return n.intValue() % 2 == 0;
}
// ...
}
上面的例子中，由于限定了T是Integer的子类，所以n可以直接调用Integer中的方法intValue。
Multiple Bounds
如果有多个限定，写法如下：
<T extends B1 & B2 & B3>
假设有3个限定A， B， C，其中A是一个类，B和C都是接口：
Class A { /* ... */ }
interface B { /* ... */ }
interface C { /* ... */ }
那么应该把A放在最前面，否则会报错：
class D <T extends A & B & C> { /* ... */ }
class D <T extends B & A & C> { /* ... */ } // compile-time error
Generic Methods and Bounded Type Parameters
假设我们要实现以下代码的功能：
public static <T> int countGreaterThan(T[] anArray, T elem) {
int count = 0;
for (T e : anArray)
if (e > elem) // compiler error
++count;
return count;
}
但是这段代码会出现编译错误，因为T的具体类型是未知的，不能直接通过e > elem判断大小（只有数值类型才能直接这样判断）。这个时候我们可以使用Bounded Type Parameters来很好的解决这个问题：
public interface Comparable<T> {
public int compareTo(T o);
}
public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
int count = 0;
for (T e : anArray)
if (e.compareTo(elem) > 0)
++count;
return count;
}
我们限定T必须实现Comparable<T>接口，而Comparable<T>接口中定义了比较两个T的大小的方法。
