这个 Java 高级特性你用过吗？

前言

泛型是什么

 public static void quickSort(int[] data, int start, int end) {
        int key = data[start];
        int i = start;
        int j = end;
        while (i < j) {
            while (data[j] > key && j > i) {
                j--;
            }
            data[i] = data[j];

            while (data[i] < key && i < j) {
                i++;
            }
            data[j] = data[i];
        }
        data[i] = key;

        if (i - 1 > start) {
            quickSort(data, start, i - 1);
        }
        if (i + 1 < end) {
            quickSort(data, i + 1, end);
        }
    }

    public static  <T extends Comparable<T>> void quickSort(T[] data, int start, int end) {
        T key = data[start];
        int i = start;
        int j = end;
        while (i < j) {
            while (data[j].compareTo(key) > 0 && j > i) {
                j--;
            }
            data[i] = data[j];

            while (data[i].compareTo(key) < 0 && i < j) {
                i++;
            }
            data[j] = data[i];
        }
        data[i] = key;

        if (i - 1 > start) {
            quickSort(data, start, i - 1);
        }
        if (i + 1 < end) {
            quickSort(data, i + 1, end);
        }
    }

• 当参数类型不明确，可能会扩展为多种时。
  
• 想声明参数类型为 
  Object
  ，并在使用时用 
  instanceof
   判断时。
  

使用

声明

    class Generics<T> { // 在类名后声明引入泛型类型
        private T field;  // 引入后可以将字段声明为泛型类型

        public T getField() { // 类方法内也可以使用泛型类型
            return field;
        }
    }

把泛型声明在方法上时：

    public [static] <T> void testMethod(T arg) { // 访问限定符[静态方法在 static] 后使用 <占位符> 声明泛型方法后，在参数列表后就可以使用泛型类型了
        // doSomething
    }

最后是在接口中声明泛型，如上面的快排中，我们使用了 Comparable<T> 的泛型接口，与此类似的还有 Searializable<T> Iterable<T>等，其实在接口中声明与在类中声明并没有什么太大区别。

调用

然后是泛型的调用，泛型的调用和普通方法或类的调用没有什么大的区别，如下：

    public static void main(String[] args) {
        String[] strArr = new String[2];
        // 泛型方法的调用跟普通方法相同
  Generics.quickSort(strArr, 0, 30 );

  // 泛型类在调用时需要声明一种精确类型
        Generics<Long> sample = new Generics<>();
        Long field = sample.getField();
    }

    // 泛型接口需要在泛型类里实现
    class GenericsImpl<T> implements Comparable<T> {
    @Override
    public int compareTo(T o) {
        return 0;
    }
}

类型擦除

由来

    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        List<Long> longList = new ArrayList<>();

        if (stringList.getClass() == longList.getClass()) {
            System.out.println(stringList.getClass().toString());
            System.out.println(longList.getClass().toString());
   System.out.println("type erased");
        }
    }

实现

1. 编译期间编译器检查传入的泛型类型与声明的泛型类型是否匹配，不匹配则报出编译器错误；
   
2. 编译器执行类型擦除，字节码内只保留其原始类型；
   
3. 运行期间，再将 Object 转换为所需要的泛型类型。
   

实践问题

具体类型须为Object子类型

边界限定通配符的使用

List<? extends Generics> genericsList = new ArrayList<>();
Generics generics = genericsList.get(0);
genericsList.add(new Generics<String>()); // 编译无法通过

List<? super Generics> genericsList = new ArrayList<>();
genericsList.add(new Generics()); // 编译无法通过
Generics generics = genericsList.get(0);

最佳实践

1. 将代码逻辑拆分为两部分：通用逻辑和类型相关逻辑；通用逻辑是一些跟参数类型无关的逻辑，如快排的元素位置整理等；类型相关逻辑，顾名思义，是需要确定类型后才能编写的逻辑，如元素大小的比较，String 类型的比较和 int 类型的比较就不一样。
   
2. 如果没有类型相关的逻辑，如 List 作为容器不需要考虑什么类型，那么直接完善通用代码即可。
   
3. 如果有参数类型相关的逻辑，那么就需要考虑这些逻辑是否已有共同的接口实现，如果已有共同的接口实现，可以使用边界限定通配符。如快排的元素就实现了 
   Compare
    接口，Object 已经实现了 
   toString()
    方法，所有的打印语句都可以调用它。
   
4. 如果还没有共同的接口，那么需要考虑是否可以抽象出一个通用的接口实现，如打印人类的衣服颜色和动物的毛皮颜色，就可以抽象出一个 
   getColor()
    接口，抽象之后再使用边界限定通配符。
   
5. 如果无法抽象出通用接口，如输出人类身高或动物体重这种，还是不要使用泛型了，因为不限定类型的话，具体类型的方法调用也就无从谈起，编译也无法通过。
   

小结

来源 | https://zhenbianshu.github.io/