AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

包装类&认识泛型

2024-05-28 47
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 包装类&认识泛型

一、包装类

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

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

1.2 装箱和拆箱

        //装箱：将一个基本数据类型转换为引用数据类型
        int a=10;
        Integer value=a;//自动装箱
        Integer value1=Integer.valueOf(20);//显示装箱
        Integer value2=new Integer(20);//显示装箱
        System.out.println(value+" "+value1+" "+value2);
 
        //拆箱：将Integer对象中的值取出，放到一个基本数据类型中
        int num=value1;//自动拆箱
        int num1=value1.intValue();

在上述使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者负担，Java提供了自动机制。

面试题

    public static void main(String[] args) {
        Integer a=127;
        Integer b=127;
        System.out.println(a==b);
        Integer c=128;
        Integer d=128;
        System.out.println(c==d);
        Integer e=Integer.valueOf(2);
    }
 
//结果：
true
false

上述结果输出不同是因为在装箱过程中返回的引用类型不一样：

二、泛型

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

2.1 语法

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

代码实现：

class MyArray<T>{
    //T[]kk=new T[10];//语法错误，泛型当中不能实例化泛型类型的数组
    public T[]array=(T[])new Object[10];
    public T getPos(int pos){
        return this.array[pos];
    }
    public void setArray(int pos,T val){
        this.array[pos]=val;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer>myArray=new MyArray<>();//1 <Integer>指定当前类型
        myArray.setArray(0,1);
        //myArray.setArray(1,"akai");//此时因为在注释1处指定类当前类型，此时编译器会在存放元素时帮助我们进行类型检查
        System.out.println(myArray.getPos(0));
    }
}

代码解释：

1.类名后的<T>代表占位符，表示当前类是一个泛型类

了解：【规范】类型形参一般使用一个大写字母，常用的名称有：

·E表示Element

·K表示Key

·V表示Value

·N表示Number

·T表示Type

·S,U,V 等等-第二、第三、第四个类型

三、泛型类的使用

3.1 语法

泛型类<类型实参>变量名；//定义一个泛型类引用

new 泛型类<类型实参>（构造方法实参）；//实例化一个泛型类对象

3.2 示例

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

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

3.3 类型推导

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

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

3.4 裸类型

裸类型是一个泛型类但没有类型实参，例如：

MyArray list=new MyArray();

注：裸类型是为了兼容老版本的API保留的机制下面的类型擦除部分

小结：

1.泛型是将数据类型参数化，进行传递

2.使用<T>表示当前类是一个泛型类。

3.泛型类目前位置的优点：数据类型参数化，编译时自动进行类型检查和转换

四、泛型如何编译的

4.1 擦除机制

在编译过程当中，将所有的T替换为Obeject这种机制，我们成为：擦除机制。

Java的泛型机制是在编译级别实现的。编译器生成的字节码文件但在运行期间并不包含泛型的类型信息。


4.2 为何不能实例化泛型类型数组

class MyArray<T>{
    public T[]array=(T[])new Object[10];
 
    public T getPos (int pos){
        return this.array[pos];
    }
    public void setVal(int pos,T val){
        this.array[pos]=val;
    }
    public T[]getArray(){
        return array;
    }
}
 
public class Test {
    public static void main(String[] args) {
        MyArray<Integer>myArray1=new MyArray<>();
        Integer[]Strings =myArray1.getArray();
    }
}
 
/*Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;
        at Test.main(Test.java:27)*/

原因：替换后的方法为（由于运行时没有泛型机制，因此擦除机制在编译时期将T转换为Object）：将Object[]分配给Intefer[]引用，程序报错。

public Object[]getArray{
  return array;
}

通俗讲就是：返回的Object数组里面，可能存放的是任何的数据类型，可能是String，可能是Person,运行的时候，直接转给Integer类型的数组，编译器认为是不安全的。

正确的使用方法：【了解即可】

class MyArray<T> {
    public T[] array;
    public MyArray() {
    } 
    //涉及到映射
    public MyArray(Class<T> clazz, int capacity) {
        array = (T[]) Array.newInstance(clazz, capacity);
    }
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
    public T[] getArray() {
        return array;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10);
        Integer[] integers = myArray1.getArray();
    }
}

泛型的常用方法：

public  Objiect[] obj=new Object [3];
 
public E getPos(int pos){
    return (E)obj[pos];
}

五、泛型的上界

5.1 语法

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

5.2 示例

1. public class MyArray<E extends Number>{
2.   ...
3. }

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


MyArray<Integer>a1;//正常，因为Integer 是Number的子类型


MyArray<String>a2;//编译错误，因为String 不是Number的子类型


注： 没有指定类型边界的E，会默认擦除为Object类型。

5.3 复杂示例

//class Alg<E> 1
//E必须是实现了Com[arable方法的
class Alg<E extends Comparable<E>>{
    public E findMax(E []array){
        E max=array[0];
        for (int i = 1; i < array.length; i++) {
            //if(max<array[i])
            //if(max.compareT0(array[i])<0) //此时 E 类型为object类型，object中没有compare方法  2
            if(max.compareTo(array[i])<0)
            max=array[i];
        }
        return max;
    }
}
 
public class Test {
    public static void main(String[] args) {
        Alg<Integer> alg=new Alg<>();
        Integer []array={1,3,5,6,2};
        Integer val=alg.findMax(array);
        System.out.println(val);
    }
}

六、泛型方法

6.1 定义语法

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

6.2 示例

public class Test {
    //返回类型可以为任意类型，E也可以
    public static <E> void swap(E[]array,int i,int j){
     E t=array[i];
     array[i]=array[j];
     array[j]=t;
    }
}

代码示例：

public class Test{
    //返回类型可以为任意类型，E也可以
    public static <E> void swap(E[]array,int i,int j){
     E t=array[i];
     array[i]=array[j];
     array[j]=t;
    }
 
    public static void main(String[] args) {
        Integer []a={1,3,5,6,2};
        Integer []b={2,3,2,1,5,6};
        //可以a的类型推导E，因此<>中可以省略
        Test.swap(a,2,3);
        Test.<Integer>swap(b,2,1);
        System.out.println(a[3]);
        System.out.println(b[1]);
    }
 
}

七、 通配符

？用于在泛型使用，即为通配符

7.1  通配符用于解决什么问题

class Message<T>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message=message;
    }
}
 
public class Common {
    public static void main(String[] args) {
        Message<String> message=new Message<>();
        message.setMessage("zhonghuizhaodaoni");
        func(message);
    }
    //如果此时泛型的类型设置的不是String，而是Integer,就会出现错误，而此时使用通配符 ? 就会很好的解决这个问题
    public static void func(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

在"?"的基础上产生了两个字通配符：

<? extends 上界>

<? extends Number> //可以传入的实参类型是Number或者Number的子类

7.2 通配符的上界

语法：

<? extends 上界>

<? extends Number> //可以传入的实参类型是Number或者Number的子类

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
 
}
class Plate<T>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message=message;
    }
}
public class Common {
    public static void main(String[] args) {
        
        Plate<Apple> plate=new Plate<>();
        plate.setMessage(new Apple());
        func(plate);
        
        Plate<Banana> plate1=new Plate<>();
        plate1.setMessage(new Banana());
        func(plate1);
    }
    //此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，多以无法修改
    public static void func(Plate<? extends Fruit> temp){
        //temp.setMessage(new Banana());//仍然无法修改
        //temp.setMessage(new Apple());//仍然无法修改
        System.out.println(temp.getMessage());
    }
}

此时无法确定fun函数中对temp进行设置元素，因为temp接收的是Fruit和它的子类，此时存储的元素应该是哪个子类无法确定。所以添加会报错！但是可以获取元素。

    public static void func(Plate<? extends Fruit> temp){
        //temp.setMessage(new Banana());//仍然无法修改
        //temp.setMessage(new Apple());//仍然无法修改
        //System.out.println(temp.getMessage());
        Fruit b=temp.getMessage();
        System.out.println(b);
    }

通配符的上界，不能进行写入数据，只能进行读取数据。

8.3 通配符下界

语法：

<? super 下界>

<? super Integer> //代表可以传入的实参的类型是Integer或者Integer的父类类型

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
 
}
class Plate<T>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message=message;
    }
}
public class Common {
    public static void main(String[] args) {
 
        Plate<Fruit> plate=new Plate<>();
        plate.setMessage(new Fruit());
        func(plate);
 
        Plate<Apple> plate1=new Plate<>();
        plate1.setMessage(new Apple());
        //func(plate1);//添加的必须是Fruit或者其父类
    }
    //此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，多以无法修改
    public static void func(Plate<? super Fruit> temp){
        //此时可以修改！添加的是Fruit或者Fruit的子类，所以可以向上转型
        temp.setMessage(new Banana());
        temp.setMessage(new Fruit());
        //temp.setMessage(new Food());//添加失败，因为若是Fruit的父类，则需要向下转型，向下转型是不安全的
        //Fruit fruit=  temp.getMessage();//不能接收，这里无法确定是哪个父类，需要向下转型为Fruit,此时也是不安全的
        System.out.println(temp.getMessage());//只能直接输出
    }
}

通配符的下界，不能进行读取数据，只能写入数据

文章标签：
Java
编译器
API
存储
开发者
游客jajxe3foty4uc
目录
相关文章
断墨寻径
|
Java
包装类的使用
包装类的使用
断墨寻径
64 0
灰灰快醒醒
|
7月前
|
Java 编译器 语音技术
包装类&简单认识泛型
包装类&简单认识泛型
灰灰快醒醒
68 0
豫下洛子-26139
|
存储 Java
包装类和基本数据类型
包装类和基本数据类型
豫下洛子-26139
73 0
Leader_TBlog
|
缓存
包装类
包装类
Leader_TBlog
73 0
泡芙-草莓
|
7月前
什么是泛型,泛型的具体使用？
什么是泛型,泛型的具体使用？
泡芙-草莓
39 0
&amp;ACE&amp;
|
7月前
|
Java
什么是泛型, 泛型的具体使用
什么是泛型, 泛型的具体使用
&amp;ACE&amp;
37 0
juvenile。。。
|
7月前
|
存储 Java
什么是泛型, 泛型的具体使用?
什么是泛型, 泛型的具体使用?
juvenile。。。
51 0
JamieChyi
|
缓存 Java
基本数据类型包装类
基本数据类型包装类
JamieChyi
67 0
wljslmz
|
安全 Java
包装类与泛型，到底区别在哪？
包装类与泛型，到底区别在哪？
wljslmz
106 0
wb7zts3t7svdo
|
存储 Java 编译器
包装类和泛型
包装类和泛型
wb7zts3t7svdo
123 0
包装类和泛型

热门文章

最新文章

  • 1
    四大触点，教你从“用户视角”构建数据分析体系
  • 2
    Spring-boot+Dubbo应用启停源码分析
  • 3
    《Stata统计分析与应用（第2版）》一3.4 图形的保存、合并及修改
  • 4
    RocketMq-Request-Reply消息
  • 5
    Confluence 6 手动添加用户
  • 6
    2013年4月20日 通用权限管理系统组件V3.8功能改进说明
  • 7
    Configuring EIGRP Unequal-Cost Paths
  • 8
    PowerShell 指定关键词遍历文件内容
  • 9
    Windows时间服务出现故障 向用户发送错误的时间
  • 10
    三种dedecms调用相关文章的方法
  • 1
    《鸿蒙HarmonyOS应用开发从入门到精通（第2版）》简介
    38
  • 2
    《Python 助力：人工智能模型的“瘦身”与“加速”之旅》
    102
  • 3
    《非计算机专业者：Python 开启人工智能职业新航道》
    29
  • 4
    《Python赋能：智绘智慧城市新蓝图》
    34
  • 5
    《智育新篇：点亮学生人工智能伦理与社会责任之光》
    36
  • 6
    《数据主权：人工智能时代的核心基石与挑战》
    25
  • 7
    鸿蒙HarmonyOS应用开发 | 探索 HarmonyOS Next-从开发到实战掌握 HarmonyOS Next 的分布式能力
    102
  • 8
    鸿蒙原生开发环境的创新与性能优化：从工具到跨平台支持的全方位提升
    254
  • 9
    鸿蒙HarmonyOS应用开发 | 「鸿蒙技术分享」HarmonyOS NEXT元服务卡片实战体验
    149
  • 10
    Qwen-Coder：通过Qwen 2.5模型实现智能代码生成的技术实践
    32

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    DataWorks