Java泛型，有效的提高代码的安全性，是时候好好的总结一番。
一、为什么引入泛型
public static void main(String[] args) {
List list = new ArrayList();
list.add("Hello");
list.add("Xidian");
list.add(80);
for(int i=0;i<list.size();i++){
String element = (String) list.get(i);//出现ClassCastException
System.out.println(element);
}
}
集合List默认为Object类型，其并不记忆存储对象的类型，在获取对象时，需要进行显示的强制类型转换，即使预知对象类型信息时，也容易出现Java.Lang.ClassCastException；
是否有方法可以使集合记忆对象类型信息，仅在编译时期正确，运行时便不会出现Java.Lang.ClassCastException?答案是，泛型；
二、小试牛刀
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(80);
list.add(85);
// list.add("Hello"); //编译时期自动报错
for(int j=0;j<list.size();j++){
Integer i = list.get(j);//无需进行类型转换，自动且隐式转换
System.out.println(i);
}
}
- 泛型，即参数化类型，顾名思义是指将类型由原来的具体类型转变为参数类型；
三、类型擦除
public static void main(String[] args) {
List<Integer> listInt = new ArrayList<Integer>();
//List<Integer>与List<Number>不是一种类型
//List<Number> listNum = listInt;
List<Number> listNum = new ArrayList<Number>();
System.out.println(listInt.getClass());
System.out.println(listNum.getClass());
System.out.println(listInt.getClass() == listNum.getClass());
}
//打印结果
class java.util.ArrayList
class java.util.ArrayList
true
Java泛型，仅作用于代码编译阶段，在编译过程中，在正确检查泛型结果后，会将泛型信息擦除，即成功编译后的class文件不包含泛型信息，泛型不进入运行阶段；
泛型类型，逻辑上可以看做不同的类型，实际上为相同的基本类型；
四、类型通配符
public static void main(String[] args) {
List<Integer> listInt = new ArrayList<Integer>();
List<Number> listNum = new ArrayList<Number>();
listInt.add(80);
listNum.add(85);
getData(listNum);
//不能调用getData(List<Number> list)
getData(listInt);
}
public static void getData(List<?> list){
System.out.println(list.get(0));
}
// public static void getData(List<Number> list){
// System.out.println(list.get(0));
// }
//
}
List<Integer>和List<Number>本质上是一种类型，但是不能实现方法调用，我们需要一个在逻辑上可以用来表示同时是List<Integer>和List<Number>的父类的一个引用类型，由此，类型通配符应运而生；
类型通配符一般是使用 ? 代替具体的类型实参。注意，此处是类型实参，而不是类型形参！且List<?>在逻辑上是List<Integer>、List<Number>...等所有List<具体类型实参>的父类；
类型通配符上限List<? extends Number>表示Number及其子类，类型通配符下限List<? super Number>表示Number及其父类；
五、泛型方法
public class Generics {
class Fruit{
@Override
public String toString() {
return "fruit";
}
}
class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}
class Person{
@Override
public String toString() {
return "Person";
}
}
class GenerateTest<T>{
public void show_1(T t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
//由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
public <E> void show_3(E t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
public <T> void show_2(T t){
System.out.println(t.toString());
}
}
public static void main(String[] args) {
Apple apple = new Generics().new Apple();
Person person = new Generics().new Person();
GenerateTest<Fruit> generateTest = new Generics().new GenerateTest<Fruit>();
//apple是Fruit的子类，所以这里可以
generateTest.show_1(apple);
//编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
//generateTest.show_1(person);
//使用这两个方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);
//使用这两个方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
}
}
泛型类、泛型接口使用相对简单，泛型方法难度较大，有很强的迷惑性，在访问权限和返回值间添加<T>表示声明一个泛型方法；
关于其他未涉及到的知识，欢迎参考泛型详解
