关闭

对Java Generic相关知识的总结

1531人阅读 评论(0) 收藏 举报
 
对于如 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
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:170104次
    • 积分:1647
    • 等级:
    • 排名:千里之外
    • 原创:9篇
    • 转载:111篇
    • 译文:0篇
    • 评论:58条
    文章分类