泛型是 Java 的一个高级个性。在 Mybatis、Hibernate 这种长久化框架，泛型更是无处不在。
然而，泛型毕竟是高级个性，藏在框架的底层代码外面。咱们平时都是写业务代码，可能素来没见过泛型，更别提怎么用了。
既然如此，咱们就一步步学习泛型吧。
泛型是什么
泛型是一种非凡的类型。你不必一开始就指明参数的具体类型，而是先定义一个类型变量，在应用的时候再确定参数的具体类型。
这如同还是很难了解。没关系，咱们先来看看，在没有泛型状况下，咱们是怎么做的。
比方，在电商零碎中，用户有两种类型，别离是普通用户、商户用户。当用户点击获取信息详情时，零碎要先把一些敏感信息设置为空，像是 password 之类字段，而后才返回给用户。
你能写一个通用办法，把这些敏感字段设置为空吗？
你可能想到了，在 Java 中，所有的类都继承了Object。于是，你写出了第一个版本。
public class ApplicationV1 { // 把敏感字段设置为空 public static Object removeField(Object obj) throws Exception { // 须要过滤的敏感字段 Set<String> fieldSet = new HashSet<String>(); fieldSet.add("password"); // 获取所有字段：而后获取这个类所有字段 Field[] fields = obj.getClass().getDeclaredFields(); // 敏感字段设置为空 for (Field field : fields) { if (fieldSet.contains(field.getName())) { // 凋谢字段操作权限 field.setAccessible(true); // 设置空 field.set(obj, null); } } // 返回对象 return obj; }}在这个办法中，你把Object作为传入参数，而后用反射操作字段，把 password 设置为空。代码零打碎敲，于是你又写出了上面的测试代码。
public class ApplicationV1 { // ...省略局部代码 public static void main(String[] args) throws Exception { // 初始化 ShopUser shopUser = new ShopUser(0L, "shopUser", "123456"); ClientUser clientUser = new ClientUser(0L, "clientUser", "123456"); // 输入原始信息 System.out.println("过滤前："); System.out.println(" " + shopUser); System.out.println(" " + clientUser); // 执行过滤 shopUser = (ShopUser) removeField(shopUser); clientUser = (ClientUser) removeField(clientUser); // 输入过滤后信息 System.out.println("过滤后："); System.out.println(" " + shopUser); System.out.println(" " + clientUser); }}运行后果过滤前： ShopUser{id=0, username='shopUser', password='123456'} ClientUser{id=0, username='clientUser', password='123456'}过滤后： ShopUser{id=null, username='shopUser', password='null'} ClientUser{id=null, username='clientUser', password='null'}运行后果看起来没问题，但很遗憾，这个办法不能用。最不言而喻的问题是，简洁性不够。这个办法要强制转换对象，你看看这两行测试代码：
// 执行过滤 shopUser = (ShopUser) removeField(shopUser); clientUser = (ClientUser) removeField(clientUser);明明是同一个对象，你过滤掉敏感字段后，本人还得再转换一次对象。你想想看，这好歹是一个通用办法，要用在很多中央，当然是越简略越好。
你又想到了，Java 有办法重载机制，你写出了第二个版本。
public class ApplicationV2 { /********************** 业务办法 ************************/ public static ShopUser removeField(ShopUser user) throws Exception { // 强转，并返回对象 return (ShopUser) remove(user); } public static ClientUser removeField(ClientUser user) throws Exception { // 强转，并返回对象 return (ClientUser) remove(user); } /********************** 外围办法 ************************/ // 把敏感字段设置为空 public static Object remove(Object obj) throws Exception { // 须要过滤的敏感字段 Set<String> fieldSet = new HashSet<String>(); fieldSet.add("password"); // 获取所有字段：而后获取这个类所有字段 Field[] fields = obj.getClass().getDeclaredFields(); // 敏感字段设置为空 for (Field field : fields) { if (fieldSet.contains(field.getName())) { // 凋谢字段操作权限 field.setAccessible(true); // 设置空 field.set(obj, null); } } // 返回对象 return obj; }}这样一来，问题如同又解决了。但新问题来了，反复办法特地多，而且如果再加一个供应商用户，我还得再写一个办法吗？这可是通用办法，动不动就改源码，也不是方法呀。
在没有泛型的状况下，反复代码没法解决，你总得做些没意义的操作。要不强转对象，要不就多写几个办法。
然而，Java 的 1.5 版本引入了泛型机制，代码能够变得更加简略。利用泛型，你写出了第三个版本。
public class ApplicationV3 { // 把敏感字段设置为空 public static <T> T removeField(T obj) throws Exception { // 须要过滤的敏感字段 Set<String> fieldSet = new HashSet<String>(); fieldSet.add("password"); // 获取所有字段：而后获取这个类所有字段 Field[] fields = obj.getClass().getDeclaredFields(); // 敏感字段设置为空 for (Field field : fields) { if (fieldSet.contains(field.getName())) { // 凋谢字段操作权限 field.setAccessible(true); // 设置空 field.set(obj, null); } } // 返回对象 return obj; }}在第三个版本中，你应用了泛型，调用办法时不必强转对象了，你也不必在源码写这么多反复办法，代码变得更加简略了。
你再认真看完下面的代码，能够发现，泛型的应用步骤：定义类型变量<T>、应用类型变量T obj、确定类型变量 removeField(new ShopUser(0L, "shopUser", "123456"))这点十分重要，这里先按下不表。
这就是泛型，你不必把参数的类型写死在代码，而是在应用的时候，再确定具体的类型。应用了泛型，你的代码能够变得更简略、平安。
当然，泛型很多的用法，别离是：泛型类及接口、泛型办法、通配符。接下来，咱们就一个个解锁吧~
泛型类
当泛型用在类和接口时，就被称为泛型类、泛型接口。这个最典型的使用就是各种汇合类和接口，比方，List、ArrayList 等等。
那么，咱们泛型怎么用在类下面呢？
首先，定义一个泛型类。
public class IdGen<T> { protected T id; public Generic(T id) { this.id = id; }}IdGen 是一个 id 生成类。第一行代码中，<T> 是泛型标识，代表你定义了一个类型变量 T。第二行代码，我应用这个类型变量，把 id 定义成一个泛型。
而后，在实例化、继承的的时候，指定具体的类型。
public class IdGen<T> { // ..省略局部代码 // 通过继承，确定泛型变量 static class User extends IdGen<Integer> { public User(Integer id) { super(id); } } public static void main(String[] args) { // 通过实例化，确定泛型变量 IdGen idGen = new IdGen<String>("1"); System.out.println(idGen); User user = new User(1); System.out.println(user); }}用户类继承了 IdGen，在代码extends IdGen<Integer>中，指定了 Integer 作为 id 的具体类型；而 IdGen 实例化的时候，在代码new IdGen<String>("1")中，则指定了 String 作为 id 的具体类型。
泛型办法
泛型不仅能用在类和接口上，还能够用在办法上。
比方，怎么把一个类的成员变量转换成 Map 汇合呢？
这时候，咱们能够写一个泛型办法。
public class Generic { public static <T> Map obj2Map(T obj) throws Exception { Map map = new HashMap<>(); // 获取所有字段：通过 getClass() 办法获取 Class 对象，而后获取这个类所有字段 Field[] fields = obj.getClass().getDeclaredFields(); for (Field field : fields) { // 凋谢字段操作权限 field.setAccessible(true); // 设置值 map.put(field.getName(), field.get(obj)); } return map; }}同样的，<T> 是泛型标识，代表你定义了一个类型变量 T，用在这个办法上。T obj 应用类型变量 T，定义一个 obj 参数。最初，在调用办法的的时候，再确定具体的类型。
泛型通配符
泛型通配符用 ? 示意，代表不确定的类型，是泛型的一个重要组成。
有一点很多文章都没提到，大家肯定要记住！！！
应用泛型有三个步骤：定义类型变量、应用类型变量、确定类型变量。在第三步，确定类型变量的时候，如果你没法明确类型变量，这时候能够用泛型通配符。
个别状况下，咱们不须要用到泛型通配符，因为你能明确地晓得类型变量，你看上面代码。
public class Application { public static Integer count(List<Integer> list) { int total = 0; for (Integer number : list) { total += number; } list.add(total); return total; } public static void main(String[] args) { // 不传指定数据，编译报错 List<String> strList = Arrays.asList("0", "1", "2"); int totalNum = count(strList); // 绕过了编译，运行报错 List strList1 = Arrays.asList("0", "1", "2"); totalNum = count(strList1); }}你十分分明 count() 办法是干什么的，所以你在写代码的时候，间接就能指明这是一个 Integer 汇合。这样一来，在调用办法的时候，如果不传指定的数据进来，就没法通过编译。退一万步讲，即便你绕过了编译这一关，程序也很可能没法运行。
所以，如果你十分分明本人要干什么，能够很明确地晓得类型变量，那没必要用泛型通配符。
然而，在一些通用办法中，什么类型的数据都能传进来，你没法确认类型变量，这时候该怎么办呢？
你能够应用泛型通配符，这样就不必确认类型变量，从而实现一些通用算法。
比方，你要写一个通用办法，把传入的 List 汇合输入到控制台，那么就能够这样做。
public class Application { public static void print(List<?> list) { for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } public static void main(String[] args) { // Integer 汇合，能够运行 List<Integer> intList = Arrays.asList(0, 1, 2); print(intList); // String 汇合，能够运行 List<String> strList = Arrays.asList("0", "1", "2"); print(strList); }}List<?> list 代表我不确定 List 汇合装的是什么类型，有可能是 Integer，有可能是 String，还可能是别的货色。但我不论这些，你只有传一个 List 汇合进来，这个办法就能失常运行。
这就是泛型通配符。此外，有些算法尽管也是通用的，但适用范围不那么大。比方，用户分为：普通用户、商家用户，但用户有一些非凡性能，其它角色都没有。这时候，又该怎么办呢？
你能够给泛型通配符设定边界，以此限定类型变量的范畴。
泛型通配符的上边界
上边界，代表类型变量的范畴无限，只能传入某种类型，或者它的子类。你看下这幅图就明确了。
利用 <? extends 类名> 的形式，能够设定泛型通配符的上边界。你看下这个例子就明确了。
public class TopLine { public static void print(List<? extends Number> list) { for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } public static void main(String[] args) { // Integer 是 Number 的子类，能够调用 print 办法 print(new ArrayList<Integer>()); // String 不是 Number 的子类，没法调用 print 办法 print(new ArrayList<String>()); }}你想调用 print() 办法中，那么你能够传入 Integer 汇合，因为 Integer 是 Number 的子类。但 String 不是 Number 的子类，所以你没法传入 String 汇合。
泛型通配符的下边界
下边界，代表类型变量的范畴无限，只能传入某种类型，或者它的父类。你看下这幅图就明确了。
利用 <? super 类名> 的形式，能够设定泛型通配符的上边界。你看下这个例子就明确了。
public class LowLine { public static void print(List<? super Integer> list) { for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } public static void main(String[] args) { // Number 是 Integer 的父类，能够调用 print 办法 print(new ArrayList<Number>()); // Long 不是 Integer 的父类，没法调用 print 办法 // print(new ArrayList<String>()); }}你想调用 print() 办法中，那么能够传入 Number 汇合，因为 Number 是 Integer 的父类。但 Long 不是 Integer 的父类，所以你没法传入 Long 汇合。
写在最初
泛型是一种非凡的类型，你能够把泛型用在类、接口、办法上，从而实现一些通用算法。
此外，应用泛型有三个步骤：定义类型变量、应用类型变量、确定类型变量。
在确定类型变量这一步中，你能够用泛型通配符来限度泛型的范畴，从而实现一些非凡算法。