对Java Generic相关知识的总结

 

对于如 List<E> 、 List< String > 、 List ，其中 List<E> 称为 parameterized type ， E 称为 (formal) type parameter ， String 称为 actual type argument ， List 称为 raw type 。

Generic 的逻辑意义

原有 java 的类型系统

Generic 为 java 5 带来了新的类型，这使得 java 中的类型关系变得更加复杂，要弄清楚加入了 generic 后的类型关系就需要先弄清楚原先 java 中的类型系统。

首先，在类型的定义上，类之间不允许多重继承，类可以实现多个接口。

其次，在类型的使用上，每个变量都必须有明确的类型，变量只能指向相应类型（或相应类型的子类型）的对象，为了实现这一规则， compile time 会对所有的赋值操作做检测，而 runtime 则对所有的显示类型转换做检测。

最后，数组作为 java 中一个特殊的类型，如果 B extends A ，那么 B[] extends A[] ，当对数组 element 赋值时， runtime 会做检测，类型不符则抛 ArrayStoreException ，如下。由于有多重数组的出现，意味着 java 的类型系统种有无限种类型。

// B extends A

A a = new A();

A[] array = new B[1];

Array[0] = a; // ArrayStoreException

我认为理想状态下的 generic

首先，假设有 B<T> extends A ，那么 B<Object> extends A 、 B<String> extends B<Object> ，并且 runtime 对使用到 parameter type 的输入参数做类型检测。这跟原先 java 类型系统中的 array 是一致的。与数组相同的还有，因为有如 B<B<String>> 、 B< B<B<String>>> 等等类型的存在， generic 也可以无限增加可用类型。

其次，当 generic 跟继承连用时，（在不考虑接口的情况下）有三种新的形式： B<T> extends A 、 B extends A<String> 、 B<T> extends A<T> ，其中第三种情况意味着有 B<String> extend A<String> 。

现实中的 generic

       事实上，在 java 5 中，对于 B<T> extends A ， B<Object> 跟 B<String> 之间并不存在继承关系（ invariant subtyping ），这跟数组（ covariant subtyping ）不同。之所以使用这种做法，我想有以下原因：

首先， java 5 compiler 使用 erasure 来支持 generic ，所有与 generic 相关的信息都不存在于 runtime （见下文中“ generic 的实现”），这就意味着 runtime 无法做如下的类型检测，而即便 runtime 有条件做类型检测，也势必影响代码的执行效率。

ArrayList<String> strList = new ArrayList<String>();

ArrayList<Object> objList = strList;

objList.add(new Object()); // runtime could not throw exception

其次，考虑下面的例子， B<T> extends A<T> ，有 B<String> extends A<String> ，如果使用 covariant subtyping ，又有 B<String> extends B<Object> ，这意味着存在多重继承，而多重继承在 java 里面是不被允许的。值得注意的是，尽管数组使用 covariant subtyping ，但却不会导致多重继承，因为数组属于系统类型， java 并不允许数组被继承。

采用了 invariant subtyping 之后，假如有 A<T> ，由于 A<Object> 不再是其他类型 A<String> 、 A<Integer> 等类型的父类， 则无法声明可以指向所有 A<T> 类型对象的变量。为了解决这一问题， java 1.5 引入了 wildcard ，声明为 A<?> 类型的变量可以指向所有 A<T> 类型的对象。需要注意的是， wildcard 跟继承是两种不同的关系，继承使类型间呈现树状的关系，类型为 B 的变量可以指向的对象类型必须在以 B 为根节点的子树中，而类型为 A<?> 的变量可以指向的对象类型必须为类型树中 A<Object> 或与 A<Object> 平行的节点。最后， wildcard 跟继承结合使得 A<?> 类型变量能够指向的对象类型必须在以 A<Object> 及 A<Object> 平行的节点为根的所有子树中。

// A<T> extends Object, B extends Object, C extends B, D extends B

A<?> a; // instances of A<Object>, A<String>, A<Integer> can be assigned to this variable

B b; // instance of B, C, D can be assigned to this variable

Generic 的实现

加入了 generic 后 java 的 type safe

       保证 type safe ，其实就关键在于确保所有变量所指向的对象的类型必须是正确的。我认为在理想状态下，应该实现以下几点：首先，类型为 A 的变量所能指向的对象类型必须在以 A 为根节点的子树中；其次，类型为 wildcard 的变量，如 A<?> ，所能指向的对象类型必须在以 A<Object> 及 A<Object> 平行的节点为根的所有子树中；最后，所有的显式转换在 runtime 必须做类型判定。其中，前两点由 compiler 实现，最后一点由 jvm 实现，然而事实上， java 5 仅实现了前两点，而决定不在 runtime 做检测。

       Compile time 下 generic 的 type safe 主要包括 generic class 跟 generic method 的 type safe ，以下分开讨论。

Generic class 的 type safe

       假设有以下的类：

public class A {};

public class B<T> extends A {

public T obj;

}

public class C<T> extends B<T> {

public void set(T obj) { this. obj = obj; }

public T get() { return obj; }

}

对于类型为 C<String> 的对象，能够指向它的变量的类型有： A 、 B<String> 、 C<String> 、 B<?> 、 C<?> 。对于类型为 A 的变量，通过该变量无法访问到任何与 T 相关的方法或对象变量，很显然在原有 java 的 type safe 机制仍然有效；对于类型为 B<String> 、 C<String> 的变量， compiler 对所有通过该变量所访问的方法（ set 、 get ）或对象变量 (obj) 进行检测，所有涉及到 T 的赋值都必须满足 T=String ，则 type safe 得以保证。对于类型为 B<?> 、 C<?> 的变量，通过该变量所访问的方法或对象变量，所有的输出值中 T 类型被替换成 T 的 bound （见下文中“ type parameter 的限制”），所有输入值中由于 T 类型未知，所以不能接受任何变量赋值（ null 除外）。在理想状态下，输入值中 T 类型应该也被替换成 T 的 bound ，然后由 runtime 去做类型判定，但是由于 runtime 没有 generic 相关的任何信息

C<String> strC = new C<String>();

C<?> c = strC;

// even if the following code pass compile time check, runtime could not throw exception

c.obj = new Object();

c.set(new Object());

// here’s a unexpected exception

String str = strC.obj;

str = strC.get();

在 generic class 的所有方法中， T 的类型被认为是其 bound 或者 bound 的某个子类。也就是说，首先， T 的变量只能指向类型为 T 或 T 的子类的对象；其次，通过 T 的变量只能访问到其 bound 的方法和对象变量。假设以下代码存在于 C 的 set 方法中：

public void set(T obj;) {

Object temp;

temp = obj; // ok

obj = temp; // ompile error

obj.toString(); // can access Object’s methods

}

Generic method 的 type safe

与 Generic class 不同的是，在 generic method 中， actual type argument 并非指定的，而是由 compiler 推断出的（ Inference ）。 Compiler 通过对 generic method 中的输入变量的类型推断 type parameter 的类型，如果不能够得到一个 unique smallest type ，则被视为 compile error ，参考以下代码：

public <A> void doublet(A a, A b) {};

…

// compile error, because String and Integer have both Comparable and Serializable as common supertypes

doublet(“abc”, 123);

当 wildcard 跟 generic method 同时使用时，有以下的特例：

public <T> List<T> test(List<T> list) { return list; }

…

List<?> wildcardList = new ArrayList<String>();

wildcardList = test(wildcardList);

最后， generic method 中对 type parameter 的使用所必须遵循的规则跟上面所提到的 generic class 的方法中的规则是一样的。

Erasure 的实现方式

Java 5 在 compiler 中采用 erasure 来实现 generic ，经过 erasure 的处理，所有与 generic 相关的信息将被抹掉（ erase ），同时在适当的位置插入显式类型转换，最终形成的 byte code 跟 java1.4 的 byte code 没有什么不一样。

首先， parameterized type ，被还原成其 non-parameterized type ，如 List<String> 将变成 List 。

其次， type parameter 被替换成它的 bound ，如 T 将变成 Object （假如它的 upper bound 是 Object ）。

接着，对于方法类成员的返回值，如果其类型为 parameter type ， erasure 则会插入显式转换。如：

public class A<T> {

public T get() { return null; }

}

…

A<String> a = new A<String>();

String temp = a.get();

// translate to

public class A {

public Object get() { return null; }

}

…

A a = new A();

String temp = (String) a.get();

最后 erasure 将在必要的时候插入 bridge method 。对于以下的代码

public class A<T> {

private T obj;

public void set(T obj) { this.obj = obj; }

public T get() { return obj; }

}

public class B extends A<String> {

public void set(String obj) {};

public String get() { return null;}

}

…

A<String> a = new B();

a.set(“abc”);

String temp = a.get();

在没有 bridge method 存在的情况下，对于 a 的方法的调用将无法获得多态性的支持，原因是 B 中的方法的 signature 跟 A 的不同，所以不被 jvm 视为重载。这时候 erasure 必须在 B 中插入如下的 bridge method ：

public void set(Object obj) { set((String) obj);}

public Object get() { return get(); }

需要注意的是 get 的 bridge method 在是编译不过的，因为 java 不允许这种形式的 overload ，事实上， bridge method 是直接在 byte code 中插入的。

最后值得注意的是， bridge method 只有在需要的时候被插入，如果 B 不重载 get 跟 set 方法，将不会有 bridge method 存在。

由于 runtime 缺乏 generic 相关的信息而导致的各种限制

1.       通过 wildcard 类型的变量访问方法及对象变量受到限制（如上文所述）。

2.       与 type parameter 相关的显式转化无法保证 type safe ，同时 compiler 会有 warning 。

List<?> list = new ArrayList<String>();

List<String> strList = (List<String>) list; // warning

public <T> T test1(Object obj) { return (T) obj; } // warning

public <T> T[] test2(Object[] objs) { return (T[]) objs; } // warning

3.       在创建某些类型对象时受到限制。

public <T> T test1(T sample) { return new T(); } // compile error

public <T> T[] test2(T sample) { return new T[0]; } // compile error

值得注意的是，即便提供了 actual type argument ，依然无法创建 parameterized type 的数组：

// compile error, but assumes that compiler allow to create such kind of array

List<String>[] lists = new List<String>[1];

List<Integer> intList = new List<Integer>();

intList.add(1);

Object[] objs = lists;

objs[0] = intList; // runtime could not throw an ArrayStoreException for this

String temp = lists[0].get(0); // unexpected error

通过 Class<T> 能够创建 T 的对象， Class<T> 的奥妙在于，一方面它能够通过 compiler 的检测，另一方面，它本身携带的信息也足以让 runtime 得以创建 T 的对象。

public T create(Class<T> c) { return c.newInstance(); };

…

String temp = create(String.class);

4.       不得不插入 bridge method （如上文所述）。

5.       使用 instanceof 时受到限制。

List<String> list = new ArrayList<String>();

boolean temp;

temp = list instanceof List<String>; // compile error

temp = list instanceof List<?>; // ok

6.       使用 reflection 时存在安全隐患。

public class A<T> {

public T obj;

}

public class B {

public A<String> a;

}

…

A<Integer> a = new A<Integer>();

B b = new B();

B.class.getField(“a”).set(a); // everything ok

String temp = b.a.obj; // unexpected error

7.       Generic class 中的 type parameter 在其静态方法及静态变量中无法使用。

在 generic 中对 type parameter 的限制

使用 extends 关键字

对于如 A<T> 的 generic class ，可以使用 extends 来进一步限制 T 所能代表的类型。如：

public class A<T extends Number> { … }

…

A<Object> objA; // compile error

A<String> strA; // compile error

A<Number> numA; // ok

A<Integer> intA; // ok

这里， extends 意味着 T 必须是 Number 或者 Number 的子类，以下是对于 extends 更为复杂的使用。

public class B<T extends B<T>> {…}

public class C extends B<C> { … }

public class D extends C { … }

…

C c = new C();

D d = new D();

B<C> bc; // ok

bc = c;

bc = d;

B<D> bd; // compile error

B<Object> b; // compile error

这里，显然 B<Object> 是非法的，对于 B<D> ，虽然 D 继承了 C ，但是把 D 替换到“ T extends B<T> ”中，显然“ D extends B<D> ”不成立，所以 B<D> 也是非法的，与此类似的是 java.lang 里面的“ Enum<E extends Enum<E>> ”，这一声明保证了，假设有类 Test ，它不是 Enum 类型（编译器保证只有使用 enum 关键字创建时才能满足 Enum 类中对 T 的限制），那么无法声明 Enum<Test> 类型的变量。

public class E<T, S extends T> { … }

…

E<Number, Number> e1; // ok

E<Number, Integer> e2; // ok

E<Number, String> e3; // compile error

这里， extends 用来限制不同的 type parameter(T 、 S) 之间的关系。

最后，需要注意的是，在 generic class 里面通过使用 extends 对 type parameter 进行限制所导致的结果是删除了一部分类型（如上述的 E<Number,String> ），而并非阻止这一类型的对象的创建，而在 generic method 里面使用 extends 则在于阻止某些类型的对象作为输入参数，如：

public <T extends String> void test(List<T> list) {}

…

test(new ArrayList<String>()); // ok

test(new ArrayList<Object>()); // compile error

关于 wildcard – “?”

在不使用 super 关键字的时候， ”?” 可以理解成 parameter type 的匿名形式，事实上，这些 ”?” 都可以转变成用 parameter type 表示。

public void test(List<? extends String> list) {}

public <T extends String> void test(List<T> list) {}

“?” 只能作为 parameterized type 的 actual type argument 使用，同时由于 ”?” 是匿名的形式，编译器并不会认为出现两次的 A<?> 要求相同的 type parameter 。

public void test(? obj) {} // compile error

public <T> void test1(List<T> list1, List<T> list2) {}

public void test2(List<?> list1, List<?> list2) {}

…

test1(new ArrayList<Object>(), new ArrayList<String>()); // compile error

test2(new ArrayList<Object>(), new ArrayList<String>()); // ok

使用 super 关键字

对于 T super A ， super 表示 T 必须是 A 或者 A 的父类，相比起 extends ，对 super 的使用有更多的限制。考虑以下代码：

public <T super Number> void test(T obj) {} // assumes that there’s no compile error

…

test(new Object()); // this looks reasonable

test(1); // Integer is not super class of Number, so compiler should reject this, but Integer is also an object, why would a method accept object as valid argument but not integer?

可以看到， super 限制对象类型必须是某个类或其父类，而继承则允许父类的变量接受子类的对象，这两者是互相抵触的，所以对 super 的时候有以下的限制：

首先， super 只能在 parameterized type 的 actual type argument 中作为限制条件使用，在这个时候，它并不和继承相抵触。如：

public void test(List<? super Number> list) {}

其次， super 不能用于限制非匿名的 parameter type ，显然如果可以这样的话，就会出现上述代码中的错误。这就决定了 super 只能与 ”?” 连用。

Generic 的向前兼容

下面以 List<E> 为例，为了向前兼容原先的代码，允许使用 List 这样的 raw type 。在语义上， List 跟 List<Object> 是一致的，然而在语法上 List 跟 List<?> 更为类似，并且编译器允许原先在 List 使用原先在 List<?> 上禁止的某些操作（对于 List<?> 为 compile error 的操作在 List 上仅仅是 warning ）。

首先，在类型转换上， List 跟 List<?> 是等价的， List 类型可以赋给任何指定了 actual type argument 的 parameterized type （如 List<String> ），而 List<?> 则不行（除非使用显式转换）。

List list;

List<?> wildcardList;

List<String> strList;

 

list = wildcardList;

list = strList;

wildcardList = list;

wildcardList = strList;

 

strList = list; // warning

strList = wildcardList; // compile error

其次， compiler 不允许通过 List<?> 访问任何输入参数与 E 相关的方法，而 List 则仅给出 wanring 。

list.add(“abc”); // waring

wildcardList.add(“abc”); // compile error

其他

关于 GJ

GJ 是使 java 支持 generic 的一个开源项目， java 5 的 generic 是参照 GJ 实现的， GJ 的语法以及实现方式基本上跟目前 java 5 的 generic 相同，当然在某些细节方面 java 5 的 generic 做了改动，研究 GJ 有利于更好的理解 java 5 的 generic 。

Security Implications

考虑以下的代码：

public class SecureChannel extends Channel {

public String read();

}

public class A {

public LinkedList<SecureChannel> cs;

…

}

由于 LinkedList<SecureChannel> 在 runtime 会退化成 LinkedList ，恶意的代码很容易在 cs 里面放入其他类型的 Channel 。 GJ 中建议使用 type specialization 来解决这一问题，但是由于 java 5 的 generic 仅在需要的时候插入 bridge 方法，所以这一方法在 java 5 中是无效的。

在方法参数中使用 extends 、 super 关键字的技巧

考虑如下代码：

public class A<T> {

private T obj;

public void set(T obj) { this.obj = obj; }

public T get() { return obj; }

}

…

public class Test<T> {

public void test(A<T> a) { … }

…

}

…

A<Object> a = new A<Object>();

A<Number> numA = new A<Number>();

A<Integer> intA = new A<Integer>();

Test<Number> test = new Test<Number>();

test.test(a); // compile error (1)

test.test(numA); // ok

test.test(intA); // compile error (2)

对于 test 方法，如果方法内仅需要调用 A<T> 的 set 方法（即仅需要用到输入值为 T 类型的方法，注意，这不包括如 List<T> 这种类新），使用 A<? super T> 代替 A<T> 可能会更为合适，这使得 (1) 得以编译通过，由于仅需要调用 A<T> 的 set 方法， A<Object>.set(Object) 显然比 A<Number>.set(Number) 允许更多的类型，从而使 A<Object> 可以替换 A<Number> 。相似的，如果 test 方法内仅需要调用 A<T> 个 get 方法，则使用 A<? extends T> 代替 A<T> 可能会更合适，这使得 (2) 得以编译通过。

关于 type parameter 的命名规范

推荐使用精简同时有意义的名称，如 E for element 、 T for type （最好是单个字母），同时避免使用任何小写字母以使得 type parameter 能够从一般的类还有接口名称中被区分出来。如果需要同时使用多个 type parameter ，则考虑使用邻近的几个不同字母，如 T 、 S 。如果在某个类中已经使用了某个字母作为 type parameter ，则在其 generic method 以及 nested class 中避免使用同样的字母。

Generic method 采用 inference 所产生的问题

public interface I {}

public class A implements I {}

public class B{}

public <T> void test(T a, T b);

…

test(new A(), new B()); // ok

当代码改动 B 也需要实现接口 I 的时候：

public class B implements I {}

…

test(new A(), new B()); // compile error

仍然搞不懂的地方

对于类似 java.util.Collections 的 max 方法，经过我的试验以下两种声明方式所能接受的类型是一样的，不明白它为什么要用前者。

public static <T extends Object & Comparable<? super T>> T max1(Collection<? extends T> coll)

public static <T extends Object & Comparable<? super T>> T max2(Collection<T> coll)

参考资料

GJ- Making the future safe for the past: Adding Genericity to the JavaTM Programming Language

Generics in the Java Programming Language