一、什么是泛型
泛型，通俗地说将是将类的类型进行参数化，也称为“参数化类型”。原来我们在使用类的时候都是具体指定使用哪一个类，比如：
public class People{
}
public class House{
private People people;
}
我们在上述的代码中，House类中使用的实例变量people是一个具体的类型People，如果我们不指定具体的类型，而是使用如T、E、K、V等形式的参数来指代，那么在真正使用的时候，将可以灵活地将需要的类当做参数来替代这些形式参数：
public class People{
}
public class House<T>{
private T people;
}
如此形式便称为泛型。
二、为什么要使用泛型
使用参数最大的好处就是多态了，多态是Java面向对象编程的重要特性，关于它的详细讲解，可以看我们讲解的另一篇文章《面向对象三大特性的总结》。
还是拿上面的例子来说，如果不使用泛型，那么我们也许要针对不同类型的对象声明好几个类：
public class House1{
private People people;
}
public class House2{
private Dog dog;
}
public class House3{
private Cat cat;
}
- 当我们有people对象，想使用House的时候，就只能使用如上的House1类；
- 当我们有dog对象，想使用House的时候，就只能使用如上的House2类；
- 当我们有cat对象，想使用House的时候，就只能使用如上的House3类；
这些House类仅仅是因为它们包含实例变量的类型不同而已，其它完全一样，显得非常冗余。所以，我们引入了泛型，不管遇到再多的不同种类对象，它们想使用House的时候，从此只要写一个House类了，世界变得更加清净而美好。
三、关于泛型的使用
3.1 泛型类
将泛型使用到类上是非常简单好理解的，我们平时使用的List<T>、Map<K,V>等都是现成的例子，这里就直接看个例子吧。
public class Animal {
}
public class Cat extends Animal {
private String name;
public Cat(String name){
this.name = name;
}
}
public class Dog extends Animal {
private String name;
public Dog(String name){
this.name = name;
}
}
public class House<T> {
private T obj;
public House(T obj){
this.obj = obj;
}
public void printType(){
System.out.println("the type is: " + obj.getClass().getName());
}
}
public class Test {
public static void main(String[] args) {
Cat tom = new Cat("tom");
House<Cat> tomHome = new House<Cat>(tom);
tomHome.printType();// Cat
Dog plutor = new Dog("plutor");
House<Dog> plutorHome = new House<Dog>(plutor);
plutorHome.printType();// Dog
System.out.println(tomHome.getClass().getName());// House
System.out.println(plutorHome.getClass().getName());// House
System.out.println(tomHome.getClass().getName().equals(plutorHome.getClass().getName()));// true
}
}
我们在如上的例子中，将House定义成了一个泛型类，其中的实例对象obj可以是任意类型的对象。
这里值得指出的是，不管泛型类被哪种类型的对象使用，泛型类本身在实际运行的时候都永远都是同一种类。比如House<Cat>和House<Dog>是完全一样的类。但是在编译时，它们会被认为是不同的类，比如House<Cat> tomHome = new new House<Dog>(plutor)就会在编译时期就报错。
3.2 泛型方法
将泛型使用到方法上之后，那么这样的方法就被称为了泛型方法。
-
普通使用
public class Voice { public<E> void makeVoice(E obj){ System.out.println(obj.getClass().getName()); } public<E,T> void eat(E obj1, T obj2){ System.out.println(obj1.getClass().getName()); System.out.println(obj2.getClass().getName()); } }public class Test { public static void main(String[] args) { Voice v = new Voice(); Cat tom = new Cat("tom"); Dog plutor = new Dog("plutor"); v.makeVoice(tom); v.makeVoice(plutor); v.eat(tom, plutor); } }在如上的代码中，我们在一个普通的类中定义了两个泛型方法，它们之间仅仅是传入参数个数的不同而已。
-
继承关系
public class Voice { public<E,T extends E> void drink(E obj1, T obj2){ System.out.println(obj1.getClass().getName()); System.out.println(obj2.getClass().getName()); } }public class Test { public static void main(String[] args) { Voice v = new Voice(); Cat tom = new Cat("tom"); Dog plutor = new Dog("plutor"); //v.drink(tom, plutor); Animal god = new Animal(); v.drink(god, plutor); } }这个例子中，我们限制了泛型方法两个参数对象之间的关系，即第二个参数对象必须是第一个参数对象的子类对象，因此，在实际使用中，
v.drink(tom, plutor);就会出现编译错误，因为plutor不是tom的子类对象。而我们如果使用父类对象
god的话就完全没有问题了。 -
通配符
使用通配符通常也是为了实现方法级别的多态，谁也不想仅仅是因为参数类别的不同而写几个很冗余的方法。
public class Test { public static void main(String[] args) { Cat tom = new Cat("tom"); House<Cat> tomHome = new House<Cat>(tom); Dog plutor = new Dog("plutor"); House<Dog> plutorHome = new House<Dog>(plutor); sleep(tomHome); //sleep(plutorHome); //sleep2(tomHome); sleep2(plutorHome); } public static void sleep(House<Cat> cat){ System.out.println(cat.getClass().getName()); } public static void sleep2(House<Dog> dog){ System.out.println(dog.getClass().getName()); } }可以看到，我们在上面的代码中没有使用泛型，那么仅仅是因为sleep函数中参数对象
House<Cat> cat和House<Dog> dog是不同的编译类型，所以就不得不单独写适合各自类型的方法。如果我们使用泛型的话，那就会变得很简单：
public class Test { public static void main(String[] args) { Cat tom = new Cat("tom"); House<Cat> tomHome = new House<Cat>(tom); Dog plutor = new Dog("plutor"); House<Dog> plutorHome = new House<Dog>(plutor); sleep3(tomHome); sleep3(plutorHome); } public static void sleep3(House<?> obj){ System.out.println(obj.getClass().getName()); } }代码中新的
sleep3方法，不管参数类型是啥，都做了通配处理，尽管来就是了。当然了，你也可以对需要通配的参数对象进行限制：
public class Bird{ private String name; public Bird(String name){ this.name = name; } } public class Test { public static void main(String[] args) { Cat tom = new Cat("tom"); House<Cat> tomHome = new House<Cat>(tom); Dog plutor = new Dog("plutor"); House<Dog> plutorHome = new House<Dog>(plutor); sleep4(tomHome); sleep4(plutorHome); Bird kitty = new Bird("kitty"); House<Bird> kittyHome = new House<Bird>(kitty); //sleep4(kittyHome); } public static void sleep4(House<? extends Animal> obj){ System.out.println(obj.getClass().getName()); } }这里限制了使用泛型方法
sleep4的参数对象House的实例对象必须是Animal类的子类，因此没有继承Animal的Bird当然不在被允许使用范围之内了。
值得注意的是，只有在泛型方法的参数中才可以使用通配符，因为此处有具体的参数对象obj可在下面使用，而在泛型类和泛型方法的声明中是无法使用通配符的，因为后面定义参数类型的时候需要使用该泛型的声明。
四、总结
在实际的编程过程中，我们可以使用泛型去简化开发，且能很好的保证代码质量。
