4.泛型接口实例学习

1.为何需要泛型接口？

泛型接口其实就是泛型类的抽象表现，它的作用就是将泛型方法的实现延迟到子类中，让子类有权决定自己的泛型处理逻辑。

2.实例学习

2.1 泛型接口Maximum

首先我们新建一个抽象接口，其包含了对数组的排序操作，获取最大/小值操作。

public interface Maximum<T extends Comparable<T>> {
    /**
     * 获得数组最大值
     * @param array
     * @return
     */
    T getMax(T[] array);

    /**
     * 获得数组最小值
     * @param array
     * @return
     */
    T getMin(T[] array);

    /**
     * 对数组进行排序
     * @param array
     * @return
     */
    T[] sorted(T[] array);
}

有了这个接口，我们可以编写不同处理逻辑的Maximum实现类，然后结合策略模式，根据不同的场景调用不同的实现类。比如说，有的实现类中的sorted方法使用的是冒泡排序实现，有的实现类中的sorted则使用快排实现。

2.2.编写GenericComparison类实现Maximum

其中的排序实现采用的是冒泡排序的升序排序。

/**
 * Maximum接口的一种具体的实现
 * @param <T>
 */
public class GenericComparison<T extends Comparable<T>> implements Maximum<T> {

    /**
     * 获取数组array的最大值
     * @param array 目标数组
     * @return 数组中的最大值
     */
    @Override
    public T getMax(T[] array) {
        //非规则调用处理
        if (array == null || array.length == 0) {
            return null;
        }
        T max = array[0];
        //遍历剩下的元素进行比较将最大的值存入max中
        for (int i = 1; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }

    /**
     * 获取数组array的最小值
     * @param array 目标数组
     * @return 数组中的最小值
     */
    @Override
    public T getMin(T[] array) {
        //非规则调用处理
        if (array == null || array.length == 0) {
            return null;
        }
        T min = array[0];
        //遍历剩下的元素进行比较，将最小的值存入min中
        for (int i = 1; i < array.length; i++) {
            if (min.compareTo(array[i]) > 0) {
                min = array[i];
            }
        }
        return min;
    }

   /**
 * 对目标数组进行升序排序处理
 * @param array 目标数组
 * @return 排序后的数组
 */
@Override
public T[] sorted(T[] array) {
    //非规则调用处理
    if (array == null || array.length == 0) {
        return null;
    }
    System.out.println();
    //采用冒泡排序进行排序
    for (int i = 0; i < array.length; i++) {
        for(int j=i;j<array.length;j++){
            if(array[i].compareTo(array[j])>0){
                T temp=array[i];
                array[i]=array[j];
                array[j]=temp;
            }
        }
    }
    return array;
}

2.3.最后编写测试方法进行测试

package GenericStudy.Exa4;

/**
 * 泛型接口学习
 */
public class GenericComparisonTest {
    public static void main(String[] args) {
        Integer[] books = { 4, 5, 2, 1,5,7,1};
        System.out.println("初始数组：");
        for (Integer book : books) {
            System.out.print(book+" ");
        }
        System.out.println();
        GenericComparison<Integer> gc = new GenericComparison<Integer>();
        System.out.println("最小值");
        Integer min=gc.getMin(books);
        System.out.println(min);
        Integer max = gc.getMax(books);
        System.out.println("最大值：");
        System.out.println(max);
        Integer[] result1=gc.sorted(books);
        System.out.println("升序排序后：");
       for(Integer a:result1){
           System.out.print(a+ " ");
       }
    }
}

运行之，成功！！