何为擦除机制，泛型的上界？

擦除机制

如下代码：

class Demo1 <T>{
    private T[] array = (T[])new Object[6];
    public void setArray(T str, int pos){
        this.array[pos] = str;
    }
    public T getArray(int pos){
        return this.array[pos];
    }
}
public class Test{
    public static void main(String[] args){
        Demo1<String> demo1 = new Demo1<>();
        demo1.setArray("China",0);
        System.out.println(demo1.getArray(0));
    }
}

在终端通过javap -c 字节码文件 可以观察到如下结果：

所有的 T类型，在编译阶段全部被换成了Object类型(在运行期间没有泛型机制)，这便是擦除机制

1.全部擦除成了Object，那为什么不能直接写成public Object[ ] array = new Object[6]?

        假设存在那么一定会存在Object类型的数组，那么观察下面代码：

class Demo1 <T>{
    private T[] array =(T[])new Object[6];
    public void setArray(T i, int pos){
        this.array[pos] = i;
    }
    public T[] getArray(){
        return array;
    }

}
public class Test{
    public static void main(String[] args){
        Demo1<Integer> demo1 = new Demo1<>();
        demo1.setArray(100,0);
        Integer[] integer = demo1.getArray();
    }
}

运行结果：

        他会告诉你类型转化异常，Object类型数组不能被转化成Integer类型的数组；

        原因可想而知，Object类型数组，里面可以放任意类型数据（例如：{ "china",15,15.6}），如果让Integer类型的数组去引用他，编译器为了安全考虑（不全是Integer类型）肯定会报错的。

正确改法如下：（告诉Object我会传入一个什么类型）

import java.lang.reflect.Array;
import java.util.Arrays;
class Demo1 <T>{
    public T[] array;
    public Demo1(Class<T> array, int size){
        this.array = (T[]) Array.newInstance(array, size);
    }
    public void setArray(T i, int pos){
        this.array[pos] = i;
    }
    public T[] getArray(){
        return array;
    }
}
public class Test{
    public static void main(String[] args){
        Demo1<Integer> demo1 = new Demo1<>(Integer.class,10);
        Integer[] integer = demo1.getArray();
        System.out.println(Arrays.toString(integer));
    }
}

---

泛型的上界

通俗讲，就是通过对传入的数据类型进行一定约束的一个边界(注意：泛型只有上界，没有下界，通配符即有上界又有下界)

如下代码：（定义边界为Number类型）

class Demo2<E extends Number>{
}
public class Test{
    public static void main(String[] args){
        Demo2<Integer> demo2 = new Demo2<>();
    }
}

此时，能传入的只能是Number及其子类。

例题：写一个泛型类，找出数组的最大值

class Demo2<T extends Comparable<T>>{//只要这个T实现了这个接口即可
    public T findMax(T[] array){
        T max = array[0];
        int i = 0;
        for(i = 0; i < array.length; i++){
            if(array[i].compareTo(max) > 0){
                max = array[i];
            }
        }
        return max;
    }
}
public class Test{
    public static void main(String[] args){
        Integer[] array = {1,5,9,6,3,5};
        Demo2<Integer> demo2 = new Demo2<>();
        int ret = demo2.findMax(array);
        System.out.println("max = " + ret);
    }
}