一、引言
初学Java时，同学们基本都会遇到这样一个基础编程题：
实验题目：获取三个整数的最大值。
它的答案非常简单，只需要比较三个int类型的变量即可：
public class Test { public static void main(String[] args) { int a = 10; int b = 20; int c = 30; int temp = (a > b) ? a : b; int max = (temp > c) ? temp : c; System.out.println("max = " + max); } }
那么问题来了：如果想要比较的对象不仅是整数，而是任意的数值类型（甚至任意的自定义类型），那该怎么办呢？
诚然，我们可以通过方法的重载，编写多个适用于不同数据类型的方法。在需要时，我们可以挨个进行调用。但这个未免还是有些吃力，毕竟光是数值类型就有7种，而这7种类型都是可以比较大小的。
因此，我们可以采用泛型类，将数据类型也作为参数传递，达到比较“任意的数值类型”的效果。
这个方法主要用到了泛型的上界这一知识点。对于泛型的基本语法，便不再赘述，需要的同学可以再自行搜索、熟悉。
二、泛型上界
1、什么是泛型的上界
为什么要引出泛型的上界？因为在实际编程中，在定义泛型类时，有时需要对传入的类型变量做一定的约束。
比如上面这个题目，约束就是“数值类型”，也就是Number类型。Integer、Double等类型（注意：泛型类型是引用类型，要传基本数据类型只能传包装类）都可以进行大小比较，但此时String类型就不在数值类型的范围内。这就是约束，约束传入的数据类型是哪些，而不是随便哪个数据类型都可以传进去。
我们可以通过类型边界来实现这种约束。
2、泛型上界的语法
class 泛型类名称<类型形参 extends 类型边界> { ... }
例如：
public class Test<E extends Number> { ... }
<E extends Number>的含义就是，Test类只接受 Number 的子类（或Number类本身）作为 E 。如果没有指定E的上界（PS：泛型没有下届，泛型的边界就是指泛型是上界）。
因此：
Test<Integer> a; // 正确，因为 Integer 是 Number 的子类型 Test<String> b; // 编译错误，因为 String 不是 Number 的子类型
这样就达到了约束的效果。
但是这样还不够。如果要约束的上界不是一个类，而是一个接口，该如何呢？语法如下：
public class Test<E extends Comparable<E>> { ... }
<E extends Comparable<E>>的含义是，传入的E必须实现了Comparable接口。
三、泛型方法
1、泛型方法的语法
方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }
例如：
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; } }
此时，Util不是泛型类，但swap是泛型方法。该方法在 🔗Java初识泛型 | 如何通过泛型类/泛型方法实现求数组元素最大值？一文的拓展部分有所应用。此处我们只需要知道泛型方法的语法即可。
2、泛型方法的类型推导
类型推导是指，在调用泛型方法时，可以不写明方法的类型，而Java会根据传入参数的类型自动推导出泛型方法中的泛型是指那种类型。如我们既可以这样写：
Integer[] a = { ... }; swap(a, 0, 9); String[] b = { ... }; swap(b, 0, 9); //没有写明swap传入的类型是什么，而是Java自动推导
也可以这样写：
Integer[] a = { ... }; Util.<Integer>swap(a, 0, 9); String[] b = { ... }; Util.<String>swap(b, 0, 9); //写明了swap方法传入的类型
有了以上的知识，就可以进行编程了。
四、编程分析
1、MyCompare<T>泛型类
public class MyCompare<T extends Comparable<T>>{ /* public T getMax(T x, T y) { return x > y ? x : y; //错误！ }*/ public T getMax(T x, T y) { return x.compareTo(y) >= 0 ? x : y; } }
由于T本身代表的就是一个引用类型，因此，直接用大于小于号比较是不正确的。
不能写作：
调用compareTo()方法才是正确的比较方式。但compareTo()方法不是可以直接调用的，使用之前必须实现Comparable接口。因此，我们需要对传入的类型进行约束，令传入的类型一定得是实现了Comparable接口的，最后再调用类型的compareTo()方法进行比较。
因此，我们写作：
public class MyCompare<T extends Comparable<T>> { //获取较大值的方法 ... }
含义为，MyCompare类只能传入实现过Comparable接口的类型T。
然后我们调用：
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner reader = new Scanner(System.in); double a = reader.nextDouble(); double b = reader.nextDouble(); double c = reader.nextDouble(); MyCompare<Double> m = new MyCompare<>(); double temp = m.getMax(a,b); double max = m.getMax(temp,c); System.out.println("max = " + max); } }
此时传入了Double类型（Double类型是实现了Comparable接口的）。
将Double改为Integer：
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner reader = new Scanner(System.in); int a = reader.nextInt(); int b = reader.nextInt(); int c = reader.nextInt(); MyCompare<Integer> m = new MyCompare<>(); int temp = m.getMax(a,b); int max = m.getMax(temp,c); System.out.println("max = " + max); } }
甚至可以传入String，因为String也实现了Comparable接口。
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner reader = new Scanner(System.in); String a = reader.next(); String b = reader.next(); String c = reader.next(); MyCompare<String> m = new MyCompare<>(); String temp = m.getMax(a,b); String max = m.getMax(temp,c); System.out.println("max = " + max); } }
也可以传入自定义的类型Student，需要手动给Student类实现Comparable接口。
1.import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner reader = new Scanner(System.in); Student stu1 = new Student(10); Student stu2 = new Student(20); Student stu3 = new Student(30); MyCompare<Student> m = new MyCompare<>(); Student temp = m.getMax(stu1,stu2); Student max = m.getMax(temp,stu3); System.out.println("max = " + max); } } class Student implements Comparable<Student>{ //实现Comparable接口，接口也要传入泛型Student类 int age; String name; double grades; public Student(int age) { //构造方法 由于只用到age，就只写了age this.age = age; } @Override public int compareTo(Student o) { //重写compareTo方法 return this.age-o.age; } @Override public String toString() { //重写toString方法，便于打印 return "Student{" + "age=" + age + '}'; } }
2、泛型方法实现
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner reader = new Scanner(System.in); //创建待比较的对象 String a = new String("hello"); String b = new String("Hi"); String c = new String("nice"); //直接调用泛型方法 //类型推导 String temp = Util.getMax(a,b); String max = Util.getMax(temp,c); System.out.println("max = " + max); } } //泛型方法 class Util { public static <T extends Comparable> T getMax(T x,T y) { return x.compareTo(y) > 0 ? x : y; } }
五、总结
泛型上界是对传入泛型类的类型变量做一定的约束，可以是约束类型变量必须是另一个类的子类或本身，也可以是约束类型变量必须实现了某一个接口。
泛型类型都是引用类型。要实现比较，传入的泛型类型必须是实现了Comparable接口的。语法为<T extends Comparable<T>>。通过调用引用变量自身的compareTo()方法，A.compareTo(B)这样来比较。
注意泛型的语法，包括泛型类实现接口、泛型方法的语法等。
————————————————
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/wyd_333/article/details/128568280
