【数据结构】泛型

xxxflower

发布于 2023-04-16 17:43:22

2280

发布于 2023-04-16 17:43:22

文章被收录于专栏：《数据结构》《数据结构》

1.泛型

1.1泛型的引出

泛型：其实就是对类型的进行参数化 问题：实现一个类，类中有一个数组，使得数组中可以存放任意类型的数据我们可以把数组定义为Object.因为所有类都默认继承于Object。

但是：

因为不确定Object数组中的元素都是String类型，所以不能强制类型转化。如果Object里面的数据都是String，也不可以强转。

使用Object类的缺点： 1.在存放元素的时候，任何类型的数据都可以存放。 2.取出元素的时候，得自己判断（需要强制类型转换）。

1.2泛型

<T>：占位符：表示当前类是一个泛型类。

泛型存在的意义：

存放元素的时候，会进行类型的检查
在取出元素的时候，不需要强制转换。这两步都是在编译期间完成的。 运行的时候是没有泛型的概念的！！！泛型主要作用于编译的时候。是编译时期的一种机制。这种机制叫做擦除机制！！！！

泛型的语法为：

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}

一个泛型类的参数列表可以指定多个类型。尖括号中<一定必须是类类型，不能是基本类型>

【注意】：

类名后的代表占位符，表示当前类是一个泛型类了解：【规范】类型形参一般使用一个大写字母表示，常用的名称有： E 表示 Element K 表示 Key V 表示 Value N 表示 Number T 表示 Type S, U, V 等等 - 第二、第三、第四个类型
不能new泛型类型的数组
类型后加入指定当前类型
不需要进行强制类型转换
代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。 T[] ts = new T[5];//是不对的

2.泛型类的使用

2.1语法

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

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

3.裸类型

此时又和最初的Object一样了。

4.泛型是如何编译的？

4.1擦除机制

在编译的时候，我们把T都擦除成了Object。疑问：既然把T都擦除成了Object，那么为什么还要写成T呢？？？

因为：编译时自动进行类型转换。

存放元素的时候，会进行类型的检查
在取出元素的时候，不需要强制转换。

可以这样写：//涉及到反射

5.泛型的上界

5.1语法

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

5.2事例

原因： T是一个引用类型，不能用大于小于比较！！！那此处应该怎么做？？？

可以写成上述情况。此处：

这个就称为泛型的上界：T一定是实现了接口的 6dc47e9745f690f8baa1d4c1e32c.png)

class Alg<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 test2 {
    //写一个泛型类，类中有一个方法，求一个数组当中的最大值
    public static void main(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = {2,3,4,6};
        System.out.println(alg.findMax(array));
    }
}

class Alg<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;
    }

}
class Person implements Comparable<Person>{

    @Override
    public int compareTo(Person o) {
        return 0;
    }
}
public class test2 {

    public static void main(String[] args) {
        Alg<Person> alg = new Alg<>();
    }

    //写一个泛型类，类中有一个方法，求一个数组当中的最大值
    public static void main1(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = {2,3,4,6};
        System.out.println(alg.findMax(array));
    }
}

E一定是Number的子类或者Number本身

7.泛型方法

为什么这里加了static之后就报错了。

因为static不依赖对象。直接用Alg.findMax();去调用，就不会传递实参了。那应该怎么办呢？？？我们这样修改代码：

泛型方法：

泛型方法的语法：

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

class Alg{

    public static<T extends Comparable> 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 test2 {

    public static void main(String[] args) {
        Integer[] array = {1,2,3,4};
        System.out.println(Alg.<Integer>findMax(array));
    }