java泛型 (转)
在Java SE1.5中，增加了一个新的特性：泛型（日本语中的总称型）。何谓泛型呢？通俗的说，就是泛泛的指定对象所操作的类型，而不像常规方式一样使用某种固定的类型去指定。泛型的本质就是将所操作的数据类型参数化，也就是说，该数据类型被指定为一个参数。这种参数类型可以使用在类、接口以及方法定义中。
一、为什么使用泛型呢？
在以往的J2SE中，没有泛型的情况下，通常是使用Object类型来进行多种类型数据的操作。这个时候操作最多的就是针对该Object进行数据的强制转换，而这种转换是基于开发者对该数据类型明确的情况下进行的（比如将Object型转换为String型）。倘若类型不一致，编译器在编译过程中不会报错，但在运行时会出错。
使用泛型的好处在于，它在编译的时候进行类型安全检查，并且在运行时所有的转换都是强制的，隐式的，大大提高了代码的重用率。
二、泛型的简单例子：
首先，我们来看看下面两个普通的class定义
private String myStr;
public String getStr() {
return myStr;
}
public void setStr(str) {
myStr = str;
}
}
public class getDouble {
private Double myDou;
public Double getDou() {
return myDou;
}
public void setDou(dou) {
myDou = dou;
}
}
这两个class除了所操作的数据类型不一致，其他机能都是相同的。现在，我们可以使用泛型来将上面两个class合并为一个，从而提高代码利用率，减少代码量。
public class getObj<T> {
private T myObj ;
public T getObj() {
return myObj;
}
public void setObj<T obj> {
myObj = obj;
}
}
那么，使用了泛型后，如何生成这个class的实例来进行操作呢？请看下面的代码：
getObj<String> strObj = new getObj<String>();
strObj.setObj(“Hello Nissay”);
System.out.println(strObj.getObj());
getObj<Double> douObj = new getObj<Double>();
douObj.setObj(new Double(“116023”));
System.out.println(douObj.getObj());
三、例子分析
现在我们来分析上面那段代码：
1、<T>是泛型的标记，当然可以使用别的名字，比如。使用<T>声明一个泛型的引用，从而可以在class、方法及接口中使用它进行数据定义，参数传递。
2、<T>在声明的时候相当于一个有意义的数据类型，编译过程中不会发生错误；在实例化时，将其用一个具体的数据类型进行替代，从而就可以满足不用需求。
四、泛型的规则和限制
通过上述的例子，我们简单理解了泛型的含义。在使用泛型时，请注意其使用规则和限制，如下：
1、泛型的参数类型只能是引用类型，而不能是简单类型。
比如，<int>是不可使用的。
2、可以声明多个泛型参数类型，比如<T, P,Q…>，同时还可以嵌套泛型，例如：<List<String>>
3、泛型的参数类型可以使用extends语句，例如<T extends superclass>。
4、泛型的参数类型可以使用super语句，例如< T super childclass>。
5、泛型还可以使用通配符，例如<? extends ArrayList>
五、扩展
1、extends语句
使用extends语句将限制泛型参数的适用范围。例如：
<T extends collection> ，则表示该泛型参数的使用范围是所有实现了collection接口的calss。如果传入一个<String>则程序编译出错。
2、super语句
super语句的作用与extends一样，都是限制泛型参数的适用范围。区别在于，super是限制泛型参数只能是指定该class的上层父类。
例如<T super List>，表示该泛型参数只能是List和List的上层父类。
3、通配符
使用通配符的目的是为了解决泛型参数被限制死了不能动态根据实例来确定的缺点。
举个例子：public class SampleClass < T extends S> {…}
假如A，B，C，…Z这26个class都实现了S接口。我们使用时需要使用到这26个class类型的泛型参数。那实例化的时候怎么办呢？依次写下
SampleClass<A> a = new SampleClass();
SampleClass<B> a = new SampleClass();
…
SampleClass<Z> a = new SampleClass();
这显然很冗余，还不如使用Object而不使用泛型，呵呵，是吧？
别着急，咱们使用通配符，就OK了。
SampleClass<? Extends S> sc = new SampleClass();
只需要声明一个sc变量，很方便把！
通配符进阶
泛型最复杂的部分是对通配符的理解。我们将讨论三种类型的通配符以及它们的用途。
首先让我们了解一下数组是如何工作的。可以从一个Integer[]为一个Number[]赋值。如果尝试把一个Float写到Number[]中，那么可以编译，但在运行时会失败，出现一个ArrayStoreException：
Integer[] ia = new Integer[5];
Number[] na = ia;
na[0] = 0.5; // compiles, but fails at runtime
如果试图把该例直接转换成泛型，那么会在编译时失败，因为赋值是不被允许的：
List<Integer> iList = new ArrayList<Integer>();
List<Number> nList = iList; // not allowed
nList.add(0.5);
如果使用泛型，只要代码在编译时没有出现警告，就不会遇到运行时ClassCastException。
上限通配符
我们想要的是一个确切元素类型未知的列表，这一点与数组是不同的。
List<Number>是一个列表，其元素类型是具体类型Number。
List<? extends Number>是一个确切元素类型未知的列表。它是Number或其子类型。
上限
如果我们更新初始的例子，并赋值给List<? extends Number>，那么现在赋值就会成功了：
List<Integer> iList = new ArrayList<Integer>();
List<? extends Number> nList = iList;
Number n = nList.get(0);
nList.add(0.5); // Not allowed
我们可以从列表中得到Number，因为无论列表的确切元素类型是什么（Float、Integer或Number），我们都可以把它赋值给Number。
我们仍然不能把浮点类型插入列表中。这会在编译时失败，因为我们不能证明这是安全的。如果我们想要向列表中添加浮点类型，它将破坏iList的初始类型安全——它只存储Integer。
通配符给了我们比数组更多的表达能力。
为什么使用通配符
在下面这个例子中，通配符用于向API的用户隐藏类型信息。在内部，Set被存储为CustomerImpl。而API的用户只知道他们正在获取一个Set，从中可以读取Customer。
此处通配符是必需的，因为无法从Set<CustomerImpl>向Set<Customer>赋值：
public class CustomerFactory {
private Set<CustomerImpl> _customers;
public Set<? extends Customer> getCustomers() {
return _customers;
}
}
无界通配符
最后，List<?>列表的内容可以是任何类型，而且它与List<? extends Object>几乎相同。可以随时读取Object，但是不能向列表中写入内容。
公共API中的通配符
总之，正如前面所说，通配符在向调用程序隐藏实现细节方面是非常重要的，但即使下限通配符看起来是提供只读访问，由于remove(int position)之类的非泛型方法，它们也并非如此。如果您想要一个真正不变的集合，可以使用java.util.Collection上的方法，比如unmodifiableList()。
编写API的时候要记得通配符。通常，在传递泛型类型时，应该尝试使用通配符。它使更多的调用程序可以访问API。
通过接收List<? extends Number>而不是List<Number>，下面的方法可以由许多不同类型的列表调用：
void removeNegatives(List<? extends Number> list);
构造泛型类型
现在我们将讨论构造自己的泛型类型。我们将展示一些例子，其中通过使用泛型可以提高类型安全性，我们还将讨论一些实现泛型类型时的常见问题。
集合风格(Collection-like)的函数
第一个泛型类的例子是一个集合风格的例子。Pair有两个类型参数，而且字段是类型的实例：
public final class Pair<A,B> {
public final A first;
public final B second;
public Pair(A first, B second) {
this.first = first;
this.second = second;
}
}
这使从方法返回两个项而无需为每个两种类型的组合编写专用的类成为可能。另一种方法是返回Object[]，而这样是类型不安全或者不整洁的。
在下面的用法中，我们从方法返回一个File和一个Boolean。方法的客户端可以直接使用字段而无需类型强制转换：
public Pair<File,Boolean> getFileAndWriteStatus(String path){
// create file and status
return new Pair<File,Boolean>(file, status);
}
Pair<File,Boolean> result = getFileAndWriteStatus("...");
File f = result.first;
boolean writeable = result.second;
集合之外
在下面这个例子中，泛型被用于附加的编译时安全性。通过把DBFactory类参数化为所创建的Peer类型，您实际上是在强制Factory子类返回一个Peer的特定子类型：
public abstract class DBFactory<T extends DBPeer> {
protected abstract T createEmptyPeer();
public List<T> get(String constraint) {
List<T> peers = new ArrayList<T>();
// database magic
return peers;
}
}
通过实现DBFactory<Customer>，CustomerFactory必须从createEmptyPeer()返回一个Customer：
public class CustomerFactory extends DBFactory<Customer>{
public Customer createEmptyPeer() {
return new Customer();
}
}
泛型方法
不管想要对参数之间还是参数与返回类型之间的泛型类型施加约束，都可以使用泛型方法：
例如，如果编写的反转函数是在位置上反转，那么可能不需要泛型方法。然而，如果希望反转返回一个新的List，那么可能会希望新List的元素类型与传入的List的类型相同。在这种情况下，就需要一个泛型方法：
<T> List<T> reverse(List<T> list)
具体化
当实现一个泛型类时，您可能想要构造一个数组T[]。因为泛型是通过擦除(erasure)实现的，所以这是不允许的。
您可以尝试把Object[]强制转换为T[]。但这是不安全的。
具体化解决方案
按照泛型教程的惯例，解决方案使用的是“类型令牌”，通过向构造函数添加一个Class<T>参数，可以强制客户端为类的类型参数提供正确的类对象：
public class ArrayExample<T> {
private Class<T> clazz;
public ArrayExample(Class<T> clazz) {
this.clazz = clazz;
}
public T[] getArray(int size) {
return (T[])Array.newInstance(clazz, size);
}
}
为了构造ArrayExample<String>，客户端必须把String.class传递给构造函数，因为String.class的类型是Class<String>。
拥有类对象使构造一个具有正确元素类型的数组成为可能。
