devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java核心技术之什么是泛型_ars是什么意思有什么功能

作者：从前慢现在也慢 | 2024-03-14 23:02:20

赞

踩

ars是什么意思有什么功能

什么是泛型？我们在工程代码中一定看过T，K，V等等，这个就是泛型了，那我们看看官网是怎么说的这个@泛型(Generic)

When you take an element out of a  Collection , you must cast it to the type of element that is stored in the collection. Besides being inconvenient, this is unsafe. The compiler does not check that your cast is the same as the collection's type, so the cast can fail at run time.
Generics provides a way for you to communicate the type of a collection to the compiler, so that it can be checked. Once the compiler knows the element type of the collection, the compiler can check that you have used the collection consistently and can insert the correct casts on values being taken out of the collection.

官方这话是什么意思呢：当你从集合中取出元素时，必须将其强制转换为存储在集合中的元素类型。除了不方便，这是不安全的。编译器不会检查强制转换是否与集合的类型相同，因此强制转换可能会在运行时失败。
泛型提供了一种将集合的类型传递给编译器的方法，以便可以对其进行检查。一旦编译器知道集合的元素类型，编译器就可以检查您是否一致地使用了集合，并且可以对从集合中取出的值插入正确的强制转换。

官方这段晦涩的语言什么意思呢？总之就是一句话：泛型程序设计（Generic programming）意味着编写的代码可以被很多不同类型的对象所重用。

Java泛型(Generic)是J2SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

了解泛型概念之后的学习的目标是什么呢？

一、了解泛型的规则与类型擦除
二、了解类型和限制两种泛型的通配符
三、了解在API设计时使用泛型的方式（自定义泛型类、泛型接口、泛型方法）
四、掌握泛型的使用及原理。
五、掌握泛型在中间件或者开源框架里的应用

下面我们对这几个问题一一探讨

泛型的规则

JDK5.0之前是没有泛型这个概念的，那么当时是怎么写代码的

  1. import java.io.File;
  2. import java.util.ArrayList;
  3. /**
  4.  * @author mac
  5.  * @date 2020/10/31-11:05
  6.  */
  7. public static void main(String[] args) {
  8.    ArrayList arrayList = new ArrayList();
  9.    arrayList.add(1);
  10.    arrayList.add("a");
  11.    // 这里没有错误检查。可以向数组列表中添加任何类的对象
  12.    arrayList.add(new File("/"));
  13.    // 对于这个调用，如果将get的结果强制类型转换为String类型，就会产生一个错误
  14.    // Exception in thread "main" java.lang.ClassCastException: java.io.File cannot be cast to java.lang.String
  15.    String file = (String) arrayList.get(2);
  16.    System.out.println(file);
  17. }

在 JDK5.0以前，如果一个方法返回值是 Object，一个集合里装的是 Object，那么获取返回值或元素只能强转，如果有类型转换错误，在编译器无法觉察，这就大大加大程序的错误几率！

  1. public static void main(String[] args) {
  2.     ArrayList<String> arrayList = new ArrayList<String>();
  3.     arrayList.add("a");
  4.     String s = (String) arrayList.get(0);
  5.     // 6、7行代码编译不通过，不会导致运行后才发生错误
  6.     arrayList.add(1);
  7.     arrayList.add(new File("/"));
  8.     String file = (String) arrayList.get(2);
  9. }

从泛型的使用可以看出，泛型是一种类型约束，简而言之，泛型在定义类，接口和方法时使类型(类和接口)成为参数。与方法声明中使用的更熟悉的形式参数非常相似，类型参数为您提供了一种使用不同输入重复使用相同代码的方法。区别在于形式参数的输入是值，而类型参数的输入是类型。
JDK是在编译期对类型进行检查，提供了编译时类型的安全性。它为集合框架增加了编译时类型的安全性，并消除了繁重的类型转换工作。

  1. public class Person {
  2.     int gender;
  3. }
  4. public class Driver extends Person {
  5.     String name;
  6.     int skilllevel;
  7. }
  8. public static void main(String[] ars) {
  9.    List<Person> ls = new Arraylist<>();
  10.    //这里会不会编译报错?
  11.    List<Driver> list = ls;
  12. }

然而泛型的应用也不是没有坑，比如上述代码，可以看出编译报错，这是不允许子类型化的泛型规则——假设允许，那么是不是可以改成以下的情况，在 JDK 里所有的类都是 Object 的子类，如果允许子类
型化，那么ls里不就可以存放任意类型的元素了吗，这就和泛型的类型约束完全相悖，所以 JDK 在泛型的校验上有很严格的约束。

为了防止子类型化混乱，泛型有了通配符的概念

泛型中的通配符

无界通配符

在上述的泛型示例中，我们都是指定了特定的类型，至少也是 Object，假设有一种场景，你不知道这个类型是啥，它可以是 Object，也可以是 Person 那咋办？这种场景就需要用到通配符，如
下所示，通常采用一个?来表示。

  1. public void addAll(Collection<?> col){
  2.     ...
  3. }

上界通配符

基于上述的场景，加入我想限制这个类型为 Person 的子类，只要是 Person 的子类就都可以，如果泛型写成<Person> 那么只能强转如下所示，那么就失去了泛型的意义，又回到了最初的起点。这时候怎么办？

  1. List<Person> list = new ArrayList<>();
  2. list.add(new Driver());
  3. Person person = list.get(0);
  4. Driver driver = (Driver) person; // 针对这种情况于是有了有界通配符的推出。

  1. // 在泛型中指定上边界的叫上界通配符<? extends XXX>
  2. public void count(Collection<? extends Person> persons) {
  3. }
  4. public void count2(Collection<Person> persons) {
  5. }
  6. public void testCount() {
  7.     List<Driver> drivers = new ArrayList<>();
  8.     // 符合上界通配符规则，编译不报错
  9.     count(drivers);
  10.     // 违反子类型化原则，编译报错
  11.     count2(drivers);
  12.     // 符合下界通配符原则，编译不报错
  13.     List<Person> persons = new ArrayList<>();
  14. }

下界通配符

原理同上界通配符， 下界通配符将未知类型限制为特定类型或该类型的超类型，下限通配符使用通配符（' ？ '）表示，后跟 super 关键字，后跟下限：<？super A>。

  1. public void count3(Collection<? super Driver> drivers) {
  2. }
  3. public void testCount() {
  4.     //符合下界通配符原则，编译不报错
  5.     List<Person> persons = new ArrayList<>();
  6.     count3(persons);
  7. }

通用方法与类型推断

通用方法

通用方法是指方法参数的类型是泛型，static 和非 static 的方法都可以使用，还有就是构造方法也可以使用。我们看具体的使用

  1. /**
  2.  * @author mac
  3.  * @date 2020/10/31-12:24
  4.  * 定义一个bean类
  5.  */
  6. public class Pair<K, V> {
  7.     private K key; private V value;
  8.     public Pair(K key, V value) {
  9.         this.key = key; this.value = value;
  10.     }
  11.     public void setKey(K key) { this.key = key; }
  12.     public void setValue(V value) { this.value = value; }
  13.     public K getKey() { return key; }
  14.     public V getValue() { return value; }
  15. }
  16.  
  17. public class Util {
  18.     // <K, V>通用方法入参类型
  19.     public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
  20.         return p1.getKey().equals(p2.getKey()) &&
  21.                 p1.getValue().equals(p2.getValue()); // 使用Object中equals判断是否相等
  22.     }
  23. }
  24.  
  25.     public static void main(String[] args) {
  26.         Pair<Integer, String> p1 = new Pair<>(1, "apple");
  27.         Pair<Integer, String> p2 = new Pair<>(2, "pear");
  28.         // JDK8之后可以这么写boolean same = Util.compare(p1, p2);
  29.         boolean same = Util.<Integer, String>compare(p1, p2); 
  30.         System.out.println(same); // false
  31.     }

类型推断

类型推断是Java编译器查看每个方法调用和相应声明以确定使调用适用的类型参数的能力。推理算法确定参数的类型，以及确定结果是否已分配或返回的类型（如果有）。最后，推理算法尝试找到与所有参数一起使用的最具体的类型。

  1. /**
  2.  * @author macfmc
  3.  * @date 2020/10/31-12:39
  4.  */
  5. public class Box<U> {
  6.     U u;
  7.     public U get() { return u; }
  8.     public void set(U u) { this.u = u; }
  9. }
  10.  
  11. public class BoxDemo {
  12.     public static <U> void addBox(U u, List<Box<U>> boxes) {
  13.         Box<U> box = new Box<U>();
  14.         box.set(u);
  15.         boxes.add(box);
  16.     }
  17.     public static <U> void outputBoxes(List<Box<U>> boxes) {
  18.         int counter = 0;
  19.         for (Box<U> box : boxes) {
  20.             U boxContents = box.get();
  21.             System.out.println("Box #" + counter + " contains [" + boxContents.toString() + "]");
  22.             counter++;
  23.         }
  24.     }
  25.     public static void main(String[] args) {
  26.         ArrayList<Box<Integer>> listOfIntegerBoxes = new ArrayList<>();
  27.         // JDK8可以使用 BoxDemo.addBox(Integer.valueOf(10), listOfIntegerBoxes);
  28.         BoxDemo.<Integer>addBox(Integer.valueOf(10), listOfIntegerBoxes);
  29.         BoxDemo.addBox(Integer.valueOf(20), listOfIntegerBoxes);
  30.         BoxDemo.addBox(Integer.valueOf(30), listOfIntegerBoxes);
  31.         BoxDemo.outputBoxes(listOfIntegerBoxes);
  32.     }
  33. }
  34. // 结果
  35. // Box #0 contains [10]
  36. // Box #1 contains [20]
  37. // Box #2 contains [30]

那么泛型的概念原理和使用都了解了，泛型在JVM中是如何去解析的呢？

泛型擦除

我们看下面两段代码

  1. public class Node {
  2.     private Object obj;
  3.     public Object get() { return obj; }
  4.     public void set(Object obj) { this.obj = obj; }
  5.     public static void main(String[] argv) {
  6.         Student stu = new Student();
  7.         Node node = new Node();
  8.         node.set(stu);
  9.         Student stu2 = (Student) node.get();
  10.     }
  11. }
  12.  
  13. public class Node<T> {
  14.     private T obj;
  15.     public T get() { return obj; }
  16.     public void set(T obj) { this.obj = obj; }
  17.     public static void main(String[] argv) {
  18.         Student stu = new Student();
  19.         Node<Student> node = new Node<>();
  20.         node.set(stu);
  21.         Student stu2 = node.get();
  22.     }
  23. }

我们将其分别编译后查看.class字节码文件

  1.     public Node();
  2.         Code:
  3.            0: aload_0
  4.            1: invokespecial #1       // Method java/lang/Object."<init>": ()V
  5.            4: return
  6.     public java.lang.Object get();
  7.         Code:
  8.            0: aload_0
  9.            1: getfield    #2        // Field obj:Ljava/lang/Object;
  10.            4: areturn
  11.     public void set(java.lang.Object);
  12.         Code:
  13.            0: aload_0
  14.            1: aload_1
  15.            2: putfield    #2        // Field obj:Ljava/lang/Object;
  16.            5: return
  17.  
  18.     public Node();
  19.         Code:
  20.            0: aload_0
  21.            1: invokespecial #1       // Method java/lang/Object."<init>": ()V
  22.            4: return
  23.     public java.lang.Object get();
  24.         Code:
  25.            0: aload_0
  26.            1: getfield    #2        // Field obj:Ljava/lang/Object;
  27.            4: areturn
  28.     public void set(java.lang.Object);
  29.         Code:
  30.            0: aload_0
  31.            1: aload_1
  32.            2: putfield    #2        // Field obj:Ljava/lang/Object;
  33.            5: return

可以看到泛型就是在使用泛型代码的时候，将类型信息传递给具体的泛型代码。而经过编译后，生成的 .class 文件和原始的代码一模一样，就好像传递过来的类型信息又被擦除了一样。

类型擦除主要包括：一、通用类型的檫除：在类型擦除过程中，Java 编译器将擦除所有类型参数，如果类型参数是有界的，则将每个参数替换为其第一个边界；如果类型参数是无界的，则将其替换为 Object。二、通用方法的擦除：java 编译器还会檫除通用方法参数中的类型参数

类型檫除的问题

桥接方法

类型檫除在有一些情况下会产生意想不到的问题，为了解决这个问题，java 编译器采用桥接方法的方式。先看个官方案例

  1. // 泛型擦除前
  2. public class Node<T> {
  3.     public T data;
  4.     public Node(T data) { this.data = data; }
  5.     public void setData(T data) { this.data = data; }
  6. }
  7. public class MyNode extends Node<Integer> {
  8.     public MyNode(Integer data) { super(data); }
  9.     public void setData(Integer data) { super.setData(data); }
  10. }
  11.  
  12. // 泛型檫除后
  13. public class Node {
  14.     public Object data;
  15.     public Node(Object data) { this.data = data; }
  16.     public void setData(Object data) { this.data = data; }
  17. }
  18. public class MyNode extends Node {
  19.     public MyNode(Integer data) { super(data); }
  20.     public void setData(Integer data) { super.setData(data); }
  21. }
  22.  
  23. // 但是编译器会产生桥接方法
  24. public class MyNode extends Node {
  25.     public MyNode(Object data) { super(data); }
  26.     // Bridge method generated by the compiler
  27.     // 编译器产生的桥接方法
  28.     public void setData(Object data) { setData((Integer) data); }
  29.     public void setData(Integer data) { super.setData(data); }
  30. }

堆污染

堆污染在编译时并不会报错，只会在编译时提示有可能导致堆污染的警告.，在运行时，如果发生了堆污染，那么就会抛出类型转换异常。Heap pollution(堆污染),，指的是当把一个不带泛型的对象赋值给一个带泛型的变量时，就有可能发生堆污染。

  1. public static void main(String[] args) {
  2.     List lists = new ArrayList<Integer>();
  3.     lists.add(1);
  4.     List<String> list = lists;
  5.     // java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
  6.     String str = list.get(0);
  7.     System.out.println(str);
  8. }

类型的限制

Java泛型转换的事实：
虚拟机中没有泛型，只有普通的类和方法。
所有的类型参数都用它们的限定类型替换。
桥接方法被合成来保持多态。
为保持类型安全性，必要时插入强制类型转换。

jdk定义了7种泛型的使用限制：
1、不能用简单类型来实例化泛型实例
2、不能直接创建类型参数实例
3、不能声明静态属性为泛型的类型参数
4、不能对参数化类型使用cast或instanceof
5、不能创建数组泛型
6、不能create、catch、throw参数化类型对象
7、重载的方法里不能有两个相同的原始类型的方法

1、不能用简单类型来实例化泛型实例

  1. class Pair<K, V> {
  2.     private K key;
  3.     private V value;
  4.     public Pair(K key, V value) { this.key = key; this.value = value; }
  5.     public static void main(String[] args) {
  6.         // 编译时会报错，因为 int、char 属于基础类型，不能用于实例化泛型对象
  7.         Pair<int, char> p = new Pair(8, 'a');
  8.         // 编译不会报错
  9.         Pair<Integer, String> p2 = new Pair<>(8, "a");
  10.     }
  11. }

2、不能直接创建类型参数实例

  1.     public static <E> void append(List<E> list) {
  2.         E elem = new E(); // compile-time error 编译报错
  3.         list.add(elem);
  4.     }
  5.     //作为解决办法，可以通过反射来创建
  6.     public static <E> void append(List<E> list, Class<E> cls) throws Exception {
  7.         E elem = cls.newInstance(); // OK
  8.         list.add(elem);
  9.     }

3、不能声明静态属性为泛型的类型参数

  1. /**
  2.  *  类的静态字段是该类所有非静态对象所共享的，如果可以，那么在有多种类型的情况下，os到底应该是哪种类型呢？
  3.  *  下面这种情况，os到底应该是Smartphone还是Pager还是TablePC呢
  4.  *  MobileDevice<Smartphone> phone = new MobileDevice<>();
  5.  *  MobileDevice<Pager> pager = new MobileDevice<>();
  6.  *  MobileDevice<TabletPC> pc = new MobileDevice<>();
  7.  */
  8. public class MobileDevice<T> {
  9.     //非法
  10.     private static T os;
  11. }

4、不能对参数化类型使用cast或instanceof

  1.     public static <E> void rtti(List<E> list) {
  2.         // 编译期会提示异常——因为 java 编译器在编译器会做类型檫除，于是在运行期就无法校验参数的类型
  3.         if (list instanceof ArrayList<Integer>) { }
  4.     }
  5.  
  6.     // 解决方法可以通过无界通配符来进行参数化
  7.     public static void rtti(List<?> list) {
  8.         // 编译不会报错
  9.         if (list instanceof ArrayList<?>) { }
  10.     }

5、不能创建数组泛型

  1.         // 编译器报错
  2.         List<Integer>[] arrayOfLists = new List<Integer>[2];
  3.         // 用一个通用列表尝试同样的事情，会出现一个问题
  4.         Object[] strings = new String[2];
  5.         strings[0] = "hi"; // OK
  6.         strings[1] = 100; // An ArrayStoreException is thrown.
  7.         Object[] stringLists = new List<String>[]; // compiler error, but pretend it's allowed 缺少数组维
  8.         stringLists[0] = new ArrayList<String>(); // OK
  9.         // java.lang.ArrayStoreException: java.util.ArrayList but the runtime can't detect it.
  10.         stringLists[1] = new ArrayList<Integer>();

6、不能create、catch、throw参数化类型对象

  1. // 泛型类不能直接或间接的扩展 Throwable 类，以下情况会报编译错
  2. // Extends Throwable indirectly
  3. class MathException<T> extends Exception { } // compile-time error
  4. // Extends Throwable directly
  5. class QueueFullException<T> extends Throwable { } // compile-time error
  6.  
  7. // 捕捉泛型异常也是不允许的
  8.     public static <T extends Exception, J> void execute(List<J> jobs) {
  9.         try {
  10.             for (J job : jobs) { }
  11.         } catch (T e) { // compile-time error
  12.         }
  13.     }
  14.  
  15. // 但是可以在字句中使用类型参数
  16. class Parser<T extends Exception> {
  17.     public void parse(File file) throws T { }
  18. }

7、重载的方法里不能有两个相同的原始类型的方法

  1. // 因为类型檫除后，两个方法将具有相同的签名，重载将共享相同的类文件表示形式，并且将生成编译时错误。
  2. public class Example {
  3.     public void print(Set<String> strSet) { }
  4.     public void print(Set<Integer> intSet) { }
  5. }

总结：

代码中泛型的演变过程和泛型的使用及为什么使用是基础算是会用，泛型的三种通配符的使用及使用规则和通用方法的使用及类型推断是进阶算是了解，类型擦除及类型擦除的问题和类型的使用限制是补充算是熟悉，能了解泛型在JDK源码中的常用API的设计方式算是精通。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/237680
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号