什么是泛型
就本质而言, 术语"泛型"的意思是参数化类型. 参数化类型很重要, 因为使用该特性创建的类, 接口以及方法, 可以作为参数指定所操作数据的类型.
一个简单的泛型示例
class Gen<T> {
T ob;
Gen(T o) {
this.ob = o;
}
T getOb() {
return this.ob;
}
void showType() {
System.out.println("Type of T is " + this.ob.getClass().getName());
}
}
public class GenDemo {
public static void main(String[] args) {
Gen<Integer> iOb = new Gen<Integer>(88);
iOb.showType();
int v = iOb.getOb();
System.out.println("value: " + v);
System.out.println();
Gen<String> strOb = new Gen<>("Generics Test");
strOb.showType();
String str = strOb.getOb();
System.out.println("value: " + str );
}
}
下面详细分析该程序.
首先, 注意下面这行代码声明泛型类 Gen 的方式:
class Gen<T> {
其中, T 是类型参数的名称. 这个名称是实际类型的占位符, 当创建对象时, 将实际类型传递给 Gen. 因此在 Gen 中, 只需要类型参数, 就是用 T.
注意 T 被包含在<>中, 只要是声明类型参数, 就需要在尖括号中指定, 因为 Gen 使用类型参数, 所以 Gen 是泛型类, 也成为参数化类型.
接下来使用 T 声明 ob, 如下所示:
T ob;
前面解释过, T 是将在创建 Gen 对象时指定的实际类型的占位符. 因此, ob 是传递给 T 的那种实际类型的对象. 例如, 如果将String 传递给 T , ob 将是String 类型.
现在分析 Gen 的构造函数:
Gen(T o) {
this.ob = o;
}
注意参数 o 的类型是 T, 这意味着 o 的实际类型取决于创建 Gen 对象时传递给 T 的类型. 此外, 因为参数 o 和成员变量 ob 的类型都是T, 所以在创建 Gen 对象时, 它们将具有相同的类型.
还可以使用类型参数 T 指定方法的返回类型, 就像 getOb() 方法那样, 如下所示:
T getOb() {
return this.ob;
}
因为 ob 也是T类型, 所以 ob 的类型和 getOb() 方法指定的返回类型是兼容的.
showType() 方法通过对 Class 对象调用 getName() 方法显式 T 的类型, 而这个 Class 对象是通过对 ob 调用 getClass() 方法返回的.
GenDemo 类演示了泛型化的 Gen 类. 它首先创建整形版本的 Gen类, 如下所示:
Gen<Integer> iOb
请仔细分析这个声明. 首先, 注意类型 Integer 是在 Gen 后面的尖括号中指定. 在此, Integer 是传递给 Gen 的类型参数. 对T 的所有引用都被转化为对 Integer 的引用. 因此对于这个声明, ob 是 Integer 类型, 并且 getob() 方法的返回类型是 Integer.
该代码将一个引用赋给 iOb:
iOb = new Gen<Integer>(88);
注意在调用 Gen 构造函数时, 仍然指定了类型参数 Integer. 这是必须的, 因为将其赋值的对象类型是 Gen<Integer>. 因此, new 返回的引用必须是 Gen<Integer> 类型.如果不是的话, 就会产生编译错误.
接下来, 程序使用下面这行代码获取 ob 的值:
int v = iOb.getOb();
因为 getob() 方法的返回类型是 T, 当声明 iOb 时 T 已被替换为 Integer 类型, 所以 getob() 方法的返回类型也是 Integer, 当返回值赋值给 v 时会自动拆箱为 int 类型.
接下来, GemDemo 声明了 Gem<String> 类型的对象:
Gen<String> strOb = new Gen<>("Generics Test");
因为类型参数是 String, 所以使用 String 替换 Gen 中的 T,这会创建Gen的String版本, 就像程序中剩余代码所演示的那样.
泛型使用引用类型
当声明泛型类的实例时, 传递过来的参数必须是引用类型. 不能使用基本类型, 如果 int 或 char. 例如, 对 Gen, 可以将任何类型传递给 T, 但是不能将基本类型传递给类型参数T ,所以, 一下声明是非法的.
Gen<int> intOb = new Gen<int>(53);
带两个类型参数的泛型类
class TwoGen<T, V> {
T ob1;
V ob2;
TwoGen (T o1, V o2) {
this.ob1 = o1;
this.ob2 = o2;
}
void showTypes() {
System.out.println("Type of T is " + ob1.getClass().getName());
System.out.println("Type of V is " + ob2.getClass().getName());
}
T getOb1() {
return ob1;
}
V getOb2() {
return ob2;
}
}
public class SimpGen {
public static void main(String[] args) {
TwoGen<Integer, String> tgObj =
new TwoGen<>(88, "Generics");
tgObj.showTypes();
int v = tgObj.getOb1();
System.out.println("value: " + v);
String str = tgObj.getOb2();
System.out.println("value: " + str);
}
}
注意 TwoGen 的声明方式:
class TwoGen<T, V> {
在此指定了两个类型参数: T 和 V, 使用逗号将他们隔开. 创建对象时必须为 TwoGen 传递两个类型参数, 如下所示:
TwoGen<Integer, String> tgObj =
new TwoGen<>(88, "Generics");
在此, Integer 替换 T, String 替换 V.
在这个例子中, 尽管两个类型参数是不同的, 但是可以将两个类型参数设置为相同的类型. 例如, 下面这行代码是合法的:
TwoGen<String, String> x=
new TwoGen<>("A", "B");
在此, T 和 V 都是 String 类型. 当然, 如果类型参数总是相同的, 就不必使用两个类型参数了.
