(转)JAVA泛型通配符T，E，K，V区别，T以及Class，Class的区别

傷城~ 2021-12-11 02:39 267阅读 0赞

# 1. 先解释下泛型概念 #

> 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为[泛型类][Link 1]、泛型接口、泛型方法。[Java语言][Java]引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的[情况][Link 2]的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的[强制类型转换][Link 3]，而这种转换是要求开发者对[实际参数][Link 4]类型可以预知的情况下进行的。对于强制类型转换错误的情况，[编译器][Link 5]可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 泛型的好处是在编译的时候检查[类型安全][Link 6]，并且所有的[强制转换][Link 7]都是自动和[隐式][Link 8]的，以提高代码的重用率。

以上内容摘自百度百科

举个栗子: Box类定义为一个泛型类

1.  `public class Box<T> {`
2.  `private T object;`
3.   
4.  `public void set(T object) { this.object = object; }`
5.  `public T get() { return object; }`
6.  `}`
7.

创建一个Box对象，不带泛型参数，发现获取对象的时候需要强制转换

1.  `Box box2 = new Box();`
2.  `box2.set(new Apple());`
3.  `Apple apple = (Apple) box2.get();`
4.

创建一个Box对象，带泛型参数，获取对象的时候就不需要强制转换

1.  `Box<Apple> box = new Box<Apple>();`
2.  `box.set(new Apple());`
3.  `Apple apple = box.get();`
4.

总结下泛型的好处就是  
**省去了强制转换，可以在编译时候检查类型安全，可以用在类，方法，接口上**

但是我们定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符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

举个栗子：

1.  `public class Test<T> {`
2.  `public List<T> list = new ArrayList<T>();`
3.  `public static void main(String[] args) {`
4.  `Test<String> test = new Test<String>();`
5.  `test.list.add("hello");`
6.  `System.out.println(test.list);`
7.  `}}`
8.

和

1.  `public class Test<A> {`
2.  `public List<A> list = new ArrayList<A>();`
3.  `public static void main(String[] args) {`
4.  `Test<String> test = new Test<String>();`
5.  `test.list.add("hello");`
6.  `System.out.println(test.list);`
7.  `}}`
8.

将T换成了A，在执行效果上是没有任何区别的，只不过我们约定好了T代表type，所以还是**按照约定规范来比较好**，增加了代码的可读性。

如果要定义**多个**泛型参数，比如说两个泛型参数  
很典型的一个栗子是Map的key,value泛型，我们也可以定义一个这样的

1.  `public interface Mymap<K, V> {`
2.  `public K getKey();`
3.  `public V getValue();`
4.  `}`
5.   
6.  `public class MymapImpl<K, V> implements Mymap<K, V> {`
7.   
8.  `private K key;`
9.  `private V value;`
10.  
11. `public MymapImpl(K key, V value) {`
12. `this.key = key;`
13. `this.value = value;`
14. `}`
15.  
16. `public K getKey() { return key; }`
17. `public V getValue() { return value; }`
18. `}`
19.

下来就可以传入任意类型，创建实例了，不用转化类型

1.  `Mymap<String, Integer> mp1= new MymapImpl<String, Integer>("Even", 8);`
2.  `Mymap<String, String> mp2= new MymapImpl<String, String>("hello", "world");`
3.  `Mymap<Integer, Integer> mp3= new MymapImpl<Integer, Integer>(888, 888);`
4.

如果要定义**超过两个，三个或三个以上**的泛型参数可以使用**T1, T2, ..., Tn**，像这样子

1.  `public class Test<T1,T2,T3> {`
2.  `public void print(T1 t1,T2 t2,T3 t3){`
3.  `System.out.println(t1.getClass());`
4.  `System.out.println(t2.getClass());`
5.  `System.out.println(t3.getClass());`
6.  `}`
7.  `}`
8.

# 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()。

下面举个栗子比较下这三种：

1.  `package com.lyang.demo.fanxing;`
2.   
3.  `import java.util.Arrays;`
4.  `import java.util.List;`
5.   
6.  `/**`
7.  `* 测试泛型参数Object和T的区别`
8.  `* Created by yanglu on 2017/04/20.`
9.  `*/`
10. `public class TestDifferenceBetweenObjectAndT {`
11. `public static void printList1(List<Object> list) {`
12. `for (Object elem : list)`
13. `System.out.println(elem + " ");`
14. `System.out.println();`
15. `}`
16.  
17. `public static <T> void printList2(List<T> list) {`
18. `for (T elem : list)`
19. `System.out.println(elem + " ");`
20. `System.out.println();`
21. `}`
22.  
23. `public static void printList3(List<?> list) {`
24. `for (int i = 0;i<list.size();i++)`
25. `System.out.println(list.get(i) + " ");`
26. `System.out.println();`
27. `}`
28.  
29. `public static void main(String[] args) {`
30. `List<Integer> test1 = Arrays.asList(1, 2, 3);`
31. `List<String> test2 = Arrays.asList("one", "two", "three");`
32. `List<Object> test3 = Arrays.asList(1, "two", 1.23);`
33. `List<Fruit> test4 = Arrays.asList(new Apple(), new Banana());`
34. `/*`
35. `* 下面这句会编译报错，因为参数不能转化成功`
36. `* */`
37. `printList1(test4);`
38. `/**/`
39. `printList1(test3);`
40. `printList1(test3);`
41. `printList2(test1);`
42. `printList2(test2);`
43. `printList2(test3);`
44. `printList3(test1);`
45. `printList3(test2);`
46. `printList3(test3);`
47. `}`
48. `}`
49.  
50.

![79234367][]

image.png

# 4. 最后来说说T，Class<T>，Class<?>区别 #

T是一种具体的类，例如String,List,Map......等等，这些都是属于具体的类，这个比较好理解  
\*\* Class是什么呢，Class也是一个类，但Class是存放上面String,List,Map......类信息的一个类\*\*，有点抽象，我们一步一步来看 。

如何获取到Class类呢，有三种方式：  
**1. 调用Object类的getClass()方法来得到Class对象，这也是最常见的产生Class对象的方法。**  
例如：

1.  `List list = null;`
2.  `Class clazz = list.getClass();`
3.

\*\*2. 使用Class类的中静态forName()方法获得与字符串对应的Class对象。  
\*\*  
例如：

1.  `Class clazz = Class.forName("com.lyang.demo.fanxing.People");`
2.

**3.获取Class类型对象的第三个方法非常简单。如果T是一个Java类型，那么T.class就代表了匹配的类对象。**

1.  `Class clazz = List.class;`
2.

### \*\* 那么问题来了？Class类是创建出来了，但是Class<T>和Class<?>适用于什么时候呢？？？\*\* ###

使用Class<T>和Class<?>多发生在反射场景下，先看看如果我们不使用泛型，反射创建一个类是什么样的。

1.  `People people = (People) Class.forName("com.lyang.demo.fanxing.People").newInstance();`
2.

看到了么，需要强转，如果反射的类型不是People类，就会报  
**java.lang.ClassCastException**错误。

使用Class<T>泛型后，不用强转了

1.  `public class Test {`
2.  `public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {`
3.  `return clazz.newInstance();`
4.  `}`
5.   
6.  `public static void main(String[] args) throws IllegalAccessException, InstantiationException {`
7.  `Fruit fruit= createInstance(Fruit .class);`
8.  `People people= createInstance(People.class);`
9.  `}`
10. `}`
11.

那Class<T>和Class<?>有什么区别呢？  
**Class<T>在实例化的时候，T要替换成具体类  
Class<?>它是个通配泛型，?可以代表任何类型，主要用于声明时的限制情况**  
例如可以声明一个

1.  `public Class<?> clazz;`
2.

但是你不能声明一个

1.  `public Class<T> clazz;`
2.

因为T需要指定类型  
所以当，不知道定声明什么类型的Class的时候可以定义一个Class<?>,Class<?>可以用于参数类型定义，方法返回值定义等。

转载于:https://www.cnblogs.com/ysySelf/p/10973748.html

[Link 1]: https://link.jianshu.com?t=http://baike.baidu.com/view/2104244.htm
[Java]: https://link.jianshu.com?t=http://baike.baidu.com/view/229611.htm
[Link 2]: https://link.jianshu.com?t=http://baike.baidu.com/view/780206.htm
[Link 3]: https://link.jianshu.com?t=http://baike.baidu.com/view/2886403.htm
[Link 4]: https://link.jianshu.com?t=http://baike.baidu.com/view/2245196.htm
[Link 5]: https://link.jianshu.com?t=http://baike.baidu.com/view/487018.htm
[Link 6]: https://link.jianshu.com?t=http://baike.baidu.com/view/1965709.htm
[Link 7]: https://link.jianshu.com?t=http://baike.baidu.com/view/965170.htm
[Link 8]: https://link.jianshu.com?t=http://baike.baidu.com/view/2852863.htm
[79234367]: /images/20211210/9f98d5fb6b064847bb7dd07ad2f69cb1.png