泛型你还不了解嘛

最新推荐文章于 2024-07-31 19:38:21 发布

cchen.835

最新推荐文章于 2024-07-31 19:38:21 发布

阅读量87

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_61392399/article/details/126624913

版权

Java 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

在前几篇博客将Java基础的语法进行了总结，之后我将更新有关数据结构有关知识的总结。

这篇博客就是来了解泛型的，这也是我们在学习数据结构之前的基础知识一起来看看吧

什么是泛型

泛型是在 JDK1.5 引入的新的语法，通俗讲，泛型： 就是适用于许多许多类型 。从代码上讲，就是对类型实现了参数化。

引出泛型

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

来看代码因为要存取任意元素所以我们使用Object类来实现

class MyArray{
    public Object[] array=new Object[10];

    public Object getPos(int pos) {//取出pos下标位置的值
        return array[pos];
    }
    public void setPos(int pos,Object val) {//pos下标放元素
        array[pos]=val;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray myArray=new MyArray();
        myArray.setPos(0,1);
        myArray.setPos(1,"hello");
        String ret=myArray.getPos(1);
    }
}

上述代码是有问题的在最后一行要想拿到元素必须强转

String ret=(String) myArray.getPos(1);

此时就出现了问题我们是希望能够自己指定类型并且不想使用强制类型转换

此时Java就提供了泛型来解决这个问题

1.语法

class 泛型类名称 < 类型形参列表 > {

// 这里可以使用类型参数

}

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

}

/*
* <T>表示占位符，表示当前类是一个泛型类
* */
class MyArray<T>{
    public T[] array=(T[])new Object[10];

    public T getPos(int pos) {//取出pos下标位置的值
        return array[pos];
    }
    public void setPos(int pos,T val) {//pos下标放元素
        array[pos]=val;
    }
}
public class Test {
    public static void main(String[] args) {
        /*
        * 1.指定当前类中使用的类型是Integer类型
        * 2.此时泛型做了两件事 
        *    1）存元素进行类型检查
        *    2）取元素进行类型转换
        * */
        MyArray<Integer> myArray=new MyArray<>();
        myArray.setPos(0,1);
        myArray.setPos(1,5);
        Integer ret = myArray.getPos(1);
    }
}

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查

2.注意

1.类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

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

2.不能new泛型类型的数组

T[] array = new T[10];//这种写法是不对的

public T[] array=(T[])new Object[10];

这个写法也不是很好为方便理解先这样写后续会修改的

泛型类使用

1.语法

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

new 泛型类 < 类型实参 > ( 构造方法实参 ); // 实例化一个泛型类对象

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

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

2.类型推导

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

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

泛型如何编译

1.擦除机制

通过命令打开字节码我们发现所有的T类型在编译过程中擦除为了Object类型这种机制，我们称为：擦除机制

我们来解释一下上面遗留的问题

2.为什么不能实例化泛型数组

public T[] array2=new T[10];

既然在编译的时候T替换成了Object为什么报错，原因在于Java的数组特殊

Object类型的数组无法给其他类型数组会报错

返回的Object数组里面，可能存放的是任何的数据类型，可能是String，可能是Person，运行的时

候直接转给Integer 类型的数组，编译器认为是不安全的

3.正确定义

/**
* 通过反射创建，指定类型的数组
* @param clazz
* @param capacity
*/
public MyArray(Class<T> clazz, int capacity) { 
    array = (T[])Array.newInstance(clazz, capacity);
 }

此处涉及到反射简单了解在之后会解释

泛型上界

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

我们来看代码，通过使用泛型实现一个找数组最大值的代码

class Alg1<T extends Comparable<T>>{
    public T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(max.compareTo(array[i])<0) {
                max=array[i];
            }
        }
        return max;
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Alg1<Integer> alg1=new Alg1<>();
        Integer[] array={1,2,3,4,5,10,29,11};
        Integer ret=alg1.findMax(array);
        System.out.println(ret);
    }
}

我简单解释一下

我们在比较元素大小直接使用符号比较会报错，因为是引用类型所以就要实现Comparable接口

重写CompareTo()方法来比较，又因为擦除机制会擦除为Object类型而Object类型中没有CompareTo()方法所以就需要使用泛型的上界限制这个类是实现了Comparable才能进行比较

泛型没有下界

泛型方法

在上面的代码中如果不想实例化对象直接使用findMax()方法就需要实现静态方法

 /*
    * 静态泛型方法
    * */
    public static<T extends Comparable<T>>  T findMAx(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }

这里要注意静态方法直接类名.方法名所以要将泛型类型参数放到stataic后

通配符

通配符是用来解决泛型无法协变的问题的

此时要注意因为通配符的出现接收的类型不确定所以无法修改

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

? extends 类：设置泛型上限

? super 类：设置泛型下限

<? extends 上界 >

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

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

<? super 下界 >

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

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

包装类

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

1.基本数据类型对应的包装类

基本数据类型	byte	short	int	long	float	double	char	boolean
包装类	Byte	Short	Integer	Long	Float	Double	Character	Boolean

装箱：将基本数据类型转换为包装类（装包）

1.自动装箱 2.手动装箱

int a=100;
Integer b=a;//自动装箱
Integer c=Integer.valueOf(a);//手动装箱

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

Integer a=100;
int b=a;//拆箱
double c=Double.valueOf(a);

2.面试题

下列代码输出什么，为什么？

public static void main(String[] args) {
        Integer a = 127; 
        Integer b = 127; 
        Integer c = 128; 
        Integer d = 128; 
        System.out.println(a == b); 
        System.out.println(c == d);
    }

一个是true另一个是false 为什么我来解释一下首先我们要清楚代码发生了装箱，所以就看看源码