本文只是做为泛型的入门和基础的泛型的了解。
什么是泛型？
泛型(generices)是JDK5引入的新特性,这个特性主要是为了创建容器类，这也是泛型出现的重要原因之一。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。声明的类型参数在使用时用具体的类型来替换。
1 泛型类
例如我们有一个容器类Container，我们希望，这个容器可以装一个String类型的变量。代码如下：
public class Container {
private String obj;
public String getObj() {
return obj;
}
public void setObj(String obj) {
this.obj = obj;
}
}
那么我们可以这么使用这个容器类，例如：
Container container = new Container();
container.setObj("container str.");
//会输出"container str."
System.out.println(container.getObj());
那，如果我们想在Container里面装入int类型的话。这个类是不适用的，因为它只有1个String类型的变量obj。那就需要另外声明一个Container类，然后里面包含一个int类型的变量。机智的你应该可以想到可以将Container的obj对象改成Object类型。这样就可以存入任何的对象了， 因为Object是所有对象的基类。代码如下：
public class ContainerObj {
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
这时候，我们就可以使用ContainerObj来存入任何类型了，只是取出来使用的时候需要进行一下转换。例如：
ContainerObj containerObj = new ContainerObj();
containerObj.setObj("contailObj str");
//会输出"contailObj str"
System.out.println(containerObj.getObj());
containerObj.setObj(1);
//会输出1
int i = (Integer) containerObj.getObj();
System.out.println(i);
这样子做回有一些缺点，例如，要记住存进去的是什么类型，不然取出来的时候，转换的类型不对的话就会发生异常。
这时候，我们使用泛型就可以达到既可以不限定类型，又可以取的时候不用转换。例如下面这个类：
public class ContainerGeneric<T> {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
//调用
//=======使用泛型的类
ContainerGeneric<Integer> containerInt = new ContainerGeneric<>();
containerInt.setObj(10);
//会输出 10
System.out.println(containerInt.getObj());
ContainerGeneric<String> containerStr = new ContainerGeneric<>();
containerStr.setObj("container str");
//会输出"container str"
System.out.println(containerStr.getObj());
2 泛型接口
泛型接口和泛型类的使用方式差不多，下面看个简单的例子：
public interface IContainer<T> {
T getObj();
}
//需要在实现这个接口的时候,指定类型为String
public class ContainerImpl implements IContainer<String> {
//所以重写getObj方法的时候,需要返回的是String类型
@Override
public String getObj() {
return "invoke getObj ..";
}
}
//=======使用泛型接口
IContainer iContainer = new ContainerImpl();
//会输出"invoke getObj .."
System.out.println(iContainer.getObj());
3 泛型方法
泛型方法，是在调用方法的时候指明泛型的具体类型。允许将在一个方法使用泛型，而不必整个类使用泛型。在方法返回值之前放上泛型标识<T>就可以了。可以在普通的方法使用泛型，也可以在静态方法使用泛型，还可以在泛型方法里面使用泛型参数。如下例子：
public class GenericMethod {
//泛型方法
public <T> void outTest(){
System.out.println("outTest is invoke..");
}
//泛型参数
public <T> void outTest(T t, Integer i){
System.out.println("t = ,"+t+"i="+i);
}
//静态泛型方法
public static <T> void staticOutTest(){
System.out.println("staticOutTest is invoke..");
}
public static void main(String[] args) {
GenericMethod genericMethod = new GenericMethod();
genericMethod.outTest();//输出"outTest is invoke.."
genericMethod.outTest("str",1);//输出"t = ,stri=1"
staticOutTest();//输出"staticOutTest is invoke.."
}
}
4 边界符
使用泛型方法的过程中，往往会需要限定方法的参数的类型，而不至于可以传入任意类型而造成混乱。
例如，我们需要写一个方法，判断一个对象是否正数。泛型方法可以这么写。
//判断一个数是否正数
public static <T> boolean isPositive (T t){
System.out.println(t);
if(t instanceof Integer)
return Integer.parseInt(t.toString()) > 0;
else if(t instanceof Double)
return Double.parseDouble(t.toString()) > 0;
//还需要判断 Float , Byte , Short , Long 类型
else
return false;
}
//调用：
System.out.println(isPositive(1));// 输出 1 true
System.out.println(isPositive(0.1d));// 输出 0.1 true
System.out.println(isPositive("aa"));// 输出 aa false
因为isPositive方法的参数T是泛型，所以调用的时候可以传入任意类型。所以在写方法的时候需要进行所有数字类型的判断。如果可以限定参数T是数字类型的话，就可以减少很多麻烦和避免程序混乱。这时候可以使用边界符，边界符的作用是，限定泛型参数T的类型。使用如下：
//使用边界符 判断一个数是否正数
public static <T extends Number> boolean isPositiveBunder (T t){
System.out.println(t);
return t.floatValue()>0;
}
//调用：
System.out.println(isPositiveBunder(1));//输出 1 true
System.out.println(isPositiveBunder(0.1d));// 输出 0.1 true
// System.out.println(isPositiveBunder("aa")); 编译失败，已经限定了T只能是实现Number抽象类的类
因为使用了边界符限定了方法isPositiveBunder的参数T必须是实现了抽象类Number的类型，所以调用的时候，只能传入实现了Number类的类型。String没有继承或者实现Number类型，所以不能通过编译。由于知道参数 t 一定是实现了Number类，所以可以直接使用 Number类的 floatValue 方法来取值进行判断。
5 通配符
我们知道，通过继承，可以实现实例化一个子类赋值给父类或接口。例如：
Number num = new Integer(1);
Integer 类实现了继承了Number这个抽象类。public final class Integer extends Number 。
但是，使用泛型的时候指定的泛型类并没有这个继承的关系，例如
// List<Number> numberList = new ArrayList<Integer>();编译不通过
泛型类ContainerGeneric的参数是Number ，而实例化的时候，指定的参数是 Integer类型。这是不能通过编译的。使用泛型的时候，默认是没有父类子类这样的继承关系的。但是可以使用通配符，来将子类和父类关联起来。例如：
//使用通配符，将泛型参数中的继承关系关联起来
List<? extends Number> numbers = new ArrayList<Integer>();
<? extends Number>表明可以接受的泛型参数可以是继承Number类的子类。Integer继承了Number类。所以可以这么写，并且在泛型中将继承关系关联起来了。
6 PECS原则
如果我们想往numbers添加元素会怎么样?
//编译不通过,不能往numbers集合里面添加元素，只能读取元素
// numbers.add(1);
// numbers.add(2);
为什么不能编译通过呢？我们可以分析一下
使用通配符的时候我们可以将numbers理解为：
List<? extends Number> numbers = new ArrayList<Integer>();
List<? extends Number> numbers = new ArrayList<Double>();
List<? extends Number> numbers = new ArrayList<Float>();
List<? extends Number> numbers = new ArrayList<Long>();
List<? extends Number> numbers = new ArrayList<Short>();
List<? extends Number> numbers = new ArrayList<Byte>();
numbers并不能确定它实际上的类型是什么类型，如果你往numbers添加一个int 元素. 但是可能numbers实际上可能装载的是Double元素。所以不能往实现了<? extends T>的类里面添加元素，只能读取元素。
如果我们确实需要添加元素怎么办呢？可以使用<? super T >。表明，参数类一定是T的父类，T一定是参数类的子类。如下例子：
List<? super Integer> numberIntList= new ArrayList<Number>();
// List<? super Number> numberList = new ArrayList<Integer>();编译不通过，Number不是Integer的子类
numberIntList.add(10);//可以通过编译
可以往实现了<? super T >的类添加元素，但是不能获取元素。为什么呢？我们一样可以分析一下。同样的，使用了spuer关键字的通配符，我们可以理解为，"？" 一定匹配的是Integer类的父类或者自己本类型。
List<? super Integer> numberIntList= new ArrayList<Integer>();
List<? super Integer> numberIntList= new ArrayList<Number>();
List<? super Integer> numberIntList= new ArrayList<Object>();
如果我们添加元素的话，可以添加Integer类型，或者Number类型，或者Object类型。但是取的时候，编译器并不能判断取出来的是什么类型。有可能是Integer，有可能是Number，有可能是Object类型。所以我们无法取出元素。
根据上面的例子，我们可以总结出一条规律源钻，”Producer Extends, Consumer Super”（PECS）：
“Producer Extends” - 如果你需要一个只读List，用它来produce T，那么使用? extends T。
“Consumer Super” - 如果你需要一个只写List，用它来consume T，那么使用? super T。
如果需要同时读取以及写入，那么我们就不能使用通配符了。
