Java泛型详解-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_74007393/article/details/127311868

1什么是泛型？

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的
代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数
化。

2 引出泛型

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

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;
    }
}
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);
    }
}

在这里插入图片描述

因为myArray.getPos(1)是Object类型，而返回值为String类型，这时候我们只需要对它进行强制类型转换就好了。

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

问题：以上代码实现后发现

任何类型数据都可以存放
1号下标本身就是字符串，但是确编译报错。必须进行强制类型转换

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。**所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。**此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

上述代码进行改写：

/**
 * @param <T> 标志位:   代表当前类是泛型类
 */
class MyArray<T>{
//    public Object[] array = new Object[10];
    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 class Test {
    public static void main(String[] args) {
        //1、<> 里面指定了类型，说明此时这个类里面，只能放这个数据类型的数据
        MyArray<Integer> myArray1 = new MyArray<Integer>();
        MyArray<String> myArray2 = new MyArray<String>();
        myArray1.setVal(0,10);
        myArray2.setVal(0,"hello");
        int ret1 = myArray1.getPos(0);
        String ret2 = myArray2.getPos(0);
        System.out.println(ret1);
        System.out.println(ret2);
    }
}

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

到这里我们应该了解了

尖括号当中的类型是什么意思？

        MyArray<Integer> myArray1 = new MyArray<Integer>();
        MyArray<String> myArray2 = new MyArray<String>();

其实就是对Object数组中元素类型的限制
2. 当指定类型之后，编译器会根据指定的类型参数来进行检查
3. 当我们再次取元素的时候就不需要像前面一样强制类型转换了
4. Java当中不可以new泛型类型的数组
5. 泛型的尖括号当中一定是引用类型

3. 裸类型

裸类型是一个泛型类但没有带着类型实参，例如之前我们写的 MyArrayList 就是一个裸类型

MyArray list = new MyArray();

注意：我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

4 泛型的上界

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

类型形参应该是类型边界或者类型边界的子类，类型形参 <= 类型边界

5 泛型方法

写一个泛型类, 找出数组当中的最大值, 只要这个T, 实现了这个接口就行

/**
 * 写一个泛型类, 找出数组当中的最大值, 只要这个T, 实现了这个接口就行
 * @param <T>
 */
class Alg<T extends Comparable<T>> {
    public T findMaxVal(T[] array) {
        T maxVal = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(maxVal) > 0) {
                maxVal = array[i];
            }
        }
        return maxVal;
    }
}

将上述类改写为静态方法:

class Alg2{
    public static<T extends Comparable<T>> T findMaxVal(T[] array) {
        T maxVal = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(maxVal) > 0) {
                maxVal = array[i];
            }
        }
        return maxVal;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {34, 56, 12, 41, 2, 5, 27};
        int val = Alg2.<Integer>findMaxVal(array);//手动指定类型
 //     int val = Alg2.findMaxVal(array);可以进行类型推导

        System.out.println(val);
    }
}

6. 包装类

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

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

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

除了 Integer 和 Character，其余基本类型的包装类都是首字母大写

6.2 装箱和拆箱

	int i = 10;
	// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
	Integer ii = Integer.valueOf(i);
	Integer ij = new Integer(i);
	// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
	int j = ii.intValue();

6.3 自动装箱和自动拆箱

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

    public static void main(String[] args) {
        int a = 10;
        Integer integer1 = a;//自动装箱  -->  底层调用的还是Integer.valueOf()

        Integer integer2 = new Integer(a);//显示装箱

        Integer ii = Integer.valueOf(a);//显示装箱
    }

7. 通配符

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

7.1 通配符解决什么问题

通配符是用来解决泛型无法协变的问题的，协变指的就是如果 Student 是 Person 的子类，那么 List 也应该是 List 的子类。但是泛型是不支持这样的父子类关系的。

泛型 T 是确定的类型，一旦你传了我就定下来了，而通配符则更为灵活或者说是不确定，更多的是用于扩充
参数的范围.

	public class TestDemo {
		public static void main(String[] args) {
			Message<Integer> message = new Message() ;
			message.setMessage(55);
			fun(message);
		}
		// 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
		public static void fun(Message<?> temp){
			//temp.setMessage(100); 无法修改！
			System.out.println(temp.getMessage());
		}
	}