定义
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
参考：Java 泛型
使用
For example
List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(111 + "");
for (int i = 0; i < arrayList.size(); i++) {
String item = (String) arrayList.get(i);
System.out.printf("泛型测试" + "item = " + item + "\n");
}
上面的代码执行会有问题吗？
如果将上面的代码修改为:
List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(111 + "");
for (int i = 0; i < arrayList.size(); i++) {
String item = (String) arrayList.get(i);
System.out.printf("泛型测试" + "item = " + item + "\n");
}
可以查看List的Add函数：
boolean add(E e);
可以看出来，肃然ArrayList可以放任意类型，例子中出现问题，因为添加了一个String后又添加了一个Integer，在到实际取出数据时，并不能准确的知道他是什么类型，导致类型转换失败。
如果代码修改成如下，在编译期就会出现报错提示：
List arrayList = new ArrayList<String>();
arrayList.add("aaaa");
arrayList.add(111);
for (int i = 0; i < arrayList.size(); i++) {
String item = (String) arrayList.get(i);
System.out.printf("泛型测试" + "item = " + item + "\n");
}
其中new ArrayList<String>() 就是泛型的使用
类
类结构是面向对象中最基本的元素，如果我们的类需要有很好的扩展性，那么我们可以将其设置成泛型的。
public class Test<T> {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
使用方式：
Test t = new Test<String>();
方法
泛型方法既可以存在于泛型类中，也可以存在于普通的类中。如果使用泛型方法可以解决问题，那么应该尽量使用泛型方法。
public class Test<T> {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
/**
* 泛型方法
* @param e
*/
public <E> void PrinterInfo(E e) {
System.out.println(e);
}
}
执行：
Test t = new Test<String>();
t.printerInfo("我是字符串");
t.printerInfo(11111);
t.printerInfo(99.9F);
接口
Java泛型接口的定义和Java泛型类基本相同。
public interface Generator<T> {
T next();
}
实现接口
public class TestGenerator<T> implements Generator<String> {
public T getClass(Class clazz) {
T t = null;
try {
t = (T) clazz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return t;
}
@Override
public String next() {
return null;
}
}
泛型擦除
Class<?> class1=new ArrayList<String>().getClass();
Class<?> class2=new ArrayList<Integer>().getClass();
System.out.println(class1);
System.out.println(class2);
System.out.println(class1.equals(class2));
class Table {}
class Room {}
class House<Q> {}
class Particle<POSITION, MOMENTUM> {}
List<Table> tableList = new ArrayList<Table>();
Map<Room, Table> maps = new HashMap<Room, Table>();
House<Room> house = new House<Room>();
Particle<Long, Double> particle = new Particle<Long, Double>();
System.out.println(Arrays.toString(tableList.getClass().getTypeParameters()));
System.out.println(Arrays.toString(maps.getClass().getTypeParameters()));
System.out.println(Arrays.toString(house.getClass().getTypeParameters()));
System.out.println(Arrays.toString(particle.getClass().getTypeParameters()));
上面的代码里，我们想在运行时获取类的类型参数，但是我们看到返回的都是“形参”。在运行期我们是获取不到任何已经声明的类型信息的。
编译器虽然会在编译过程中移除参数的类型信息，但是会保证类或方法内部参数类型的一致性。
泛型参数将会被擦除到它的第一个边界:
public class BaseModel {
String name = "sssss";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class MyClass<T extends BaseModel> {
T t;
public T getObj() {
return t;
}
public void setObj(T t) {
this.t = t;
}
}
extend关键字后后面的类型信息决定了泛型参数能保留的信息。Java类型擦除只会擦除到BaseModel类型。
创建类型实例
T t = new T();
上面的代码可以执行吗？
泛型代码中不能new T()的原因有两个，一是因为擦除，不能确定类型；而是无法确定T是否包含无参构造函数。
public interface Factory<T> {
T create();
}
public class Creater<T> {
T instance;
public <F extends Factory<T>> T newInstance(F f) {
instance = f.create();
return instance;
}
}
public class IntegerFactory implements Factory<Integer> {
@Override
public Integer create() {
Integer integer = new Integer(9);
return integer;
}
}
我们通过工厂模式+泛型方法来创建实例对象，调用入下：
Creater<Integer> creater=new Creater<>();
System.out.println(creater.newInstance(new IntegerFactory()));
应用场景
open-api
