详解Java【泛型】

1 为什么使用泛型

普通的类和方法，只能使用具体的类型，比如基本类型或者自定义的类，如果要应用多种类型的代码，就非常的不方便。

而从JDK1.5后，引入了泛型这个概念，泛型和函数的区别就是

函数传参传的是值，而泛型传的是类型，这样泛型就适用于许多许多类型，也就是将类型当做了参数

2 泛型的语法

⚜️在写泛型语法之前，我们先思考一下，

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

简单分析一下吧

正常的数组是只能存放指定类型元素的值，但我们学过了，所有类的父类，默认都是Object类型的，那么数组可以为Object吗，下面我们来浅浅的试一下

创建一个类

** 注意看，我们将数组类型设置成Object后没有报错，说明是可行的**

然后我们开始存放数据，并且获取下标元素的值

** 这里我们可以，强制类型转化一下**

** 虽然说，这样数组任何类型也可以存放，但是感觉不太方便，而且条理比较混乱，**

所以还是想让他只有一种数据类型，此时，我们就一个是考虑泛型了，

泛型存在的意义，就是指定当前的容器，然后想要什么类型的对象，让编译器去检查，把想要的类型，当做参数去传递。

下面直接上语法吧

class 泛型类名称<类型形参列表> {
    //这里可以使用类型参数
}

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

class 泛型类名称<类型形参列表> extends 继承类/*这里可以是类型参数*/ {
    //这里可以使用类型参数
}

class ClassName<T1,T2...,Tn> extends ParentClass<T1> {
    //这里可以使用部分类型参数
}

然后，现在把刚刚那个问题代码修改一下，引入泛型试试看效果

先写一个泛型类

//<T>代表当前类是泛型类
class MyArray2<T> {
    
    public T[] array = (T[])new Object[10];
    public T getPos(int pos) {
        return array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}

**下面我们在<>中指定类型，此时就只能存放这个数据类型的数据了 **

    public static void main(String[] args) {
        //<>中指定类型,此时这个类里面，只能放这个数据类型的数据
        MyArray2<String> myArray = new MyArray2<String>();
        myArray.setVal(0,"nb");
        myArray.setVal(1,"xawl");

        String s =  myArray.getPos(1);
        String s1 = myArray.getPos(0);
        System.out.println(s);
        System.out.println(s1);
    }

** 我们比如在定义一个Integer类型的**

        MyArray2<Integer> myArray2 = new MyArray2<Integer>();
        myArray2.setVal(0,12);
        myArray2.setVal(1,13);
        Integer I = myArray2.getPos(0);
        System.out.println(I);

例子就写到这里

下面说一下泛型类语法

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

注意事项：

（1）类名后的<T>叫占位符,意思就是当前的类是泛型类

（2）不需要进行强制类型转化

（3）Java中，不可以new泛型类型的数组

** （4）注意<>中必须要引用类型**

**否则，就会报错 **

（5）泛型类使用中可以省略类型实参的填写

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

这是因为，编译器可以推导出实例化需要的类型实参为Integer

3.泛型的编译步骤

3.1 擦除机制

擦除机制就是，在编译的过程中，将泛型T替换为Object

并且擦除机制就是编译时期的一种机制，运行期间没有泛型这个概念

3.2 不可以实例化泛型类型数组

思考这样一个例子

既然所有的T都替换为Object，那为什么这样就不可以写

下面看一下这个例子你就明白了

** ⚜️ 那为什么不能被转化呢？**

很简单Object数组中存在很多的类型，然后此时你用Integer来转化很多种类型，那肯定是不行的，编译器从安全考虑不会让你通过的，

** 所以我们正确的应该是这样做**

package Demo01;

import java.lang.reflect.Array;
import java.util.Arrays;
class MyArray<T> {
    public T[] array;
    
    public MyArray(Class<T> clazz, int capacity) {
        array = (T[]) Array.newInstance(clazz,capacity);
    }
    public T[] getArray() {
        return array;
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
    public T getPos(int pos) {
        return this.array[pos];
    }
}
public class Test01 {
    public static void main(String[] args) {//指定数组类型是Integer
        MyArray<Integer> myArray = new MyArray<>(Integer.class,10);
        myArray.setVal(0,10);
        Integer[] tmp = myArray.getArray();
        System.out.println(Arrays.toString(tmp));
    }
}

4.了解裸类型

下面看一下这个

我们写了一个泛型类，但是并没有带参数类型，而且也没报错，那么我们把这个叫做裸类型

** 这里说明裸类型，是为了兼容老版本的API保留机制，我们不要自己去使用裸类型**

5.泛型的上界

语法格式

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

......

}

** 下面思考一下，如果要写一个泛型类，找数组中的最大值，应该怎么做**

首先，肯定是直接比较不了的，因为T是引用数据类型，引用类型比较要用比较器

所以，

** 这里也可以看到Comparable也是个泛型接口**

所以泛型类可以这样写

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

6.泛型方法

语法格式

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

直接上例子

在前面我们找数组中的最大值，是在泛型类中写了一个方法，来实现的

** 要调用这个方法，就必须要有个对象，如果不想有这个对象，那就可以把这个方法变成静态的就可以了，所以还有一种方法是**

⚜️ 可以把这个方法写成静态的，然后放在普通类中

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

** ⚜️ 还有个方法是，继续写一个泛型方法，只不过这个方法也是成员方法**

class Alg3 {
    //泛型方法：成员方法
    public <T extends Comparable<T>> T findMaxVal2(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 static void main(String[] args) {
        Alg3 alg3 = new Alg3();
        Integer[] array = {100,200,24,34,55};
        int val = alg3.findMaxVal2(array);
        System.out.println(val);
    }

7.通配符（?）

7.1 理解通配符

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

协变****指的是如果child是parent的子类，那么List<Child>也应该是List<Parent>的子类。但是泛型是不支持这样的父子类关系的。

这是因为

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 Test01 {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        System.out.println(myArray);
        MyArray<String> myArray2 = new MyArray<>();
        System.out.println(myArray2);
    }
}

🤠 可以看到<>尖括号中的内容，不参与类型的组成。

所以在泛型中List<Child>不是List<Parent>的子类

下面看一个例子

class Message<T> {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class Test02 {
    public static void main(String[] args) {
        Message<String> message = new Message() ;
        message.setMessage("xawl");
        fun(message);
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

⚜️ 如果说此时泛型的类型不是String而是Integer

** 🤠 所以这里就希望的是可以接收所有的泛型类型，但是又不能够让用户随意修改。这样就需要使用通配符‘’？‘’来解决**

    public static void fun(Message<?> temp){
        System.out.println(temp.getMessage());
    }

所以通配符“？”表示，可以接收任意类型

在泛型中只有上界，没有下界

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

？extends类：设置通配符上界

？super类：设置通配符下界

7.2 通配符上界

语法：

Vector<? extends 类型1> x = new Vector<类型2>();

类型1指定一个数据类型，那么类型2就只能是类型1或者是类型1的子类：

Vector<? extends Number> x = new Vector<Integer>();

下面看一个例子

class Food {}
class Fruit extends Food {}
class Apple extends Fruit {}
class Banana extends Fruit {}
class Test<T> { // 设置泛型上限
    private T val ;
    public T getVal() {
        return val;
    }

    public void setVal(T Val) {
        this.val = val;
    }
}
public class Test03 {
    public static void main(String[] args) {
        Test<Apple> test = new Test<>() ;
        test.setVal(new Apple());
        fun(test);
        Test<Banana> test2 = new Test<>() ;
        test2.setVal(new Banana());
        fun(test2);
    }
    //只要是Fruit或者Fruit的子类即可
    public static void fun(Test<? extends Fruit> temp){
         System.out.println(temp.getVal());
    }
}

⚜️ 如果此时在fun函数中对temp添加元素，就会报错

** 这是因为temp接收的是Fruit和他的子类，此时存储的元素应该是哪个子类无法确定，所以添加元素就会报错，所以只能获取元素**

*总结：***通配符的上界，不能进行写入数据，只能进行读取数据。 **

7.3 通配符下界

语法：

Vector<? super 类型1> x = new Vector<类型2>();

**类型1指定一个数据类型，那么类型2就只能是类型1或者是类型1的父类： **

Vector<? super Integer> x = new Vector<Number>();

下面看一个例子：

class Food {}
class Fruit extends Food {}
class Apple extends Fruit {}
class Banana extends Fruit {}
class Test<T> { // 设置泛型上限
    private T val ;
    public T getVal() {
        return val;
    }
    public void setVal(T Val) {
        this.val = val;
    }
}
public class Test03 {
    public static void main(String[] args) {
        Test<Fruit> test = new Test<>() ;
        test.setVal(new Fruit());
        fun2(test);
        Test<Food> test2 = new Test<>() ;
        test2.setVal(new Food());
        fun2(test2);
    }
    public static void fun2(Test<? super Fruit> temp){
        System.out.println(temp.getVal());
    }

⚜️ 如果此时在fun2函数中对temp添加元素，还会报错吗

    public static void fun2(Test<? super Fruit> temp){
      // 此时可以修改！！添加的是Fruit 或者Fruit的子类
        temp.setVal(new Apple());//这个是Fruit的子类
        temp.setVal(new Fruit());//这个是Fruit的本身
        // Fruit fruit = temp.getMessage(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getVal());//只能直接输出
    }

*总结：***通配符的下界，不能进行读取数据，只能进行写入数据。 **

8.包装类

8.1基本数据类型对应包装类

在java中，因为基本类型不是继承Object，为了在泛型代码中可以支持基本类型，java给每个基本类型都搞了一个包装类型。
基本数据类型
包装类
byteByteshortShortint****IntegerlongLongfloatFloatdoubleDoublechar****CharacterbooleanBoolean

8.2 装箱和拆箱

装箱：

    public static void main(String[] args) {
        int a = 20;
        Integer integer = a;//自动装箱

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

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

        System.out.println(integer);
        System.out.println(integer2);
        System.out.println(integer3);
    }

⚜️ 下面看一下，自动装箱的字节码文件

拆箱：

    public static void main(String[] args) {
        int a = 30;
        Integer integer  = a;

        int val = integer;//自动拆箱
        System.out.println(val);

        int val2 = integer.intValue();//显示拆箱
        System.out.println(val2);

        double val3 = integer.doubleValue();//显示拆箱
        System.out.println(val3);
    }

⚜️ 下面看一下，自动拆箱的字节码文件