JAVA SE 包装类和泛型

06-02 1126阅读

文章目录

📕1. 包装类

✏️1.1 基本数据类型和对应的包装类
✏️1.2 装箱和拆箱
✏️1.3 自动装箱和自动拆箱
📕2. 泛型

✏️2.1 泛型的语法
✏️2.2 泛型类的使用
✏️2.3 裸类型(Raw Type)
✏️2.4 擦除机制
✏️2.5 泛型的上界
✏️2.6 泛型方法

✏️2.7 通配符

📕1. 包装类

在JAVA中，共有8种基本类型，分别是byte,short,long,int,double,float,char,boolean.但由于JAVA是一门纯面向对象的语言，而且8种基本并非继承于Object类，为了在泛型代码中可以⽀持基本类型，于是JAVA提供了包装类。

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

除了 Integer 和 Character，其余基本类型的包装类都是⾸字⺟⼤写。

✏️1.2 装箱和拆箱

装箱：基本数据类型转换成包装类

int i = 10;
Integer ij = new Integer(i);
//装箱

拆箱：包装类转换成基本数据类型

int i = 10;
Integer ij = new Integer(i);
int j = ii.intValue();
//拆箱

💡注意：现在都使用自动拆箱和自动装箱！！！

✏️1.3 自动装箱和自动拆箱

为了减少开发者的负担，java 提供了⾃动机制。

自动装箱

 int i = 10;
 Integer j = i;//自动装箱

自动拆箱

Integer j = 10;
int a = j;//自动拆箱

❓提问：下述代码分别输出什么，为什么？

public class Test {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        Integer c = 128;
        Integer d = 128;
        Integer e = -129;
        Integer f = -129;
        System.out.println(a == b);//true
        System.out.println(c == d);//false
        System.out.println(e == f);//false
    }
}

💡注意：a和b是应用类型，==比较的是身份，比较值要重写equals方法进行比较。

答：[-128，127]这个范围数字比较是会出现true，其他数字比较则会出现false。原因是Integer中常用的数字被放到了常量池里，常用数字的范围是[-128，127].

📕2. 泛型

我们以前学过的数组，只能存放指定类型的元素，但是因为所有类的父类都是Object类，所以数组类型是否可以创建成Object呢？

class MyArray {
  	private Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0,10);
        myArray.setVal(1,"hello");//字符串也可以存放
        String ret = myArray.getPos(1);//编译报错
        System.out.println(ret);
    }
}
//1号下标本⾝就是字符串，但是确编译报错。必须进⾏强制类型转换

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望它只能够持有

⼀种数据类型。⽽不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有

什么类型的对象，让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传⼊

什么类型。

✏️2.1 泛型的语法

基础写法：

class 泛型类名称 {
	// 这⾥可以使⽤类型参数
}

其他写法：

class 泛型类名称 extends 继承类/* 这⾥可以使⽤类型参数 */ {
	// 这⾥可以使⽤类型参数
}

上述代码进⾏改写如下：

class MyArray {
    public Object[] array = new Object[10];
    public T getPos(int pos) {
        return (T)this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();//1
        myArray.setVal(0,10);
        myArray.setVal(1,12);
        int ret = myArray.getPos(1);//2
        System.out.println(ret);
        myArray.setVal(2,"小朱小朱");//3 编译报错！！！
    }
}

1. 注释1处，类型后加⼊指定当前类型

2. 注释2处，不需要进行强制类型转换

3. 注释3处，代码编译报错，此时因为在注释1处指定类当前的类型，此时编译器会在存放元素的时候帮助我们进行类型检查。

代码解释：

类名后的代表占位符，表⽰当前类是⼀个泛型类
【规范】类型形参⼀般使⽤⼀个⼤写字⺟表示，常⽤的名称有：
• E 表示Element
• K 表示 Key
• V 表示 Value
• N 表示 Number
• T 表示 Type
• S, U, V 等等 - 第⼆、第三、第四个类型

✏️2.2 泛型类的使用

泛型类 变量名; // 定义⼀个泛型类引⽤
new 泛型类(构造⽅法实参); // 实例化⼀个泛型类对象
MyArray list = new MyArray();

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

✏️2.3 裸类型(Raw Type)

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

MyArray list = new MyArray();

✏️2.4 擦除机制

在编译时，Java 编译器会将泛型类型信息从代码中移除，这个过程就叫做类型擦除。擦除后，泛型类型会被替换为其边界类型（通常是 Object）或者指定的类型。同时也会在必要的地方插⼊类型转换以保持类型安全。

擦除前：

class MyArray {
    public Object[] array = new Object[10];
    public T getPos(int pos) {
        return (T)this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}

擦除后：

class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos, Object val) {
        this.array[pos] = val;
    }
}

✏️2.5 泛型的上界

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

语法：

class 泛型类名称 {
...
}
public class MyArray {
...
}
//只接受 Number 的⼦类型作为 E 的类型实参

✏️2.6 泛型方法

语法：

⽅法限定符  返回值类型 ⽅法名称(形参列表）{...}

示例：

public class Util {
	//静态的泛型⽅法 需要在static后⽤声明泛型类型参数
	public static  void swap(E[] array, int i, int j) {
		E t = array[i];
		array[i] = array[j];
		array[j] = t;
	}
}

✏️2.7 通配符

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

请观察下述代码：

class Message {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class Test {
    public static void main(String[] args) {
        Message message = new Message() ;
        message.setMessage("欢迎来到小朱的CSDN");
        fun(message);
    }
    public static void fun(Message temp){
        System.out.println(temp.getMessage());
    }
}

以上程序会带来新的问题，如果现在泛型的类型设置的不是String，⽽是Integer.

public class TestDemo {
    public static void main(String[] args) {
        Message message = new Message() ;
        message.setMessage(99);
        fun(message); // 出现错误，只能接收String
    }
    public static void fun(Message temp){
        System.out.println(temp.getMessage());
    }
}

我们需要的解决方案：可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使

⽤通配符"?"来处理

public class TestDemo {
    public static void main(String[] args) {
        Message message = new Message() ;
        message.setMessage(55);
        fun(message);
    }
    // 此时使⽤通配符"?"描述的是它可以接收任意类型
    public static void fun(Message temp){
        System.out.println(temp.getMessage());
    }
}

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

通配符上界：

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们。