Java--认识泛型(2)

泛型类的使用：

        Java中泛型的语法已经在上节中提到，此时我们来深入研究他的语法构成：

泛型类 < 类型实参 > 变量名 ; // 定义一个泛型类引用

new 泛型类 < 类型实参 > ( 构造方法实参 ); // 实例化一个泛型类对象

此时要实例化一个泛型类有两种方式：

        我们发现这两种的区别就在于实例化的时候，<>中有没有声明泛型类的类型， 此时编译器会为我们自动推导出我们索要实例化的泛型类的类型！

裸类型：

        我们发现上面两种实例化泛型类时必须在引用泛型类的时候传入类型实参！
        那么可不可以在实例化的时候不用传入任何形参直接实例化对象？

        答案是可以的，例如：

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

泛型是如何编译的：

擦除机制：

         当我们写好一个泛型类之后，编译器会为我们进行自动编译：
编译器会将类型参数中的T自动转换为Object类型，我们可以从反汇编中看出：

注意：

        该过程是发生在编译阶段!!

那么问题来了：

有了这样一个基础，此时我将代码写成这样可不可以呢？

那么此时是否就等价于：

注意此时是不等价的，第一种情况下编译器会直接报错，但是第二种不会报错，为什么呢？

我么可以这样理解，编译器在做第一次检查时，不允许我们new一个未知类型的数组。

 那么如果此时我这样写一定对吗？

这样写编译的时候会给我们警告，为什么呢？

来看这样一组代码：

class MyArray5 <T> {
    public T[] arrays = (T[])new Object[10];

    public void setArrays(int pos,T a) {
        this.arrays[pos] = a;
    }
    public T getArrays1(int pos){
        return (T)arrays[pos];
    }
    public T[] getArrays2(){
        return arrays;
    }
    public static void main(String[] args) {
        MyArray5<Integer> myArray5 = new MyArray5<>();
        myArray5.setArrays(3,10);
        Integer[] a = myArray5.getArrays2();
    }
}

这样写是不安全的，最后运行时会报错：

由于最后相当于把Object[]类型拿Integer[]类型接收，是不安全的！！！

所以如果是这样的话，我们干脆这样写：

class MyArray5 <T> {
   // public T[] arrays = (T[])new Object[10];
    public Object[] o = new Object[10];
    public void setArrays(int pos,T a) {
        this.o[pos] = a;
    }
    public T getArrays1(int pos){
        return (T)o[pos];
    }
    public T[] getArrays2(){
        return (T[])o;
    }
    public static void main(String[] args) {
        MyArray5<Integer> myArray5 = new MyArray5<>();
        myArray5.setArrays(3,10);
//        Integer[] a = myArray5.getArrays2();
         int b =  myArray5.getArrays1(3);//自动拆箱
//         int c = b.intValue();
    }
}

泛型的上界：

语法：

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

...

}

例如： 

 

当我们<>里面传参时需要传入Number或者时Number得到子类，不然会报错！！

例如：

此时会报错，因为String不是Number的子类！！

 特殊的上界：

        如果此时有这样的代码：

        比较两个值的大小：

class Alg<T>{
    public T findMaxValue(T[] arrary){
        T max = arrary[0];
        for(int i = 0;i<arrary.length;i++){
            if(arrary[i]>max){//编译器会在这报错
                max = arrary[i];
            }
        }
        return max;
    }
}

        此时编译器会报错：原因是T是引用类型，不是基本数据类型，所以不能直接通过><=号比较，此时需要用到compareTo方法，由于编译阶段T被擦除为Object类，Object类中没有compareTo方法，所以此时不能直接比较，所以此时应该判断一下，传进来的参数T中有没有继承Comparable接口，有这个接口就有compareTo方法！！

        所以此时加一个上界：

 

此时就可以用T中的compareTo方法了。

但是此时如果实例化对象时，传入的参数中没有Compareable接口，同样会报错！！

泛型方法：

        有一种情况，就是如果一个类不是泛型类，但是里面的方法可能是泛型方法！！

 */class Alg2{
    public <T extends Comparable<T>> T findMaxValue(T[] arrary){
        T max = arrary[0];
        for(int i = 0;i<arrary.length;i++){
            if(arrary[i].compareTo(max)>0){
                max = arrary[i];
            }
        }
        return max;
    }
}

 如果只想用该方法，但不去实例化，好还是可以将该方法静态化：

 */class Alg2{
    public static <T extends Comparable<T>> T findMaxValue(T[] arrary){
        T max = arrary[0];
        for(int i = 0;i<arrary.length;i++){
            if(arrary[i].compareTo(max)>0){
                max = arrary[i];
            }
        }
        return max;
    }
}

找最大值就可以这样去写：

class Alg2{
    public static <T extends Comparable<T>> T findMaxValue(T[] arrary){
        T max = arrary[0];
        for(int i = 0;i<arrary.length;i++){
            if(arrary[i].compareTo(max)>0){
                max = arrary[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Integer arr[] = {1,2,3,4,5,6};
        int max = Alg2.findMaxValue(arr);
        System.out.println(max);
    }
}