《Java组件设计》第三章 预备知识(续2)
3.4 泛型
3.4.1 泛型简介
先拿一个例子来说明泛型是什么。
有两个类如下，要构造两个类的对象，并打印出各自的成员
x
。
public class StringFoo {
private String x;
public String getX() {
return x;
}
public void setX(String x) {
this.x = x;
}
}
public class DoubleFoo {
private Double x;
public Double getX() {
return x;
}
public void setX(Double x) {
this.x = x;
}
}
如果要实现对
Integer
、
Long
、
Date
等类型的操作，还要写相应的类，实在是无聊之极。
因此，对上面的两个类进行重构，写成一个类，考虑如下：
上面的类中，成员和方法的逻辑都一样，就是类型不一样。
Object
是所有类的父类，因此可以考虑用
Object
做为成员类型，这样就可以实现通用了。
public class ObjectFoo {
private Object x;
public Object getX() {
return x;
}
public void setX(Object x) {
this.x = x;
}
}
调用的代码如下：
public
class ObjectFooDemo {
public static void main(String args[]) {
ObjectFoo strFoo = new ObjectFoo();
strFoo.setX("Hello Generics!");
ObjectFoo douFoo = new ObjectFoo();
douFoo.setX(new Double("33"));
ObjectFoo objFoo = new ObjectFoo();
objFoo.setX(new Object());
String str = (String)strFoo.getX();
Double d = (Double)douFoo.getX();
Object obj = objFoo.getX();
System.
out
.println("strFoo.getX=" + str);
System.
out
.println("douFoo.getX=" + d);
System.
out
.println("strFoo.getX=" + obj);
}
}
以上，是没有泛型的情况下，我们编写的代码，采用最顶层基类
Object
进行类型声明，然后将值传入，取出时要进行强制类型转换。
JDK
从
1.5
开始引入了泛型的概念，来优雅解决此类问题。采用泛型技术，编写的代码如下：
public class GenericsFoo <T> {
private T x;
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
}
调用的代码如下：
public
class GenericsFooDemo {
public static void main(String args[]){
GenericsFoo<String> strFoo=new GenericsFoo<String>();
strFoo.setX("Hello Generics!");
GenericsFoo<Double> douFoo=new GenericsFoo<Double>();
douFoo.setX(new Double("33");
GenericsFoo<Object> objFoo=new GenericsFoo<Object>();
objFoo.setX(new Object());
String str = strFoo.getX();
Double d = douFoo.getX();
Object obj = objFoo.getX();
System.out.println("strFoo.getX=" + str);
System.out.println("douFoo.getX=" + d);
System.out.println("strFoo.getX=" + obj);
}
}
注意，有几点明显的改变：
1．
对象创建时，明确给出类型，如
GenericsFoo<String>
。
2．
对象通过
getX
方法取出时，不需要进行类型转换。
3．
对各个方法的调用，如果参数类型与创建时指定的类型不匹配时，编译器就会报错。
那么我们为什么要泛型呢？
有两个好处：
1.
可以在编译时检查存储的数据是否正确。我们开发有一个趋向就是尽早的发现错误，最好就是在编译阶段，
泛型正好符合这一条件。
2.
减少了强制转换，
String str = (String)strList.get(0
）；这样的操作属于一种向下转型，
是比较危险的操作，
当
List
内存储的对象不适
String
时就会抛出异常。
JDK1.5
中，
java.util
包中的各种数据类型工具类，都支持泛型，在编程中被广泛使用，需要好好掌握。
泛型最常见的应用是应用在类、接口和方法上，下面分别介绍。
3.4.2 泛型应用在接口上：
public interface ValuePair<A,B> {
public A getA();
public B getB();
public String toString();
}
这里
A
和
B
都是代表类型。尖角号
<>
中，可以使用一个类型，也可以使用多个类型。
3.4.3 泛型应用在类上：
public class ValuePairImpl<A,B> {
public final A first;
public final B second;
public ValuePairImpl(A a, B b) { first = a; second = b; }
public A getA() { return first; }
public B getB() { return second; }
public String toString() {
return "(" + first + ", " + second + ")";
}
}
如果这个类实现泛型接口，则相应的写法为：
public class ValuePairImpl<A,B> implements ValuePair<A, B> {
……
}
3.4.4 泛型应用在方法上：
泛型也可以应用在单独的方法上，示例如下：
public class GenericMethod {
public <T> void printValue(T v) {
String str = v.getClass().getName() + “ = “ + v.toString();
System.out.println(str);
}
}
注意语法：在
public
修饰符后面是
<>,
然后是函数返回值，
接着是函数名，函数参数。当然，返回值也可以是泛型的类型。
3.4.5 限制泛型的可用类型
以上介绍的三种泛型应用，应用在接口、类、方法上，是一种通用的做法，对泛型可以传入的类型没有任何限制。但有些场景下，我们希望对可用的类型进行限制，比如希望传入的类型必须从某个类继承（也就是说，必须是某个类的子类、孙类等），这种情况下就用到了泛型限制的语法。
extends
：限制泛型类型必须为某个类的后代，包括本类型。
语法：
<T extends parentClass>
这里，
T
为泛型类型，
extends
关键字限制泛型类型必须是
parentClass
的后代。
parentClass
指定父类的类型，也可以是接口。
在
Java
语言中，对类只能单继承，对接口可以多继承，如果要限制指定类型必须从某个类继承，并且实现了多个接口，则语法为：
<T extends parentClass & parentInterface1 & parentInterface2>
注意，类必须在接口前面。
举例如下：
public
class BaseClass {
int value;
public BaseClass(int value) {
this.value = value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
public
class SubClass extends BaseClass{
public SubClass(int value) {
super(value*2);
}
}
public
class GenericBound<T extends BaseClass> {
public long sum(List<T> tList) {
long iValue = 0;
for (BaseClass base : tList) {
iValue += base.getValue();
}
return iValue;
}
public static void main(String[] args) {
GenericBound<SubClass> obj = new
GenericBound<SubClass>();
List<SubClass> list = new LinkedList<SubClass>();
list.add(new SubClass(5));
list.add(new SubClass(6));
System.
out
.println(obj.sum(list));
}
}
运行，输出结果为
22.
接着，我们再深入探讨一下。把上面的例子该写如下：
public
class GenericBound<T extends BaseClass> {
public long sum(List<T> tList) {
long iValue = 0;
for (BaseClass base : tList) {
iValue += base.getValue();
}
return iValue;
}
public static void main(String[] args) {
//
注意！！！
//
将
obj
的类型由
GenericBound<SubClass>
改为
GenericBound<BaseClass>
，无法通过编译
GenericBound<BaseClass> obj = new
GenericBound<SubClass>();
List<SubClass> list = new LinkedList<SubClass>();
list.add(new SubClass(5));
list.add(new SubClass(6));
System.out.println(obj.sum(list));
}
}
语句
GenericBound<BaseClass> obj = new GenericBound<SubClass>();
无法通过编译，其根本原因在于，
GenericBound
类声明处的
<T extends BaseClass>
，限制了构造此类实例的时候
T
是确定的一个类型，这个类型是
BaseClass
的后代。但是
BaseClass
的后代还又很多，如
SubClass3
，
SubClass4
，如果针对每一种都要写出具体的子类类型，那也太麻烦了，干脆还不如用
Object
通用一下。能不能象普通类那样，用父类的类型引入各种子类的实例，这样不就简单了很多？答案是肯定的，泛型针对这种情况提供了更好的解决方案，那就是“通配符泛型”，下面详细讲解。
3.4.6 通配符泛型
Java
的泛型类型如同
java.lang.String
，
java.io.File
一样，属于普通的
Java
类型。比方说，下面两个变量的类型就是互不相同的：
Box<Object> boxObj = new Box<Object>();
Box<String> boxStr = new Box<String>();
虽然
String
是
Object
的子类，但是
Box<String>
和
Box<Object>
之间并没有什么关系――
Box<String>
不是
Box<Object>
的子类或者子类型，因此，以下赋值语句是非法的：
boxObj = boxStr; //
无法通过编译
因此，我们希望使用泛型时，
能象普通类那样，用父类的类型引入各种子类的实例，从而简化程序的开发。
Java
的泛型中，
提供
?
通配符来满足这个要求。
代码示例如下：
public
class WildcardGeneric {
public void print(List<?> lst) {
for (int i = 0; i < lst.size(); i++) {
System.out.println(lst.get(i));
}
}
public static void main(String[] args) {
WildcardGeneric wg = new WildcardGeneric();
ArrayList<String> strList = new ArrayList<String>();
strList.add("One");
strList.add("Two");
wg.print(strList);
LinkedList<Integer> intList = new LinkedList<Integer>();
intList.add(25);
intList.add(30);
wg.print(intList);
}
}
但是这种情况下，
WildcardGeneric.print
方法的参数可以接受类型可能对于程序员设计的意图而言太广泛了一点。因为我们可能只是希望
print
可以接受一个
List
，但这个
List
中的元素必须是
Number
的后代。因此，我们要对通配符有所限制，这时可以使用边界通配符（
bounded wildcard
）形式来满足这个要求。我们将
print
方法再修改一下：
public
void print(List<? extends Number> lst) {
for (int i = 0; i < lst.size(); i++) {
System.out.println(lst.get(i));
}
}
这样，
List<Integer>
、
List<Short>
等等类型的变量就可以传给
print
方法，而储存其他类型元素的
List
的泛型类型变量
(
如
List<String>)
传给
print
方法将是非法的。
除了
？
extends
上边界通配符（
upper bounded wildcard
）以外，我们还可以使用下边界通配符（
lower bounded wildcard
），例如
List<? super ViewWindow>
。
最后总结一下使用通配符的泛型类型的三种形式：
GenericType<?>
GenericType<? extends upperBoundType>
GenericType<? super lowerBoundType>
3.4.7 泛型深入
我们已经初步掌握了泛型的基本用法，接着再来探讨一下深入的主题。
我们还是先来看一段代码：
public
class GenericsFoo <T> {
private T x;
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public static void main(String[] args) {
GenericsFoo<String> gf = new GenericsFoo<String>();
gf.setX("Hello");
GenericsFoo<?> gf2 = gf;
gf2.setX("World"); //
报错！！！
String str = gf2.getX(); //
报错！！！
gf2.setX(gf2.getX()); //
报错！！！
}
}
注意，
main
方法中的最后三行都是非法的，无法通过编译。本来是一个
<String>
的泛型，通过
<?>
来引用后，
setX()
传入一个
String
就报错，
getX()
返回值的类型也不是
String
。更为奇怪的是，语句
gf2.setX(gf2.getX());
就是从里面取出值然后再原封不动设置回去，也不行。这是怎么回事？
为了彻底弄清楚这些问题，我们需要了解
JDK
对泛型的内部实现原理。先看两个例子：
public
class GenericClassTest {
public static void main(String[] args) {
Class c1 = new ArrayList<String>().getClass();
Class c2 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2);
Class c3 = new ArrayList().getClass();
System.out.println(c1 == c3);
}
}
运行后，输出结果为：
true
true
这个例子说明，泛型
ArrayList<String>
、
ArrayList<Integer>
和没有使用泛型的
ArrayList
其实是同一个类。就如同没使用泛型一样。
再看第二个例子：
class
Element {}
class
Box<T> {}
class
Pair<KEY, VALUE> {}
public
class GenericClassTest2 {
public static void main(String[] args) {
List<Element> list = new ArrayList<Element>();
Map<String,Element> map = new HashMap<String, Element>();
Box<Element> box = new Box<Element>();
Pair<Integer, String> p = new Pair<Integer, String>();
System.out.println(Arrays.toString(
list.getClass().getTypeParameters()));
System.out.println(Arrays.toString(
map.getClass().getTypeParameters()));
System.out.println(Arrays.toString(
box.getClass().getTypeParameters()));
System.out.println(Arrays.toString(
p.getClass().getTypeParameters()));
}
}
运行后，输出结果为：
[E]
[K, V]
[T]
[KEY, VALUE]
查阅
JDK
的文档，
Class.getTypeParameters()
方法返回一个
TypeVariable
对象的数组，数组中每个
TypeVariable
对象描述了泛型中声明的类型。这似乎意味着，我们可以从
TypeVariable
对象中找出泛型实例化时真正的类型。但是，从程序运行的输出结果，我们可以看出，
Class.getTypeParameters()
返回的一系列
TypeVariable
对象，仅仅表征了泛型声明时的参数化类型占位符，真正实例化时的类型都被抛弃了。因此，
Java
泛型的真相是：
在泛型代码中，根本就没有参数化类型的信息。
产生这样一个事实的原因在于，
JDK
对泛型的内部实现，采用了擦除
(erasure)
的方式，具体擦除的方式如下：
1)
ArrayList<String>
、
ArrayList<Integer>
、
ArrayList<?>
都被擦除成
ArrayList
2)
ArrayList<T extends BaseClass>
、
ArrayList<? extends BaseClass>
都被擦除成
ArrayList<BaseClass>
3)
ArrayList<? super BaseClass>
被擦除成
ArrayList<BaseClass>
理解了擦除的实现机制后，我们再回过头来，分析一下前面的例子，看看为什么不能通过编译：
public
class GenericsFoo <T> {
private T x;
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public static void main(String[] args) {
GenericsFoo<String> gf = new GenericsFoo<String>();
gf.setX("Hello");
GenericsFoo<?> gf2 = gf;
gf2.setX("World"); //
报错！！！
String str = gf2.getX(); //
报错！！！
gf2.setX(gf2.getX()); //
报错！！！
}
}
由于擦除机制，
GenericsFoo<?
>
都被擦除成
GenericsFoo
，类型被丢失后，那么相应的方法声明就变成了：
public Object getX();
public void setX(null x);
因此，泛型类的任何取出值的
get
方法，返回值都变成了
Object
，可以被调用，但返回值需要进行类型转换；泛型类的任何设置值的
set
方法，参数类型都变成了
null
，任何类型都无法转换成
null
类型，因此所有的
set
方法都无法被调用。
这样就形成了一个有趣的现象：对
<?>
的泛型类型，只能
get
，不能
set
。
以上阐述了
Java
泛型的擦除机制，导致一些有用的类型信息丢失。但我们可以通过一些技巧，让编译器重新构建出类型信息，从而使得
set
方法可以被正常调用。见如下的代码：
public void setGeneric(GenericsFoo<?> foo) {
setGenericHelper(foo);
}
private<V> void setGenericHelper(GenericsFoo<V> foo) {
foo.setX(foo.getX());
}
setGenericHelper()
是一个泛型方法，泛型方法引入了额外的类型参数（位于返回类型之前的尖括号中），这些参数用于表示参数和
/
或方法的返回值之间的类型约束。
setGenericHelper ()
这种声明方式，允许编译器（通过类型接口）对
GenericsFoo
泛型的类型参数命名。但一个类型可以有父类、祖父类，还可以实现多个接口，那么编译器会转换成哪个类型呢？
我们用下面这段代码来验证一下：
public
class GenericClassTest3 {
public static<T> String getType(T arg) {
return arg.getClass().getName();
}
public static void main(String[] args) {
Integer i = new Integer(5);
System.out.println(GenericClassTest3.getType(i));
}
}
程序运行后，输出结果为：
java.lang.Integer
因此，编译器能够推断
T
是
Integer
、
Number
、
Serializable
或
Object
，但它选择
Integer
作为满足约束的最具体类型。
另外，由于泛型的擦除机制，我们也无法直接对泛型类型用
new
操作符，比如：
public
class GenericNew<T> {
public T create() {
T obj = new T(); //
无法通过编译！！！
return obj;
}
}
由于擦除机制，语句
T obj = new T();
擦除后就变成了
obj = new ();
于是就无法通过编译了。
但是，在一些情况下，我们还是需要对泛型类型的动态实例化。对于创建单个对象和创建数组，代码示例如下：
public
class GenericNew<T> {
public T create(Class<T> cls) {
try {
Object obj = cls.newInstance();
return (T)obj;
} catch(Exception e) {
return null;
}
}
public T[] createArray(Class<T> cls, int len) {
try {
Object obj = java.lang.reflect.Array.newInstance(cls, len);
return (T[])obj;
} catch (Exception e) {
return null;
}
}
}
以上代码中，
create
方法实现了动态创建一个泛型类型的实例，
createArray
方法实现了动态创建一个泛型类型的实例数组。
本文出自 “expert” 博客，转载请与作者联系！