在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

3.复杂示例

写一个泛型类，求一个数组中的最大值

面对这样一个问题，我们可能首先会写出以下代码：

此时if处为什么会报错呢？

原因：T一定是一个引用类型，最终被擦除为Object类型，而T类型则一定要是可比较的，不然无法进行比较。

所以：怎么约束这个T一定是可以比较大小的？

很简单，只要让它extends一个Comparable

class Alg<T extends Comparable<T>> /*表示T一定是实现了Comparable接口的*/{
    public T FindMax(T[] array) {
        T Max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (Max.compareTo(array[i]) < 0) /*Max如果比array[i]小，则返回的小于0*/{
                Max = array[i];
            }
        }
        return Max;
    }
}

八，泛型方法

1.定义语法

方法限定符 < 类型形参列表 > 返回值类型 方法名称 ( 形参列表 ) { ... }

简单来说：就是在一个普通的类里面实现泛型方法

2.示例

public class Util {

//静态的泛型方法 需要在static后用<>声明泛型类型参数

public static <E> void swap(E[] array, int i, int j) {

E t = array[i];

array[i] = array[j];

array[j] = t;

}

}

将上述代码以泛型方法的形式来写：

class Alg {
    public<T extends Comparable<T>> T FindMax(T[] array) {
        T Max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (Max.compareTo(array[i]) < 0) /*Max如果比array[i]小，则返回的小于0*/{
                Max = array[i];
            }
        }
        return Max;
    }
}

3.使用实例-可以类型推导

Integer[] a = { ... };

swap(a, 0, 9);

String[] b = { ... };

swap(b, 0, 9);

同样以上述代码为例：

当我们要使用上述代码来获得一个数组中的最大值时

class Alg {
    public<T extends Comparable<T>> T FindMax(T[] array) {
        T Max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (Max.compareTo(array[i]) < 0) /*Max如果比array[i]小，则返回的小于0*/{
                Max = array[i];
            }
        }
        return Max;
    }
}
public class Main {
    public static void main(String[] args) {
        Alg alg = new Alg();
        Integer[] integers = new Integer[]{1,2,3,4,5};
        //int ret = alg.<Integer>FindMax(integers);//指定类型
        int ret = alg.FindMax(integers);//不指定类型
        //类型推导：根据实参传值来推导此时的类型
        //当可以类型推导时上两种写法均可
        System.out.println(ret);
    }
}

4.使用实例-不可以类型推导

Integer[] a = { ... };

Util.<Integer>swap(a, 0, 9);

String[] b = { ... };

Util.<String>swap(b, 0, 9);

---

完.