Java泛型

一、泛型介绍

1、简介

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型

参数化类型:

• 把类型当作是参数一样传递
• **<数据类型>** 只能是引用类型

相关术语：

• ArrayList<E>中的E称为类型参数变量
• ArrayList<Integer>中的Integer称为实际类型参数
• 整个称为ArrayList<E>泛型类型
• 整个ArrayList<Integer>称为参数化的类型ParameterizedType

2、泛型优点

• 类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
• 消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
• 潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

3、泛型的定义和使用

• 泛型类
• 泛型方法
• 泛型接口

二、泛型基础

1、泛型类与泛型方法

1、泛型类

**泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。**这样的话，用户明确了什么类型，该类就代表着什么类型；用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。

public class test {
    public static void main(String[] args) {
        //创建对象并指定元素类型
        User<String> tool = new User<>();
        tool.setObj("shawn");
        String s = tool.getObj();
        System.out.println(s);
        //创建对象并指定元素类型
        User<Integer> objectTool = new User<>();
        //如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
        objectTool.setObj(10);
        int i = objectTool.getObj();
        System.out.println(i);
    }

    /*
    1:把泛型定义在类上
    2:类型变量定义在类上,方法中也可以使用
    */
    public static class User<T> {
        private T obj;
        public T getObj() {
            return obj;
        }
        public void setObj(T obj) {
            this.obj = obj;
        }
    }
}

2、泛型方法

泛型方法与泛型类稍有不同的地方是，类型参数也就是尖括号那一部分是写在返回值前面的。第一个 T 被称为类型参数，而方法中的 T 被称为参数化类型，它不是运行时真正的参数。最后声明的类型参数，其实也是可以当作返回值的类型的。

public class Test1 {
      //定义泛型方法
      public <T> T void testMethod(T t){
      // TODO
      return null;
      }
  }

3、泛型类和泛型方法并存

public class test {

    public static void main(String[] args) {

        Test1<String> t = new Test1();
        t.testMethod("shawn");
        //注意使用泛型方法并不需要我们显式地用<>声明类型
        Integer i = t.testMethod1(new Integer(1));
        // 1
        System.out.println(i);
    }

    // 泛型类和泛型方法并存，两者的类型参数最好不要同名
    public static class Test1<T>{
        public  void testMethod(T t){
            // java.lang.String
            System.out.println(t.getClass().getName());
        }
        public  <E> E testMethod1(E e){
            return e;
        }
    }
}

2、泛型继承关系

泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承。泛型继承分两种情况

• 子类明确泛型类的类型参数变量
• 子类不明确泛型类的类型参数变量

要注意的是实现类的要是重写父类的方法，返回值的类型是要和父类一样的；其次类上声明的泛形只对非静态成员有效

public class test {

    public static void main(String[] args) {

        //测试第一种情况
        Inter<String> i = new InterImpl();
        i.show("hello");

        //第二种情况测试
        Inter<String> ii = new InterImpl1<>();
        ii.show("100");
    }

    /**
        把泛型定义在接口上
     */
    public interface Inter<T> {
        void show(T t);

    }

    /**
     * 子类明确泛型类的类型参数变量
     */

    public static class InterImpl implements Inter<String> {
        @Override
        public void show(String s) {
            System.out.println(s);

        }
    }
    /**
     * 当子类不明确泛型类的类型参数变量时，外界使用子类的时候
     * 也需要传递类型参数变量进来，
     * 在实现类上需要定义出类型参数变量
     */
    public static class InterImpl1<T> implements Inter<T> {
        @Override
        public void show(T t) {
            System.out.println(t);

        }
    }
}

3、泛型通配符

1、介绍

**常用的 T，E，K，V，？**本质上都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：

• ？表示不确定的 java 类型
• T (type) 表示具体的一个java类型
• K V (key value) 分别代表java键值中的Key Value
• E (element) 代表Element

2、？无界通配符

对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?> ），表示可以持有任何类型。无限定通配符经常与容器类配合使用，它其中的 ? 其实代表的是未知类型，所以涉及到 ? 时的操作，一定与具体类型无关。

3、上界通配符 < ? extends E>

上届：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 E 或者 E 的子类，编译不成功
• 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

public class test {

    public class Test2 <T,E extends T>{
        T value1;
        E value2;
    }
    public <D,S extends D> void test(D d,S s){
    // TODO
    }
}

4、下界通配符 < ? super E>

下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

在泛型的上限和下限中有一个原则：PECS(Producer Extends Consumer Super)

• 带有子类限定的可以从泛型读取【也就是—>(? extend T)】-------->Producer Extends
• 带有超类限定的可以从泛型写入【也就是—>(? super T)】-------->Consumer Super

5、通配符?和泛型方法T区别

使用原则：

• 如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法
• 如果没有依赖关系的，就使用通配符，通配符会灵活一些.

//大多时候，我们都可以使用泛型方法来代替通配符
//使用通配符
public static void test(List<?> list) {

}
//使用泛型方法
public <T> void  test2(List<T> t) {

}

两者区别：

• 通过 T 来 确保 泛型参数的一致性
• 类型参数可以多重限定而通配符不行
• 通配符可以使用超类限定而类型参数不行

//类型参数 T 只具有 一种 类型限定方式：
//但是通配符 ? 可以进行 两种限定： 
T extends A
? extends A
? super A

三、泛型与虚拟机

1、类型擦除

泛型是 Java 1.5 版本才引进的概念，但是泛型代码能够很好地和之前版本的代码很好地兼容。这是因为泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

public class test {
    public static void main(String[] args){
        List<String> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        // 结果为True,因为结果都为List
        System.out.println(list.getClass()==list1.getClass());
    }
}

类型擦除过程中，原始类型用第一个限定来替换类型变量，如果没有给定限定，就替换为Object。例如User<T>中的类型变量没有显示的限定，就会用Object进行替换；如果声明了User<T extends Comparable>，就会用Comparable替换。

2、泛型转换重要结论

• 虚拟机中没有泛型，只有普通的类和方法
• 所有的类型参数都会替换为它们的限定类型
• 会合成桥方法来保持多态
• 为保持类型安全性，必要时会插人强制类型转换

3、泛型局限性

1. 不能使用基本类型实例化类型参数
2. 不能实例化类型参数
3. 不可以实例化类型变量的数组
4. 不可以定义泛型类的数组
5. 不可以对泛型类型进行类型检测/转化
6. 不可以抛出或捕获泛型异常
7. 泛型类的静态类型变量/方法无效
8. 类型擦除引发的冲突

---

参考文章

《Java核心技术卷1》

https://segmentfault.com/a/1190000014120746

https://www.cnblogs.com/jiading/articles/12560549.html

https://mp.weixin.qq.com/s/ZxOULsyFt1Iy8HqPW8VOSw