共计 6779 个字符,预计需要花费 17 分钟才能阅读完成。
泛型是 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 汇合。
写在最初
泛型是一种非凡的类型,你能够把泛型用在类、接口、办法上,从而实现一些通用算法。
此外,应用泛型有三个步骤:定义类型变量、应用类型变量、确定类型变量。
在确定类型变量这一步中,你能够用泛型通配符来限度泛型的范畴,从而实现一些非凡算法。