Java泛型

今天我们浅浅了解一下泛型
泛型：
1.定义：就是适用于许多类型，对类型实现了参数化

2.大白话理解： 这样说吧，先让你看一下他多么的🐂，就是说你创建一个数组，然后这个数组可以存放任意类型，第一个位置放整数，第二个位置放小数，第三个位置放字符串......是不是很秀！（虽然可以这样，但泛型实际不是这样应用的，其实你浅浅思考一下就知道，放了之后还要强转才能取出你想要的位置的数还挺麻烦的）

3.泛型的主要目的：就是指定当前的容器，要持有什么类型的对象，让编译器去做检查  把类型，作为参数传递。需要什么类型，就传入什么类型

4.具体创建：定义一个泛型类引用：泛型类<类型实参>变量名
                     实例化一个泛型类对象：new泛型类<类型实参>(构造方法实参)           
                     MyArray <Integer> myarray = new MyArray<Integer>( );

                     类名后的 <T> 代表占位符，表示当前类是一个泛型类

                        （E表示Element   K表示Key   V表示Value   N表示Number   T表示Type）

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

class MyArray<T>{
    public T[] array =(T[])new Object[10];

    public T getArray(int pos) {
        return this.array[pos];
    }

    public void setArray(int pos,T val) {
        this.array[pos] = val;
    }
}
public class Text {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<Integer>();
        myArray.setArray(0,22);
        myArray.setArray(1,24);
        System.out.println(myArray.getArray(0));
    }

}

5.泛型如何编译：擦除机制——把泛型T擦除为Object（编译时期的一种机制，运行时不包括泛型）

6.泛型的边界：泛型只有上界，没有下界

public class MyArray <E extends Number> //能传的是Number及其子类

class Alg<T extends Comparable<T>>{
    public T findMaxValue(T[] array){
        T maxValue = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(maxValue) > 0){
                maxValue = array[i];
            }
        }
        return maxValue;
    }

}

class Alg2{
    //静态方法
    public static<T extends Comparable<T>> T findMaxValue(T[] array){
        T maxValue = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(maxValue) > 0){
                maxValue = array[i];
            }
        }
        return maxValue;
    }

}
public class TextDemo {
    public static void main(String[] args) {
        Integer[] array = {12,54,234,35,22,57};
        int max = Alg2.<Integer>findMaxValue(array);//Alg2.findMaxValue(array);也行
        System.out.println(max);
    }

    public static void main1(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = {12,54,234,35,22,57};
        int max = alg.findMaxValue(array);
        System.out.println(max);
    }
}

                     
7.通配符：用来解决泛型无法协变的问题
                <?> 可接受任意类型，但由于不确定性，所以无法修改
                     （通配符有上界，也有下界）
                       ？extends 类：设置通配符上界——extends A 可以传A或A的子类类型—— 不能写入，只能读取数据
                       ？super 类：设置通配符下界——super A 可以传A或A的父类类型—— 一般用来添加元素

class Message<T>{
    T messsage;

    public T getMesssage() {
        return messsage;
    }

    public void setMesssage(T messsage) {
        this.messsage = messsage;
    }
}
public class Text1 {
    /*public static void func(Message<String> tmp){
        System.out.println(tmp.getMesssage());
    }*/
    // 这样的话func(message2);会报错 因为Message<String> Message<Integer>类型不同
    //所以我们利用通配符Message<?>

    public static void func(Message<?> tmp){
        System.out.println(tmp.getMesssage());
    }
    public static void main(String[] args) {
        Message<String> message = new Message<>();
        message.setMesssage("hello!");
        func(message);

        Message<Integer> message2 = new Message<>();
        message2.setMesssage(100);
        func(message2);
    }

}