1泛型语法：
泛型类： class ClassName<T>{}
泛型方法：public <T> void f(T x){}
基本指导原则：如果使用泛型方法可以取代将整个类泛型化，那么就应该使用泛型方法，因为它可以让事情更加清楚。
2为什么使用泛型？
在Java SE1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是：
（1）在编译时检查类型安全；
（2）并且所有的强制转换都是自动和隐式的，提高代码的重用率。
促成泛型出现最引人注目的一个原因就是为了创造容器类。
优先考虑泛型!!!
使用泛型比使用需要在客户端代码中进行转换的类型来的更加安全，也更加容易。
在设计新类型的时候，要确保它们不需要这种转换就可以使用。这通常意味着要把类做成是泛型的。
比如
客户端代码使用Stack的时候，如果不使用泛型，在取用Stack中的对象时还需要进行不安全的类型判断，类型转换等，而且代码还比较复杂。如果使用带泛型的Stack，客户端代码中就不需要进行类型转换了，直接使用而且不会复杂。
3泛型数组：
无法创建泛型数组，一般的解决方式是在任何想要使用泛型数组的地方使用ArrayList。
-
public <T> voidtest() -
{ -
//Cannotcreate a generic array of T -
T[]tList = new T[10]; -
int[]iList = new int[10]; -
//useArrayList<T> -
ArrayList<T>sList = new ArrayList<T>();
4不可协变：
（1）数组和泛型对比
数组是可协变的、泛型是不可协变的。
什么是可协变性？举个例子说明：
数组可协变(covariant)是指如果类Base是类Sub的基类，那么Base[]就是Sub[]的基类。
泛型不可变的(invariant)是指List<Base>不会是List<Sub>的基类，两者压根没关系。
（2）泛型为什么不可协变
泛型“编译时进行类型检查（类型安全）”特性决定了其不可协变。
| ArrayList<Object> objList = new ArrayList<Long>(); |
//can't compile pass |
类型安全检查 |
| Object[] objArray = new Long[10]; |
//compile OK |
如果ArrayList<Long>类型对象可以赋值给ArrayList<Object>类型引用，那么就违反了泛型类型安全的原则。
因为如果编译器你这样做，会导致可以往容器中放置非Long型的对象。但是数组就无所谓，他不是类型安全的。
再看看下面代码，第一行编译错误是因为不可协变性，那么为什么第二行可以呢？
| List<Type> listt = new ArrayList<SubType>(); |
//can't compile pass |
|
| List<? extends Type> listt = new ArrayList<SubType>(); |
//OK |
参考泛型通配符，这就是其作用 |
不可协变并不代表不能在泛型代码中将父类出现的地方使用子类代替，如下面代码是合法的：
| ArrayList<Type> list = new ArrayList<Type>(); |
//Type is SuperClass |
| list.add(new SubType()); |
//SubType is SubClass |
| Type[] tt = new Type[3]; |
tt[0] = new SubType(); |
（3）数组可协变带来的问题：
数组的协变性可能会导致一些错误，比如下面的代码：
-
public static voidmain(String[] args) { -
Object[] array = new String[10]; -
array[0] = 10; -
}
它是可以编译通过的，因为数组是协变的，Object[]类型的引用可以指向一个String[]类型的对象。但是运行的时候是会报出如下异常的：
Exception in thread"main" java.lang.ArrayStoreException: java.lang.Integer
但是对于泛型就不会出现这种情况了：
-
public static voidmain(String[] args) { -
List< Object> list = newArrayList< String>(); -
list.add(10); -
}
这段代码连编译都不能通过。
5通配符：
通配符在类型系统中的作用部分来自其不会发生协变（covariant）这一特性。即通配符产生一部分原因来自突破不可协变的限制。
可以认为通配符使得List<?>是List<AnyType>的基类，List<? extends Type>是List<SubType>的基类。
-
// collection1可以存放任何类型 -
Collection<?>collection1 = new ArrayList<String>(); -
collection1 = newArrayList<Integer>(); -
collection1 = newArrayList<Object>(); -
//collection3表示它可以存放Number或Number的子类 -
Collection<?extends Number> collection3 = null; -
collection3 = newArrayList<Number>(); -
collection3 = newArrayList<Double>(); -
collection3 = newArrayList<Long>(); -
//collection4表示它可以存放Integer或Integer的父类 -
Collection<? superInteger> collection4 = null; -
collection4 = newArrayList<Object>();
T 有类型
? 未知类型
既然知道List<Cat>并不是List<Anilmal>的子类型，那就需要去寻找替他解决的办法， 是AnimalTrianer.act()方法变得更为通用（既可以接受List<Animal>类型，也可以接受List<Cat>等参数）。在java里解决办法就是使用通配符“？”，具体到AnimalTrianer,就是将方法改为act(List<？ extends Animal> list),当中“？”就是通配符，而“？ extends Animal”则表示通配符“？”的上界为Animal，换句话说就是，“？ extends Animal”可以代表Animal或其子类，可代表不了Animal的父类（如Object），因为通配符的上界是Animal。如下，为改进之后的AnimalTrianer
public class AnimalTrainer {
public void act(List<? extends Animal> list) {
for (Animal animal : list) {
animal.eat();
}
}
}
再来测试一下，如下，发现Test 2 可以通过编译了：
public class TestAnimal {
public static void main(String[] args) {
AnimalTrainer animalTrainer = new AnimalTrainer();
//Test 1
List<Animal> animalList = new ArrayList<>();
animalList.add(new Cat("cat1"));
animalList.add(new Bird("bird1"));
animalTrainer.act(animalList); //可以通过编译
//Test 2
List<Cat> catList = new ArrayList<>();
catList.add(new Cat("cat2"));
catList.add(new Cat("cat3"));
animalTrainer.act(catList); //也可以通过编译
}
}
经过上述分析，可以知道List<Animal>和List<Cat>都是List<? extends Animal>的子类型，类似有List<Bird>,List<Magpie>也是List<? extends Animal>的子类型。
现总结如下，对于通配符的上界，有以下几条基本规则：（假设给定的泛型类型为G，(如List<E>中的List),两个具体的泛型参数X、Y，当中Y是X的子类（如上的Animal和Cat））
- G<? extends Y> 是 G<? extends X>的子类型（如List<? extends Cat> 是 List<? extends Animal>的子类型）。
- G<X> 是 G<? extends X>的子类型（如List<Animal> 是 List<? extends Animal>的子类型）
- G<?> 与 G<? extends Object>等同，如List<?> 与List<? extends Objext>等同。
学到这里，可能会遇到一些疑惑的地方，或者说事理解不透的地方，先观察如下两段代码片段，判断一下其是否可行？？
public void testAdd(List<? extends Animal> list){
//....其他逻辑
list.add(new Animal("animal"));
list.add(new Bird("bird"));
list.add(new Cat("cat"));
}
List<? extends Animal> list = new ArrayList<>();
list.add(new Animal("animal"));
list.add(new Bird("bird"));
list.add(new Cat("cat"));
先分析如下：因为“？ extends Animal”可代表Animal或其子类（Bird，Cat），那上面的操作应该是可行的。事实上是”不行“，即无法通过编译。为什么呢？？
在解释之前，再来重新强调一下已经知道的规则：在List<Aimal> list里只能添加Animal类对象及其子类对象（如Cat和Bird对象），在List<Bird>里只能添加Bird类和其子类对象（如Magpie），可不能添加Animal对象（不是Bird的子类），类似的在List<Cat>和List<Magpie>里只能添加Cat和Bird对象（或其子类对象，不过这没有列出）。现在再回头看一下testAdd（）方法，我们知道List<Animal>、List<Cat等都是List<？ extends Animal>的子类型。先假设传入的参数为为List<Animal>,则第一段代码的三个“add”操作都是可行的；可如果是List<Bird>呢？？则只有第二个“add”可以执行；再假设传入的是List<Tiger>（Tiger是想象出来的，可认为是Cat的子类），则三个“add”操作都不能执行。
现在反过来说，给testAdd传入不同的参数，三个“add”操作都可能引发类型不兼容问题，而传入的参数是未知的，所以java为了保护其类型一致，禁止向List<? extends Animal>添加任意对象，不过却可以添加null，即list.add(null)是可行的。有了上面谈到的基础，再来理解第二段代码就不难了，因为List<? extends Animal>的类型“？ extends Animal”无法确定，可以是Animal，Bird或者Cat等，所以为了保护其类型的一致性，也是不能往list添加任意对象的，不过却可以添加null。
先总结如下：不能往List<? extends Animal> 添加任意对象，除了null。
另外提醒大家注意的一点是，在List<? extends Animal> 可以是Animal类对象或Bird对象等（只是某一类对象），反过来说，在List<? extends Animal> list里的都是Animal对象，即Bird也是Animal对象，Cat也是Animal对象（用java的语言来说就是子类可以指向父类，父类却不能指向子类），那么在Animal里的所有方法都是可以调用的，如下：
for (Animal animal : list) { animal.eat(); }
既然有了通配符的上界，自然有着通配符的下界。可以如此定义通配符的下界 List<? super Bird>，其中”Bird“就是通配符的下界。注意：不能同时声明泛型通配符申明上界和下界。
在谈注意细节之前，我们先看一下通配符的使用规则——对于通配符的上界，有以下几条基本规则：（假设给定的泛型类型为G，(如List<E>中的List),两个具体的泛型参数X、Y，当中Y是X的子类（如上的Animal和Cat））
- G<? super X> 是 G<? super Y>的子类型（如List<? super Animal> 是 List<? super Bird>的子类型）。
- G<X> 是 G<? super X>的子类型（如List<Animal> 是 List<? super Animal>的子类型）
现在再来看如下代码，判断其是否符合逻辑：
public void testAdd(List<? super Bird> list){
list.add(new Bird("bird"));
list.add(new Magpie("magpie"));
}
List<? super Bird> list = new ArrayList<>();
list.add(new Bird("bird"));
list.add(new Magpie("magpie"));
list.add(new Animal("animal"));
看第一段代码，其分析如下，因为”? super Bird”代表了Bird或其父类，而Magpie是Bird的子类，所以上诉代码不可通过编译。而事实上是”行“，为什么呢？2？
在解疑之前，再来强调一个知识点，子类可以指向父类，即Bird也是Animal对象。现在考虑传入到testAdd（）的所有可能的参数，可以是List<Bird>,List<Animal>,或者List<Objext>等等，发现这些参数的类型是Bird或其父类，那我们可以这样看，把bird、magpie看成Bird对象，也可以将bird、magpie看成Animal对象，类似的可看成Object对象，最后发现这些添加到List<? supe Bird> list里的对象都是同一类对象（如本文刚开篇提到的Test 1），因此testAdd方法是符合逻辑，可以通过编译的。：
现在再来看一下第二段代码对于，第二、三行代码的解释和上文一样，至于最后一行“list.add(newAnimal("animal"))”是无法通过编译的，为什么的？？为了保护类型的一致性，因为“？ super Bird”可以是Animal，也可以是Object或其他Bird的父类，因无法确定其类型，也就不能往List<? super Bird>添加Bird的任意父类对象。
既然无法确定其父类对象，那该如何遍历List<? super Bird> ? 因为Object是所有类的根类,所以可以用Object来遍历。如下，不过貌似其意义不大。
for (Object object : list) {//...}
那“？ super BoundingType”可以应用在什么地方呢？？“？ super BoundingType”应用相对广泛，只不过是混合着用。下面举个简单的例子。先假设有以下两个Student和CollegeStudent，当中CollegeStudent继承Student，如下：
public class Student implements Comparable<Student>{
private int id;
public Student(int id) {
this.id = id;
}
@Override
public int compareTo(Student o) {
return (id > o.id) ? 1 : ((id < o.id) ? -1 : 0);
}
}
public class CollegeStudent extends Student{
public CollegeStudent(int id) {
super(id);
}
}
先需要根据他们的id对他们进行排序（注意此处是对数组对象进行排序），设计方法如下，（n指数组元素的个数）：
public static <T extends Comparable<? super T>> void selectionSort(T[] a,int n)
先理解此方法含义，首先<T extends Comparable<T>>规定了数组中对象必须实现Comparable接口，Comparable<? Super T>表示如果父类实现Comparable接口，其自身可不实现，如CollegeStudent。先假设有一个CollegeStudent的数组，如下：
CollegeStudent[] stu = new CollegeStudent[]{
new CollegeStudent(3),new CollegeStudent(2),
new CollegeStudent(5),new CollegeStudent(4)};
执行方法 selectionSort(stu,4)是完全可以通过的。可如果定义的selectionSort方法如下：
public static <T extends Comparable<T>> void selectionSort(T[] a,int n)
则方法selectionSort(stu,4)不能执行,因为CollegeStudent没有实现Comparable<CollegeStudent>接口。换句话就是“？ super T”使selectionSort方法变得更为通用了。selectionSort完整代码的实现可参考本文的末尾。