1.泛型的概念：
泛型是Java SE 1.5的新特性，泛型的本质参数化类型，即所操作的数据类型被指定为一个参数。
2.使用泛型的优点：
（1）安全简单，提高代码重用率，在编译的时候检查类型安全，并且所有的强制类型转化都是自动和隐式的；
（2）类型安全，向后兼容，层次清晰，性能较高。
3.元组类库（出处：《Thinking Java》）
（1）定义：元组指将一对对象直接打包存储于其中的一个单一对象，这个容器对象允许读取其中元素，但不允许向其中放入新的对象；
（2）元组可以具有任意长度，元组中的对象可以是任意不同类型。
例：
//一个1维元组，它持有1个对象
class OneTuple<A> {
//code
}
//一个2维元组，它持有两个对象
class TwoTuple<A,B> {
//code
}4.定义简单泛型
（1）泛型类：具有一个或多个类型变量的类
public class Pair<T> {
private T first;
private T second;
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return this.first;
}
public void setFirst(T newValue) {
this.first = newValue;
}
}（2）泛型方法：
例：
//普通泛型方法
public class ArrayAlg {
//...表示可变参数
public <T> T getMiddle(T... a) {
return a[a.length/2];
}
}
//集合泛型方法
class ArrayListTest {
public <T> List<T> list() {
return new ArrayList<T>();
}
}（3）泛型接口
例：
public interface Generator<T> {
T next();
}（4）泛型应用于匿名内部类
例：
public class Customer {
public Generator<Customer> clerk() {
return new Generator<Customer>() {
@Override
public Customer next() {
return new Customer();
}
};
}
}5.泛型的擦除
（1）定义;
java字节码中不包含有泛型的类型信息。编译器在编译阶段去掉泛型信息，在运行的时候加上类型信息。
（2）不同类型的擦除
例：
public class ErasedTypeEquairalence{
public static void main(String[] args) {
Class c1 = new ArrayList<String>().getClass();
Class c2 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2);
}
}
//输出结果： true（3）重载中的类型擦除
例：
class HoldItem <T,V>{
public void f(List<T> t) {} // error 编译器报错
public void f(List<V> v) {}
public void f(List<T> t,List<V> v) {}
}6.泛型的边界
（1）限定类型：< T extends Comparable & Serializable>
由于泛型有擦除行为，所以只能调用Object的toString( ),equals( ),hashCode( )……方法，但若加上限制，
例：< T extends Dog> 就可以使用Dog类中的方法了。
（2）自限定类型： < T extends Access < T >>
若定义一个类F
class F extends Access< u > { }
这个U必须是Access的子类（即：u必须与Access有关）
7.通配符
（1）有限制的通配符
List < ? extends Fruit> 子类型通配符
List < ? super class> 超类型通配符
*生产者消费者模型
助记符：PESC (produce - extends consumer - super)
- 如果想从列表中读取T类型的元素，则需要将这个列表声明成< ? extends T>，之后就不能往该列表中添加任何元素。
- 如果想把T类型的元素加入到列表中，则需要把这个列表声明成< ? super T>，之后就不能从中读取元素。
- 如果一个列表即要生产，又要消费，你不能使用泛型通配符声明列表，比如List < Integer >。
例：
public <T extends Dog> void get1(List<T extends Dog> list){
list.get(0);
}
//error
public <T extends Dog> void set1(List<T extends Dog> list, Dog dog){
list.add(dog);
}
//error
public <T super Cat> void get2(List<T super Cat> list){
list.get(0);
}
public <T super Cat> void set2(List<T super Cat> list, Cat cat){
list.add(cat);
}例2：Collections类的copy方法就是典型的PECS模型，下面是copy方法的源码
/**
* Copies all of the elements from one list into another. After the
* operation, the index of each copied element in the destination list
* will be identical to its index in the source list. The destination
* list must be at least as long as the source list. If it is longer, the
* remaining elements in the destination list are unaffected. <p>
*
* This method runs in linear time.
*
* @param <T> the class of the objects in the lists
* @param dest The destination list.
* @param src The source list.
* @throws IndexOutOfBoundsException if the destination list is too small
* to contain the entire source List.
* @throws UnsupportedOperationException if the destination list's
* list-iterator does not support the <tt>set</tt> operation.
*/
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
int srcSize = src.size();
if (srcSize > dest.size())
throw new IndexOutOfBoundsException("Source does not fit in dest");
if (srcSize < COPY_THRESHOLD ||
(src instanceof RandomAccess && dest instanceof RandomAccess)) {
for (int i=0; i<srcSize; i++)
dest.set(i, src.get(i));
} else {
ListIterator<? super T> di=dest.listIterator();
ListIterator<? extends T> si=src.listIterator();
for (int i=0; i<srcSize; i++) {
di.next();
di.set(si.next());
}
}
}（2）无界通配符 < ? >
8.约束与局限性
（1）不能用基本数据类型实例化类型参数
（2）运行时类型查询只适用于原始类型
（3）不能创建参数化类型的数组
例：
Pair<String>[] table = new Pair<String> [10]; //error解决方法：
*使用ArrayList< Pair < String > >
*使用工具类 Arrays.asList()
（4）Varargs警告
抑制警告：@SuppressWarnings（“unchecked”） 或 safe Varargs
（5）不能实例化类型变量
（6）泛型类的静态上下文中类型变量无效
（7）不能抛出或捕获泛型类的实例
（8）防范擦除后的冲突
本人才疏学浅，如有错误，请指出~
谢谢！
