认识泛型和包装类

认识泛型和包装类

  • 包装类
    • 基本数据类型和对应的包装类
    • 装箱和拆箱
    • 自动装箱和自动拆箱
  • 什么是泛型
  • 引出泛型
    • 语法
  • 泛型类的使用
    • 语法
    • 示例
    • 类型推导
  • 裸类型(Raw Type)
    • 说明
  • 泛型如何编译的
    • 擦除机制
  • 泛型的上界
    • 语法
    • 示例
    • 复杂示例
  • 泛型方法
    • 定义方法
    • 示例
    • 使用类型推导和不用类型推导
    • 静态的泛型方法

包装类

在java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，java给每个基本类型都对应了一个包装类型。

基本数据类型和对应的包装类

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean

除了Integer和Charater，其余基本类型的包装类都是大写字母。

装箱和拆箱

装箱：把基本数据类型变为包装类类型的过程叫做装箱
拆箱：把包装类类型变为基本数据类型的过程叫做拆箱

public class Test {
    public static void main(String[] args) {
        int i = 10;

        //装箱操作，新建一个Integer类型对象，将i的值放入对象的某个属性中
        Integer integer1 = Integer.valueOf(i);
        Integer integer2 = new Integer(i);

        //拆箱操作，将Integer对象中的值取出，放到一个基本的数据类型中
        int j = integer1.intValue();
    }
}

自动装箱和自动拆箱

装箱/装包：自动(隐式)装箱 显式装箱
拆箱/拆包：自动(隐式)拆箱 显式拆箱
在使用过程中，装箱和拆箱带来了不少代码量，为了减少开发者的负担，java提供了自动机制

public class Test {
    public static void main(String[] args) {
        int a = 10;

        Integer integer1 = Integer.valueOf(a);  //显式装箱
        Integer integer2 = a;                   //隐式装箱，底层帮我们调用了Integer.valueOf(a)

        int i = integer1.intValue();            //显式拆箱
        int j = integer1;                       //隐式拆箱，底层帮我们调用了integer1.intValue()
        
    }
}

接下来我们再来看一段代码：

public class Test {
    //下面代码输出什么，为什么？
    public static void main(String[] args) {
       Integer a = 100;
       Integer b = 100;

       Integer c = 200;
       Integer d = 200;

        System.out.println(a == b);
        System.out.println(c == d);
    }
    //结果为：
    //true
    //false
}

为什么是这种结果呢，这跟我们装箱中的valueOf(int i)这个方法有关系，我们来看源码：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

当 i 在 IntegerCache.low 和 IntegerCache.high之间返回数组中的值，若不是则创建新对象，所以我们再来看这个范围是什么
在这里插入图片描述
在这里插入图片描述
所以100在这个区域内，返回同一个数，所以输出true，而200不在，所以创建了两个新对象，所以输出false

什么是泛型

一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。------来源《java编程思想》对泛型的介绍
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型，从代码上讲，就是对类型实现了参数化。

引出泛型

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
思考：

  1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10];Strings[] strs = new String[10];
  2. 所有类的父类默认为Object类。数组是否可以创建为Object？
public class MyArray {
    public Object[] myArray = new Object[10];

    public Object getMyArray(int pos) {
        return myArray[pos];
    }

    public void setMyArray(int pos,Object value) {
        this.myArray[pos] = value;
    }
}

public class Test {

    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setMyArray(0,123);
        myArray.setMyArray(1,"onward");

        int num = (int)myArray.getMyArray(0);
        String str = (String)myArray.getMyArray(1);
        System.out.println(num);
        System.out.println(str);
    }
    //结果为：
    //123
    //onward
}

问题：

  • 任何数据都可以存放，存放太乱，什么类型都能存放
  • 数组1号下标本身就是字符串，但是编译报错，必须进行强转，什么类型都需要强转。

虽然在当前这种情况，数组确实可以存放任何类型数据都可以存放，但是，更多情况下，我们还是希望它只能够持有一种数据类型，而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象，让编译器去做检查，此时，就需要把类型作为参数传递，需要什么类型就传入什么类型。

语法

class 泛型类型名称<类型形参列表>{
	//这里可以使用类型参数
}

class ClassName<T1,T2,...,Tn>{

}
class 泛型类型名称<类型形参列表>extends 继承类/*这里可以使用类型参数*/{
	//这里可以使用类型参数
}
class ClassName<T1,T2,...,Tn>extends ParentClass<T1>{
	//可以只使用部分类型参数
}

我们可以对上面的代码进行改写

public class MyArray2 <T>{
    public Object[] myArray = new Object[10];

    public T getMyArray(int pos) {
        T value = (T)myArray[pos];
        return value;
    }

    public void setMyArray(int pos, T value) {
        this.myArray[pos] = value;
    }
}


public class Test {

    public static void main(String[] args) {
        MyArray2<Integer> myArray = new MyArray2<Integer>();    //指定当前类型为Integer
        myArray.setMyArray(0,123);  //自动类型强转
        //myArray.setMyArray(1,"onward");       //自动类型检查，编译报错
        myArray.setMyArray(1,12);
        int num = myArray.getMyArray(0);    //不用进行强制类型强转
        System.out.println(num);

        MyArray2<String> myArray2 = new MyArray2<String>();
        myArray2.setMyArray(0,"onward");
        myArray2.setMyArray(1,"forward");
        String str = myArray2.getMyArray(0);
        System.out.println(str);
    }
    //结果为：
    //123
    //onward
}

注意：

  • 类名后的 < T > 代表占位符，表示当前类是一个泛型类
    了解：【规范】类型形参一般使用一个大写字母表示，常用的名称有：
  • E 表示 Element
  • K 表示 Key
  • V 表示 Value
  • N 表示 Number
  • T 表示 Type
  • S、U、V等等表示第二、第三、第四个类型
  • 类型后加入< Integer >指定当前类型，编译器会在我们存放元素的时候进行类型检查。

泛型类的使用

语法

泛型类<类型实参> 变量名;		//定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参);		//实例化一个泛型类对象

示例

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型都必须使用包装类！

类型推导

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>();	//可以推导出实例化需要的类型实参为 Integer

裸类型(Raw Type)

说明

裸类型是一个泛型类但是没有带着类型实参，例如myArray就是一个裸类型

public class MyArray2 <T>{
    public Object[] myArray = new Object[10];

    public T getMyArray(int pos) {
        T value = (T)myArray[pos];
        return value;
    }

    public void setMyArray(int pos, T value) {
        this.myArray[pos] = value;
    }
}

public class Test {

    public static void main(String[] args) {
        MyArray2 myArray = new MyArray2();    //裸类型
        myArray.setMyArray(0,12);
        myArray.setMyArray(1,"onward");
        int num = (int)myArray.getMyArray(0);
        String str = (String) myArray.getMyArray(1);
        System.out.println(num);
        System.out.println(str);
    }
    //结果为：
    //12
    //onward
}

注意：我们尽量不要去使用裸类型，裸类型是为了兼容老版本的API保留的机制
小结：

  • 泛型是将数据类型参数化，进行传递。
  • 使用< T >表示为当前类是一个泛型类。
  • 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

泛型如何编译的

擦除机制

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
java的泛型机制是在编译级别实现的，编译器生成的字节码在运行期间并不包含泛型的类型信息。
有关擦除机制的文章介绍我们可以参考：链接: Java泛型擦除机制之答疑解惑

泛型的上界

在定义泛型类时，有时需对传入的类型变量做一定的约束，可以通过类型边界来约束。

语法

class 泛型类名称<类型实参 extends 类型边界>{
	...
}

示例

public class MyArray2 <E extends Number>{
    public Object[] myArray = new Object[10];

    public E getMyArray(int pos) {
        E value = (E)myArray[pos];
        return value;
    }

    public void setMyArray(int pos, E value) {
        this.myArray[pos] = value;
    }
}

只接受Number的子类型作为E的类型实参

public class Test {

    public static void main(String[] args) {
        MyArray2<Integer> myArray = new MyArray2<Integer>();
        //正常，因为Integer是Number的子类型   
        myArray.setMyArray(0,123);  
        myArray.setMyArray(1,12);
        int num = myArray.getMyArray(0);   
        System.out.println(num);

        MyArray2<String> myArray2 = new MyArray2<String>(); 
        //编译报错：java: 不兼容的类型: java.lang.String无法转换为java.lang.Number，因为String不是Number的子类型
        myArray2.setMyArray(0,"onward");
        myArray2.setMyArray(1,"forward");
        String str = myArray2.getMyArray(0);
        System.out.println(str);
    }
    //结果为：
    //123
    //onward
}

没有指定类型边界E，可以视为E extends Object

复杂示例

public class MyArray<E extends Comparable<E>>{
	...
}

E必须是实现了Comparable接口的

泛型方法

定义方法

方法限定符<类型形参列表> 返回值类型 方法名称(形参列表){...};

示例

需求：写一个泛型类。当中有个方法，可以求数组最大值

public class Alg <E>{
    public E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++) {
            if(array[i] > max){     //编译报错
                max = array[i];
            }
        }
        return max;
    }
}

上述代码会编译报错。由于擦除机制，在运行的时候类型E都会被擦除为Object类
类如果要比较大小，引用存的是地址，无法直接比较，要扩展Comparable接口，才能调用compareTo()方法。

public class Alg <E extends Comparable<E>>{
    public E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++)
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,33,67,8,99,4};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMax(array));
    }
}

使用类型推导和不用类型推导

上述代码还可以这样写将继承接口写在方法上

public class Alg2 <E>{
    public <E extends Comparable<E>>E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++)
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,33,67,8,99,4};
        Alg2<Integer> alg2 = new Alg2<>();
        System.out.println(alg2.findMax(array));    //可以前面不写，会自动检查，类型推导
        System.out.println(alg2.<Integer>findMax(array));   //不使用类型推导
    }
}

静态的泛型方法

public class Alg3 <E>{
    //静态的泛型方法 需要在static后用<>声明泛型类型参数
    public static <E extends Comparable<E>> E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++)
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,33,67,8,99,4};
        System.out.println(Alg3.findMax(array));
    }
}

关于泛型和包装类我们先了解到这，对泛型的深入了解还需要一定时间的沉淀，才能对其有深刻的理解和掌握，道阻且长，我们一起努力！！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

IO模型---BIO、NIO、IO多路复用、AIO详解

IO模型---BIO、NIO、IO多路复用、AIO详解

本篇将想给详细解释一下什么是BIO、NIO、IO多路复用以及AIO~ 同步的阻塞(BIO)和非阻塞(NIO)的区别 BIO&#xff1a;线程发来IO请求后&#xff0c;一直阻塞着IO线程&#xff0c;需要缓冲区这边数据准备好之后&#xff0c;才会进行下一步的操作。 举个&#x1f330;&#xff1…
阅读更多...
UE5学习笔记21-武器的射击功能

UE5学习笔记21-武器的射击功能

一、创建C类 创建武器子弹的类&#xff0c;创建生产武器子弹的类&#xff0c;创建弹壳的类&#xff0c;生产武器子弹的类的父类是武器的类 创建后如图&#xff0c;ProjectileMyWeapon类(产生子弹的类)继承自weapon类&#xff0c;Projectile(子弹的类)&#xff0c;Casing(弹壳声…
阅读更多...
如何使用QT完成记事本程序的UI界面布局

如何使用QT完成记事本程序的UI界面布局

每日QT技巧查询表-CSDN博客 会持续更新记事本编写的全部过程&#xff0c;关注不迷路 一、相关控件 ①水平和垂直布局 ②按键 ③文本框 ④水平弹簧 ⑤标签 ⑥Widget 二、控件使用方法 1、PushButton 拖出三个按键&#xff0c;并对其进行命名&#xff0c;两处地方命名可以不一…
阅读更多...
【Echarts】vue3打开echarts的正确方式

【Echarts】vue3打开echarts的正确方式

ECharts 是一个功能强大、灵活易用的数据可视化工具&#xff0c;适用于商业报表、数据分析、科研教育等多种场景。那么该如何优雅的使用Echarts呢? 这里以vue3为例。 安装echarts pnpm i echarts封装公用方法 // ts-nocheck import * as echarts from echarts; // 我们这里借…
阅读更多...
C++：入门基础

C++：入门基础

一.C参考文档 https://legacy.cplusplus.com/reference/ https://zh.cppreference.com/w/cpp https://en.cppreference.com/w/ 二.C的第一个程序 #include <iostream> using namespace std;int main() {cout << "Hello world!" << en…
阅读更多...
无人机PX4飞控ROS应用层开发：MAVROS 功能包介绍与飞控消息汇总（一）

无人机PX4飞控ROS应用层开发：MAVROS 功能包介绍与飞控消息汇总（一）

概述 这个软件包提供了针对各种自动驾驶仪(如PX4,Ardupilot)使用 MAVLink 通信协议的通信驱动程序。 此外&#xff0c;它还提供了用于地面控制站&#xff08;例如 QGroundControl&#xff09;的 UDP MAVLink 桥接功能。 通常与PX4的offboard模式联合使用 Offboard控制背后的想…
阅读更多...
单机docker-compose部署minio

单机docker-compose部署minio

单机多副本docker-compose部署minio 简单介绍 如果服务器有限可以单机挂载多硬盘实现多副本容错&#xff08;生产不推荐&#xff09; 部署好的文件状态 有两个重要文件 docker-compose.yaml和nginx.conf docker-compose.yaml是docker部署容器的配置信息包括4个minio和1个ng…
阅读更多...
c中 int 和 unsigned int

c中 int 和 unsigned int

c语言中&#xff0c;char、short、int、int64以及unsigned char、unsigned short、unsigned int、unsigned int64等等类型都可以表示整数。但是他们表示整数的位数不同&#xff0c;比如&#xff1a;char/unisigned char表示8位整数&#xff1b; short/unsigned short表示16位整…
阅读更多...
菜鸟入门Docker

菜鸟入门Docker

初始Docker Docker的概念 Docker的用途 DOcke的安装 Docker架构 配置Docker镜像加速器 Docker常用命令 Docker服务相关的命令。 Docker镜像相关的命令 Docker容器相关的命令 容器的数据卷 数据卷的概念和作用 配置数据卷 Docker应用部署 Docker部署mysql Docker…
阅读更多...
Unity同时启动多个Editor

Unity同时启动多个Editor

HardLinkShellExt tool https://schinagl.priv.at/nt/hardlinkshellext/linkshellextension.html 作用&#xff1a; 1.网络Online项目方便调试&#xff0c;MMO项目 2.方便发布不同平台的包&#xff0c;快速开发测试 使用方法&#xff1a;
阅读更多...
easy-es动态索引支持

easy-es动态索引支持

背景 很多项目目前都引入了es&#xff0c;由于es弥补了mysql存储及搜索查询的局限性&#xff0c;随着技术的不断迭代&#xff0c;原生的es客户端使用比较繁琐不直观&#xff0c;上手代价有点大&#xff0c;所以easy-es框架就面世了&#xff0c;学习成本很低&#xff0c;有空大…
阅读更多...
【Gateway】Gateway Filter Factories

【Gateway】Gateway Filter Factories

Predicate决定了请求由哪一个路由处理,如果在请求处理前后需要加一些逻辑,这就是Filter(过滤器)的作用范围了.Filter分为两种类型:Pre类型和Post类型 滤器的两种类型 Pre 类型过滤器: 执行时机: 在请求被转发到后端服务之前执行。作用: 可以用来执行鉴权、限流、请求日志记录、…
阅读更多...
Django笔记一：搭建Django环境与URL路径访问

Django笔记一：搭建Django环境与URL路径访问

博主之前学从Java后端开发&#xff0c;后面获取到读研资格&#xff0c;想着未来转算法岗&#xff0c;初学Python&#xff0c;发现Python还挺有趣的&#xff0c;由于之前所学后端缘故&#xff0c;有点后端情节&#xff0c;想学习一下Django框架&#xff08;python的web框架&…
阅读更多...
什么是交换机级联？

什么是交换机级联？

在现代计算机网络中&#xff0c;交换机级联是一种广泛应用的技术&#xff0c;有助于提升网络的扩展性和灵活性。本文将深入探讨交换机级联相关知识&#xff0c;详细介绍其基本概念和连接配置方法&#xff0c;并对常见技术问题进行解答。 交换机级联概述 交换机级联是指通过将…
阅读更多...
线性基大发现

线性基大发现

一.构造方法 1.贪心法&#xff08;每一个数往里插入即可&#xff09; /*贪心法构造线性基的特点&#xff1a; 1.从小到大排列 2.各个基的高位可能存在重复的1 2.线性基不是唯一的&#xff0c;与原集合的元素顺序有关*/ void insert(int x){//贪心法for(int i63;i>0;i--){i…
阅读更多...
c#中给winform定义快捷键的几种方式

c#中给winform定义快捷键的几种方式

快捷键的使用在日常的开发中频率比较高&#xff0c;这里总结了最常见的各种快捷键的设置方式&#xff0c;需要的时候大家直接照抄就可以了&#xff0c;不用再去查询如何实现了。 文章目录 一、按钮快捷键二、菜单快捷键三、全局快捷键1、重写ProcessCmdKey2、使用KeyPreview属…
阅读更多...
Word使用手册

Word使用手册

修改样式 编辑word文档时&#xff0c;标题和正文文本通常有不同的格式&#xff0c;如果能将这些格式保存为样式&#xff0c;下一次就能直接调用样式&#xff0c;而不需要重复手动设置格式。 可以将样式通常保存为不同的 样式模板.docx&#xff0c;要调用不同样式集&#xff0…
阅读更多...
MATLAB基础应用精讲-【数模应用】卡方拟合优度检验（附MATLAB、python和R语言代码实现）

MATLAB基础应用精讲-【数模应用】卡方拟合优度检验（附MATLAB、python和R语言代码实现）

目录 前言 几个高频面试题目 卡方分布与拟合优度的卡方检验是什么关系？ 算法原理 什么是卡方检验 卡方是什么？ 如何使用卡方表计算器？ 什么是卡方拟合优度检验 使用条件 基本原理 数学模型 卡方检验自由度 理论频数计算 需要注意的事项 卡方检验分类 1、 独…
阅读更多...
校园管理系统创新：Spring Boot框架应用案例

校园管理系统创新：Spring Boot框架应用案例

第4章 系统设计 4.1 系统体系结构 校园管理系统的结构图4-1所示&#xff1a; 图4-1 系统结构 登录系统结构图&#xff0c;如图4-2所示&#xff1a; 图4-2 登录结构图 校园管理系统结构图&#xff0c;如图4-3所示。 图4-3 校园管理系统结构图 4.2开发流程设计 系统流程的分…
阅读更多...
走进低代码表单开发（一）：可视化表单数据源设计

走进低代码表单开发（一）：可视化表单数据源设计

在前文&#xff0c;我们已对勤研低代码平台的报表功能做了详细介绍。接下来&#xff0c;让我们深入探究低代码开发中最为常用的表单设计功能。一个完整的应用是由众多表单组合而成的&#xff0c;所以高效的表单设计在开发过程中起着至关重要的作用。让我们一同了解勤研低代码开…
阅读更多...
最新文章

Copyright @ 2022~2023