Java-泛型机制详解

Java-泛型机制详解

1: 提出背景

Java集合（Collection）中元素的类型是多种多样的。例如，有些集合中的元素是Byte类型的，而有些则可能是String类型的，等等。Java允许程序员构建一个元素类型为Object的Collection，其中的元素可以是任何类型在[Java SE](https://baike.baidu.com/item/Java SE/4662159?fromModule=lemma_inlink) 1.5之前，没有泛型（Generics）的情况下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要作显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以在预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。因此，为了解决这一问题，J2SE 1.5引入泛型也是自然而然的了。
2: 泛型简介

泛型概念

​        Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
泛型作用

• 第一是泛化
  ​                可以用T代表任意类型Java语言中引入泛型是一个较大的功能增强不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了，这带来了很多好处。
  
• 第二是类型安全
  ​                泛型的一个主要目标就是提高Java程序的类型安全，使用泛型可以使编译器知道变量的类型限制，进而可以在更高程度上验证类型假设。如果不用泛型，则必须使用强制类型转换，而强制类型转换不安全，在运行期可能发生ClassCast Exception异常，如果使用泛型，则会在编译期就能发现该错误。
  
• 第三是消除强制类型转换
  泛型可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。
  
• 第四是向后兼容
  ​      支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译
  

3:泛型的基本使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。下面一部分例子参考与菜鸟教程网站(https://www.runoob.com/java/java-generics.html)

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
例子:

• 简单泛型类
  

1. /**
2. *
3. * @param <T> 此处是标识符号，T是type简称
4. */
5. public class MyBox<T> {
6.     /**
7.      * t的类型有T指定，创建该对象的时候，指定的类型
8.      */
9.     private T t;
10.    
11.     public void add(T t) {
12.         this.t = t;
13.     }
14.     public T get() {
15.         return t;
16.     }
17. }
19. public class MainTest {
20.     public static void main(String[] args) {
21.         MyBox<String> stringMyBox = new MyBox<>();
22.         stringMyBox.add("dddd");
23.         System.out.println(stringMyBox.get());
25.         MyBox<Integer> integerMyBox = new MyBox<>();
26.         integerMyBox.add(23);
27.         System.out.println(integerMyBox.get());
28.     }
29. }

复制代码

• 多元泛型类
  

1. /**
2. *
3. * @param <K> 变量key的类型，由外部指定
4. * @param <V> 变量value的类型，由外部指定
5. */
6. public class MyMap<K,V> {
7.    
8.     private K key;
9.     private V value;
11.     public K getKey() {
12.         return this.key;
13.     }
15.     public V getValue() {
16.         return this.value;
17.     }
19.     public void setKey(K key) {
20.         this.key = key;
21.     }
23.     public void setValue(V value ){
24.         this.value = value;
25.     }
27. }
29. public class MainTest {
30.     public static void main(String[] args) {
31.         MyMap<String, String> stringStringMyMap = new MyMap<>();
32.         stringStringMyMap.setKey("key1");
33.         stringStringMyMap.setValue("key2");
34.         System.out.println(stringStringMyMap.getKey()+"="+ stringStringMyMap.getValue());
36.         MyMap<String, Integer> stringIntegerMyMap = new MyMap<>();
37.         stringIntegerMyMap.setKey("key1");
38.         stringIntegerMyMap.setValue(1234);
39.         System.out.println(stringIntegerMyMap.getKey()+"="+ stringIntegerMyMap.getValue());
40.     }
41. }

复制代码

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中
例子:
当实现泛型接口的类，没有传入泛型实参的时候:

1. /**
2. * 定义一个泛型接口
3. * @param <T>
4. */
5. public interface Generator<T> {
6.    
7.     public T getNext();
8.    
9. }
11. /**
12. * 没有传入参数实参时，与泛型类的定义相同，在声明类的时候，需要将泛型的声明也一起加到类中
13. * @param <T>
14. */
15. class GoodsGenerator<T> implements Generator<T> {
16.    
17.     @Override
18.     public T getNext() {
19.         return null;
20.     }
21. }

复制代码

当实现泛型接口的类，传入泛型实参时候：

1. /**
2. * 传入泛型实参后，那么这个实现类里面的所有的参数都指定的类型，不能更改
3. * @param <Params>
4. */
5. public class MyGoodsGenerator<Params> implements  Generator<Params> {
7.     private Params params = null;
9.     @Override
10.     public Params getNext() {
11.         return params;
12.     }
13. }
15. class Params {
17.     private String name;
18.     private String type;
20.     Params() {}
22.     Params(String name,String type) {
23.         this.name = name;
24.         this.type = type;
25.     }
26. }

复制代码

泛型方法

相对于泛型类，泛型方法就比较复杂了。
泛型类 是在实例化类的时候指明泛型的具体类型。而泛型方法，是在调用的时候指明泛型的具体类型
泛型方法规则

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 ）
  
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符
  
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符
  
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）
  

Java中泛型标记符

• E - Element (在集合中使用，因为集合中存放的是元素)
  
• T - Type（Java 类）
  
• K - Key（键）
  
• V - Value（值）
  
• N - Number（数值类型）
  
• ？ - 表示不确定的 java 类型
  

下面我们看一个例子:

1. /**
2.      * 泛型方法
3.      *  首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T。
4.      *  这个T可以出现在这个泛型方法的任意位置
5.      * @param container 用来创建泛型对象
6.      * @param <T> 指明泛型T的具体类型
7.      * @return
8.      * @throws IllegalAccessException
9.      * @throws InstantiationExceptio
10.      */
11.     public <T> T showKeyName(Class<T> c) throws IllegalAccessException, InstantiationException {
12.         //创建对象
13.         T t = c.newInstance();
14.         return t;
15.     }

复制代码

1: 为什么要用变量c来创建对象呢？
​        既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

​        泛型方法要求的参数是Class类型，而Class.forName()方法的返回值也是Class，因此可以用Class.forName()作为参数。当然，泛型方法不是仅仅可以有一个参数Class，可以根据需要添加其他参数。
好处
​        因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。
泛型的上下限

先看下下面的例子

1.     public class Entity {
3.     }
5.     class BaseEntity extends Entity {
7.     }

复制代码

1.     //这两个方法编译不报错
2.     public static void funA(Entity a) {
3.     // ...
4.     }
5.     public static void funB(BaseEntity b) {
6.     funA(b);
7.     // ...
8.     }
10.     //下面的funC(ListB)就会编译报错
11.     public static void funC(List<Entity> Entitys) {
12.         // ...
13.     }
15.     public static void funD(List<BaseEntity> BaseEntitys) {
16.         funC(BaseEntitys);
17.         // ...
18.     }

复制代码

如何解决这个问题: 看下面的方法
[code]   public static void funC(List