一看就懂 详解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

个人的一些理解，如果有不对的地方，欢迎各位前辈给出宝贵指导，在此先行谢过。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。