包装类&认识泛型

秃头的赌徒

已于 2023-12-03 23:11:56 修改

阅读量223

点赞数

分类专栏： JAVA SE 文章标签： java jvm 开发语言

于 2023-02-14 10:20:17 首次发布

本文链接：https://blog.csdn.net/weixin_70564024/article/details/128568898

版权

JAVA SE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、包装类

定义：在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 示例

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

此时只接受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 定义语法

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

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());//只能直接输出
    }
}

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