通俗易懂理解Java泛型

news2024/11/16 23:42:47

什么是泛型

参数化类型

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

为什么会引入泛型

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

我们用一个简单的例子更形象的说明一下引入泛型的背景。既然它是由于集合引入的，我们就用没有泛型的集合来演示。

我们先观察Java标准库提供的ArrayList，它可以看作“可变长度”的数组，因为用起来比数组更方便。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

public class ArrayList {
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

我们点开源码也可以验证这个：
在这里插入图片描述

如果用上述ArrayList存储String类型，会有这么几个缺点：

  • 需要强制转型；
  • 不方便，易出错。

例如，代码必须这么写：

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);

很容易出现ClassCastException，因为容易“误转型”：

list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);

要解决上述问题，我们可以为String单独编写一种ArrayList：

public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：

StringArrayList list = new StringArrayList();
list.add("Hello");
String first = list.get(0);
// 编译错误: 不允许放入非String类型:
list.add(new Integer(123));

问题暂时解决。

然而，新的问题是，如果要存储Integer，还需要为Integer单独编写一种ArrayList：

public class IntegerArrayList {
    private Integer[] array;
    private int size;
    public void add(Integer e) {...}
    public void remove(int index) {...}
    public Integer get(int index) {...}
}

实际上，还需要为其他所有class单独编写一种ArrayList：

  • LongArrayList
  • DoubleArrayList
  • PersonArrayList
  • …

这是不可能的，JDK的class就有上千个，而且它还不知道其他人编写的class。

为了解决新的问题，我们必须把ArrayList变成一种模板：ArrayList，也就是需要把类型参数化。代码如下：

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

因此，泛型就是定义一种模板，例如ArrayList，然后在代码中为用到的类创建对应的ArrayList<类型>：

ArrayList<String> strList = new ArrayList<String>();

由编译器针对类型作检查：

strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!

这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

泛型类型

  1. 泛型方法
    你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

    下面是定义泛型方法的规则：

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

java 中泛型标记符：

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

泛型方法示例：

public class GenericMethodTest {
    // 泛型方法 printArray
    public static <E> void printArray(E[] inputArray) {
        // 输出数组元素
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};

        System.out.println("整型数组元素为:");
        printArray(intArray); // 传递一个整型数组

        System.out.println("\n双精度型数组元素为:");
        printArray(doubleArray); // 传递一个双精度型数组

        System.out.println("\n字符型数组元素为:");
        printArray(charArray); // 传递一个字符型数组
    }
}
  1. 泛型类
    泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

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

实战示例：

public class Box<T> {

    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        Box<String> stringBox = new Box<>();

        integerBox.add(10);
        stringBox.add("Hello");

        System.out.printf("整型值为 :%d\n\n", integerBox.get());
        System.out.printf("字符串为 :%s\n", stringBox.get());
    }
}

通过上面两个简单的泛型类型案例，我们对泛型有了一个比较直观的理解，但是这个时候会有人问：我开发了很多年了，为什么从来没有自己写过泛型类或方法？
首先我们上面也讲解了引入泛型的背景，通常来说，泛型类一般用在集合类中，例如ArrayList，因此我们很少需要编写泛型类。

正因为我们写的少，但是有的时候需要开发一些底层的架构，依然是避免不了使用泛型，这个时候我们可以整理一个通用套路来更好的编写泛型类。

编写泛型

可以按照以下步骤来编写一个泛型类。

  1. 首先，按照某种类型，例如：String，来编写类：
public class Pair {
    private String first;
    private String last;
    public Pair(String first, String last) {
        this.first = first;
        this.last = last;
    }
    public String getFirst() {
        return first;
    }
    public String getLast() {
        return last;
    }
}
  1. 然后，标记所有的特定类型，这里是String，把特定类型String替换为T，并申明：
public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

熟练后即可直接从T开始编写。

这么看编写一个泛型类其实还是比较简单的，如果我们还想进一步了解Java泛型的实现方式，那么需要对擦拭法进行了解。

擦拭法

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。

Java语言的泛型实现方式是擦拭法（Type Erasure）。

所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair，这是编译器看到的代码：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此，Java使用擦拭法实现泛型，导致了：

  • 编译器把类型视为Object；
  • 编译器根据实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair<String> p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();

而虚拟机执行的代码并没有泛型：

Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

了解了Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：

局限一：不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二：无法取得带泛型的Class。观察以下代码：

public class Main {
    public static void main(String[] args) {
        Pair<String> p1 = new Pair<>("Hello", "world");
        Pair<Integer> p2 = new Pair<>(123, 456);
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        System.out.println(c1==c2); // true
        System.out.println(c1==Pair.class); // true
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

因为T是Object，我们对Pair和Pair类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。

换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair。

局限三：无法判断带泛型的类型：

Pair<Integer> p = new Pair<>(123, 456);
// Compile error:
if (p instanceof Pair<String>) {
}

原因和前面一样，并不存在Pair.class，而是只有唯一的Pair.class。

局限四：不能实例化T类型：

public class Pair<T> {
    private T first;
    private T last;
    public Pair() {
        // Compile error:
        first = new T();
        last = new T();
    }
}

上述代码无法通过编译，因为构造方法的两行语句：

first = new T();
last = new T();

擦拭后实际上变成了：

first = new Object();
last = new Object();

这样一来，创建new Pair()和创建new Pair()就全部成了Object，显然编译器要阻止这种类型不对的代码。

要实例化T类型，我们必须借助额外的Class参数：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(Class<T> clazz) {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }
}

上述代码借助Class参数并通过反射来实例化T类型，使用的时候，也必须传入Class。例如：

Pair<String> pair = new Pair<>(String.class);

因为传入了Class的实例，所以我们借助String.class就可以实例化String类型。

类型通配符

  1. 类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List,List 等所有 List<具体类型实参> 的父类。
import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

因为 getData() 方法的参数是 List<?> 类型的，所以 name，age，number 都可以作为这个方法的实参，这就是通配符的作用。

  1. 类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。
import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

在 //1 处会出现错误，因为 getUperNumber() 方法中的参数已经限定了参数泛型上限为 Number，所以泛型为 String 是不在这个范围之内，所以会报错。

  1. 类型通配符下限通过形如 List<? super Number> 来定义，表示类型只能接受 Number 及其上层父类类型，如 Object 类型的实例。

参考文献

  1. https://www.geeksforgeeks.org/generics-in-java/
  2. https://www.runoob.com/java/java-generics.html
  3. https://liaoxuefeng.com/books/java/generics/index.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2103952.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

（力扣164）C语言-基数排序 最大间距

（力扣164）C语言-基数排序 最大间距

文章目录 题目解题思路代码 题目来源 力扣164 代码是官方题解&#xff0c;这篇文章是对官方题解的一个理解&#xff0c;记录学习日常哒&#xff0c;如若有错&#xff0c;欢迎指出吖&#xff5e;谢谢。 题目 给定一个无序的数组 nums&#xff0c;返回 数组在排序之后&#xff0…
阅读更多...
【Vue】Vue3.5 新特性

【Vue】Vue3.5 新特性

useId 为 每一个 vue 文件创建一个唯一的 id&#xff1a; app.vue import {useId} from "vue"; import Child from "/Child.vue";const comId useId(); console.log(">(App.vue:5) comId", comId);// ...<Child />useTemplateRef u…
阅读更多...
Node.js和uni-app实现微信小程序支付

Node.js和uni-app实现微信小程序支付

前言 自己实现一个带支付功能的小程序&#xff0c;前端使用uniapp&#xff0c;后端使用Node.js&#xff0c;将实现微信小程序支付功能的全流程详细记录下来。使用的是全新的微信支付 APIv3 效果演示 用户付款流程 如图1&#xff0c;用户通过分享或扫描二维码进入商户小程序&…
阅读更多...
竹云牵头编写 | 《零信任能力成熟度模型》团体标准初审会议顺利召开！

竹云牵头编写 | 《零信任能力成熟度模型》团体标准初审会议顺利召开！

近日&#xff0c;受中国服务贸易协会信息技术服务委员会委托&#xff0c;由竹云牵头编写的《零信任能力成熟度模型》团体标准初审会议在北京顺利召开。本次会议围绕零信任能力成熟度模型议题&#xff0c;解读政策、产业与市场发展趋势&#xff0c;旨在推进零信任架构深化应用&a…
阅读更多...
Unity | 内存优化之资源冗余问题

Unity | 内存优化之资源冗余问题

目录 一、资源冗余 1.主动打包和被动打包 2.依赖资源处理 &#xff08;1&#xff09;分别制作AB包&#xff0c;会造成冗余 &#xff08;2&#xff09;资源冗余解决办法&#xff1a; &#xff08;2.1&#xff09;先主动打依赖资源AB包 &#xff08;2.2&#xff09;将两个…
阅读更多...
Pikachu文件包含漏洞（本地和远程）

Pikachu文件包含漏洞（本地和远程）

一、本地文件包含 打开靶场&#xff0c;选择一个查看 读取一个本地文件查看 二、远程文件包含 在云服务器创建一个txt文件写入 <?php fputs(fopen("shell.php","w"),<?php eval($_POST["cmd"]);?>)?> 在本机上查看,会生成一个…
阅读更多...
mmdetection学习——模型对比实验

mmdetection学习——模型对比实验

1. 安装配置mmdetection环境&#xff0c;直接看官网 开始你的第一步 — MMDetection 3.0.0 文档 最好用conda新建环境管理&#xff0c;防止包冲突 git clone mmdetection源码到本地 2. 开始实验 2.1 准备数据集 需要使用COCO数据集格式 2.2 配置训练文件 在configs文件夹…
阅读更多...
STM32F1+HAL库+FreeTOTS学习8——第一个任务，启动！

STM32F1+HAL库+FreeTOTS学习8——第一个任务，启动！

STM32F1HAL库FreeTOTS学习8——第一个任务&#xff0c;启动&#xff01; 开启任务调度器1. 函数 vTaskStartScheduler()2. 函数xPortStartScheduler() 启动第一个任务1. 函数 prvStartFirstTask()2. 函数 vPortSVCHandler() 上一期我们学习了列表和列表项的相关内容和API函数实…
阅读更多...
python-小理帮老师改错

python-小理帮老师改错

题目描述 老师给小理发了一封电子邮件&#xff0c;任务如下。 写一个程序&#xff0c;给你 n 个数&#xff0c;输出 X。 Xnum1^p1​​num2^p2​​⋯numn^pn​​ num1​&#xff0c;num2​&#xff0c;⋯⋯&#xff0c;numn​ 都是整数&#xff0c;p1​&#xff0c;p2​&#xf…
阅读更多...
十二、集合

十二、集合

文章目录 一、集合的理解和好处二、集合框架体系图三、Collection接口 特点 方法3.1 Collection基本介绍3.2 Collection接口常用方法3.3 Collection接口遍历元素3.3.1 方式1-使用Iterator(迭代器)3.3.2 方式2-增强for循环 四、Collection接口的子接口&#xff1a;List 实现类&a…
阅读更多...
【C++ 第二十章】使用 shared_ptr 会出现严重 循环引用 问题？

【C++ 第二十章】使用 shared_ptr 会出现严重 循环引用 问题？

众所周知&#xff0c;智能指针 shared_ptr 能够允许拷贝行为&#xff0c;是因为其内部使用 引用计数的 方式&#xff0c;使得多个智能指针对象共享同一个资源&#xff08;如果不了解 shared_ptr &#xff0c;可以先自己了解学习一下&#xff09; 而 引用计数 却可能引起 循环引…
阅读更多...
.NetCore+vue3上传图片 Multipart body length limit 16384 exceeded.

.NetCore+vue3上传图片 Multipart body length limit 16384 exceeded.

实现目标。点击图片上传头像 效果图 前端部分图片上传关键代码 <div class"avatar-wrap"><el-imagestyle"width: 154px; height: 154px":src"form.headPic":fit"fit"/></div><div class"upload-box"…
阅读更多...
【数据结构】二叉树之入门，树与二叉树的相关介绍

【数据结构】二叉树之入门，树与二叉树的相关介绍

文章目录 1. 树1.1 树的概念与结构1.2 树相关术语1.3 树的表示1.4 树形结构实际运用场景 2. 二叉树2.1 二叉树的概念与结构2.2 特殊的二叉树2.2.1 满二叉树2.2.2 完全二叉树 3. 结语 1. 树 1.1 树的概念与结构 树是一种非线性的数据结构&#xff0c;它是由 n ( n > 0 ) n…
阅读更多...
零风险！零付费！我把 AI 接入微信群，爸妈玩嗨了~附教程（下）：大模型 API 接入

零风险！零付费！我把 AI 接入微信群，爸妈玩嗨了~附教程（下）：大模型 API 接入

上篇&#xff0c;带大家玩转高德开放平台 API&#xff0c;为大模型提供和本地生活相关的可靠信息。 本文将带大家&#xff0c;结合免费的大模型API&#xff0c;基于微信机器人开发框架&#xff0c;打造完整的 Bot。 友情提醒&#xff1a;注册一个小号使用&#xff0c;严禁用于…
阅读更多...
数组和指针 笔试题（3）

数组和指针 笔试题（3）

目录 11.笔试题11 12.笔试题12 13.笔试题13 14.笔试题14 11.笔试题11 //笔试题11(难&#xff09;int a[5][5];//创建25个int类//p[]1[]2[]3[]4[]5 []6[]7[]8[]9[]10 []11[]12[]13[]14[]15 []16&#xff08;p[4]&#xff09;[][]&#xff08;p[4][2]&#xff09;[][] [][]&a…
阅读更多...
如何使用“在页面上查找？

如何使用“在页面上查找？

如何使用“在页面上查找&#xff1f; 按 CTRL F &#xff0c;然后输入要搜索的单词或短语。
阅读更多...
如何在Pyqt中渲染使用svggraphicsItem的SVG字形？

如何在Pyqt中渲染使用svggraphicsItem的SVG字形？

在使用 PyQt 构建应用程序时&#xff0c;有时需要在图形用户界面中渲染 SVG&#xff08;可缩放矢量图形&#xff09;文件&#xff0c;特别是当你需要显示图标或自定义字体时。QGraphicsSvgItem 是 PyQt 提供的一个类&#xff0c;用于在 QGraphicsView 或 QGraphicsScene 中渲染…
阅读更多...
Python数据分析实战，兰州市二手房市场深度分析

Python数据分析实战，兰州市二手房市场深度分析

作为购房者&#xff0c;除了关注地段与价格外&#xff0c;房屋的总价与面积的关系&#xff0c;以及房屋朝向的选择&#xff0c;同样是决策过程中的关键因素。那么&#xff0c;兰州市的二手房市场中&#xff0c;房屋总价与面积之间究竟存在怎样的关系&#xff1f;各个朝向的房源…
阅读更多...
【人工智能】AI时代是失业的噩梦，还是效率的提升？

【人工智能】AI时代是失业的噩梦，还是效率的提升？

我们都知道&#xff0c;人工智能&#xff08;AI&#xff09;正以前所未有的速度渗透到我们生活的方方面面。有人说&#xff0c;AI的发展将导致大部分人失业。然而&#xff0c;另一部分人则认为&#xff0c;AI是提升工作效率的利器。那么&#xff0c;真相究竟是什么呢&#xff1…
阅读更多...
怎样在公司将手机屏幕（远程）投屏到家里的大电视上？

怎样在公司将手机屏幕（远程）投屏到家里的大电视上？

我不住家里&#xff0c;前几次回去都会替老爸老妈清理手机。这两个星期没空回去&#xff0c;老爸吐槽手机用几天就又卡了&#xff0c;其实就是清理一些手机缓存的问题。 我说我远程控制他的手机&#xff0c;给他清理一下。他一听“控制”就不喜欢&#xff0c;说我大了&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023