一看就懂 详解JAVA泛型通配符T,E,K,V区别
1. 先解释下泛型概念
泛型是java se 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。java语言引入泛型的好处是安全简单。
在java se 1.5之前,没有泛型的情况的下,通过对类型object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,以提高代码的重用率。
举个栗子:
box类定义为一个泛型类
public class box<t> { private t object; public void set(t object) { this.object = object; } public t get() { return object; } }
创建一个box对象,不带泛型参数,发现获取对象的时候需要强制转换
box box2 = new box(); box2.set(new apple()); apple apple = (apple) box2.get();
创建一个box对象,带泛型参数,获取对象的时候就不需要强制转换
box<apple> box = new box<apple>(); box.set(new apple()); apple apple = box.get();
总结下泛型的好处就是
省去了强制转换,可以在编译时候检查类型安全,可以用在类,方法,接口上
但是我们定义泛型类,泛型方法,泛型接口的时候经常会碰见很多不同的通配符t,e,k,v等等,这些通配符又都是什么意思呢?继续往下看
2. 下来说说泛型通配符t,e,k,v区别
这些全都属于java泛型的通配符,刚开始我看到这么多通配符,一下晕了,这几个其实没什么区别,只不过是一个约定好的代码,也就是说
使用大写字母a,b,c,d......x,y,z定义的,就都是泛型,把t换成a也一样,这里t只是名字上的意义而已
- ? 表示不确定的java类型
- t (type) 表示具体的一个java类型
- k v (key value) 分别代表java键值中的key value
- e (element) 代表element
举个栗子:
public class test<t> { public list<t> list = new arraylist<t>(); public static void main(string[] args) { test<string> test = new test<string>(); test.list.add("hello"); system.out.println(test.list); }}
和
public class test<a> { public list<a> list = new arraylist<a>(); public static void main(string[] args) { test<string> test = new test<string>(); test.list.add("hello"); system.out.println(test.list); }}
将t换成了a,在执行效果上是没有任何区别的,只不过我们约定好了t代表type,所以还是按照约定规范来比较好,增加了代码的可读性。
如果要定义多个泛型参数,比如说两个泛型参数
很典型的一个栗子是map的key,value泛型,我们也可以定义一个这样的
public interface mymap<k, v> { public k getkey(); public v getvalue(); } public class mymapimpl<k, v> implements mymap<k, v> { private k key; private v value; public mymapimpl(k key, v value) { this.key = key; this.value = value; } public k getkey() { return key; } public v getvalue() { return value; } }
下来就可以传入任意类型,创建实例了,不用转化类型
mymap<string, integer> mp1= new mymapimpl<string, integer>("even", 8); mymap<string, string> mp2= new mymapimpl<string, string>("hello", "world"); mymap<integer, integer> mp3= new mymapimpl<integer, integer>(888, 888);
如果要定义超过两个,三个或三个以上的泛型参数可以使用t1, t2, ..., tn,像这样子
public class test<t1,t2,t3> { public void print(t1 t1,t2 t2,t3 t3){ system.out.println(t1.getclass()); system.out.println(t2.getclass()); system.out.println(t3.getclass()); } }
3. 接下来说说list<t>,list<object>,list<?>区别
arraylist<t> al=new arraylist<t>(); 指定集合元素只能是t类型
arraylist<?> al=new arraylist<?>(); 集合元素可以是任意类型,这种没有意义,一般是方法中,只是为了说明用法
arraylist<? extends e> al=new arraylist<? extends e>();
泛型的限定:
extends e:接收e类型或者e的子类型。
super e:接收e类型或者e的父类型
- object和t不同点在于,object是一个实打实的类,并没有泛指谁,而t可以泛指object,比方public void printlist(list<t> list){}方法中可以传入list<object> list类型参数,也可以传入list<string> list类型参数,但是public void printlist(list<object> list){}就只可以传入list<object> list类型参数,因为object类型并没有泛指谁,是一个确定的类型
- ?和t区别是?是一个不确定类,?和t都表示不确定的类型 ,但如果是t的话,函数里面可以对t进行操作,比方 t car = getcar(),而不能用? car = getcar()。
下面举个栗子比较下这三种:
package com.lyang.demo.fanxing; import java.util.arrays; import java.util.list; /** * 测试泛型参数object和t的区别 * created by yanglu on 2017/04/20. */ public class testdifferencebetweenobjectandt { public static void printlist1(list<object> list) { for (object elem : list) system.out.println(elem + " "); system.out.println(); } public static <t> void printlist2(list<t> list) { for (t elem : list) system.out.println(elem + " "); system.out.println(); } public static void printlist3(list<?> list) { for (int i = 0;i<list.size();i++) system.out.println(list.get(i) + " "); system.out.println(); } public static void main(string[] args) { list<integer> test1 = arrays.aslist(1, 2, 3); list<string> test2 = arrays.aslist("one", "two", "three"); list<object> test3 = arrays.aslist(1, "two", 1.23); list<fruit> test4 = arrays.aslist(new apple(), new banana()); /* * 下面这句会编译报错,因为参数不能转化成功 * */ printlist1(test4); /**/ printlist1(test3); printlist1(test3); printlist2(test1); printlist2(test2); printlist2(test3); printlist3(test1); printlist3(test2); printlist3(test3); } }
4. 最后来说说t,class<t>,class<?>区别
t是一种具体的类,例如string,list,map......等等,这些都是属于具体的类,这个比较好理解
class是什么呢,class也是一个类,但class是存放上面string,list,map......类信息的一个类,有点抽象,我们一步一步来看 。
如何获取到class类呢,有三种方式:
1. 调用object类的getclass()方法来得到class对象,这也是最常见的产生class对象的方法。
例如:
list list = null; class clazz = list.getclass();
2. 使用class类的中静态forname()方法获得与字符串对应的class对象。
例如:
class clazz = class.forname("com.lyang.demo.fanxing.people");
3.获取class类型对象的第三个方法非常简单。如果t是一个java类型,那么t.class就代表了匹配的类对象。
class clazz = list.class;
那么问题来了?class类是创建出来了,但是class<t>和class<?>适用于什么时候呢???**
使用class<t>和class<?>多发生在反射场景下,先看看如果我们不使用泛型,反射创建一个类是什么样的。
people people = (people) class.forname("com.lyang.demo.fanxing.people").newinstance();
看到了么,需要强转,如果反射的类型不是people类,就会报java.lang.classcastexception错误。
使用class<t>泛型后,不用强转了
public class test { public static <t> t createinstance(class<t> clazz) throws illegalaccessexception, instantiationexception { return clazz.newinstance(); } public static void main(string[] args) throws illegalaccessexception, instantiationexception { fruit fruit= createinstance(fruit .class); people people= createinstance(people.class); } }
那class<t>和class<?>有什么区别呢?
class<t>在实例化的时候,t要替换成具体类
class<?>它是个通配泛型,?可以代表任何类型,主要用于声明时的限制情况
例如可以声明一个
public class<?> clazz;
但是你不能声明一个
public class<t> clazz;
因为t需要指定类型
所以当不知道定声明什么类型的class的时候可以定义一个class<?>,class<?>可以用于参数类型定义,方法返回值定义等。
以上所有示例的代码我已经提交到了github,有兴趣的同学可以去看看https://github.com/qwertyanglu/fanxingdemo
个人的一些理解,如果有不对的地方,欢迎各位前辈给出宝贵指导,在此先行谢过。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。
上一篇: 引入阿里矢量图标库
下一篇: C#批量动态生成控件