泛型（Generics）

泛型（Generics）泛型类型（Generic Type）多个类型参数泛型类型的继承原始类型（Raw Type）泛型方法（Generic Method）泛型方法 - 类型推断泛型方法 – 构造方法限制类型参数限制类型参数 — 接收泛型数组返元素最大值方法限制类型参数 — 要求传入的类型必须可比较通配符（Wildcards）通配符 — 上界（`extends`）通配符 — 下界（`super`）通配符 — 无限制通配符 – 继承通配符 — 注意点泛型的使用限制

Java笔记目录可以点这里：Java 强化笔记（适合有基础的童鞋，不适合小白）

泛型（Generics）

从 Java 5 开始，增加了泛型技术

什么是泛型？

将类型变为参数，提高代码复用率

建议的类型参数名称：

• T ：Type

• E ：Element

• K ：Key

• N ：Number

• V ：Value

• S、U、V ：2nd, 3rd, 4th types

泛型类型（Generic Type）

什么是泛型类型？

使用了泛型的类或者接口

比如：parator、parable

public class Student <T> {private T score;public T getScore() {return score;}public void setScore() {this.score = score;}}

// Java 7 以前的写法Student<String>stu = new Student<String>();// Java 7开始, 可以省略右边<>中的类型（钻石语法）Student<String> stu1 = new Student<>();stu1.setScore("A");String score1 = stu1.getScore();Student<Double> stu2 = new Student<>();stu2.setScore(98.5);Double score2 = stu2.getScore();

多个类型参数

public class Student <N, S> {private N no;private S score;public Student(N no, S score) {this.no = no;this.score = score;}}

Student<String, String> s1 = new Student<>("E9527", "A++");Student<Integer, Double> s2 = new Student<>(17210224, 96.5);

泛型类型的继承

如果没有泛型类型的类之间有继承关系，加了泛型类型后不一定会保持继承关系。

例如Integer类继承自Number，但是Box<Integer>不继承Box<Number>

只有泛型类型也相同时，原本有继承关系的类会继续保持继承关系。

如果拥有多个泛型类型，第一个泛型类型与父类的泛型类型相同，即可保持继承关系。

例如，下图中MyList<String, Object>与List<String>保持了继承关系。

原始类型（Raw Type）

泛型方法（Generic Method）

什么是泛型方法？

使用了泛型的方法（实例方法、静态方法、构造方法），比如Arrays.sort(T[], Comparator<T>)

public class Main {public static void main(String[] args) {Student<String, String> s1 = new Student<>();// 可以像下面这么写, 但一般不会写的这么麻烦Main.<String, String>set(s1, "K99", "C++");Student<Integer, Double> s2 = new Student<>();// 编译器可以自动推断出类型参数的具体类型set(s2, 25, 99.5);}// 泛型方法(静态方法)static <T1, T2> void set(Student<T1, T2> stu, T1 no, T2 score) {stu.setNo(no);stu.setScore(score);}}

泛型方法示例：

public class Box<E> {private E element;public Box() {}public Box(E element) {this.element = element;}}

public class Main {public static void main(String[] args) {List<Box<Integer>> boxes = new ArrayList<>();addBox(11, boxes);addBox(22, boxes);addBox(33, boxes);}// 泛型方法(静态方法)static <T> void addBox(T element, List<Box<T>> boxes) {Box<T> box = new Box<>(element);boxes.add(box);}}

泛型方法 - 类型推断

上图是 jdk 中Collections类的源码，可以看出emptyList()是泛型方法，可以自动推断类型。

// 根据接收的类是 List<String> 推断出了泛型是 String 类型List<String> list1 = Collections.emptyList();// 根据接收的类是 List<Integer> 推断出了泛型是 Integer 类型List<Integer> list2 = Collections.emptyList();

泛型方法 – 构造方法

限制类型参数

可以通过extends对类型参数增加一些限制条件，比如<T extends A>

extends后面可以跟上类名、接口名，代表 T 必须是 A 类型，或者继承、实现 A

// <T extends Number> 表示传入的类型参数必须是Numbe及其子类public class Person<T extends Number> {private T age;public <E> Person(T age) {this.age = age;}public int getAge() {// 传入null则视为0, 否则转为intreturn (age == null) ? 0 : age.intValue();}}

public static void main(String[] args) {Person<Double> p1 = new Person<>(18.7);System.out.println(p1.getAge()); // 18Person<Integer> p2; // 正常运行, Integer是Number的子类// Person<String> p3; // 会报错, 因为String不是Number的子类}

可以同时添加多个限制，比如<T extends A & B & C>，代表 T 必须同时满足 A、B、C，只能有一个类，但是可以有多个接口，类必须放在前面

限制类型参数 — 接收泛型数组返元素最大值方法

public class Main {public static void main(String[] args) {Double[] ds = {5.6, 3.4, 8.8, 4.6};System.out.println(getMax(ds)); // 8.8Integer[] is = {4, 19, 3, 28, 56};System.out.println(getMax(is)); // 56}static <T extends Comparable<T>> T getMax(T[] array) {if (array == null || array.length == 0) return null;T max = array[0];for (int i = 0; i < array.length; i++) {if (array[i] == null) continue;if (array[i].compareTo(max) <= 0) continue;max = array[i];}return max;}}

限制类型参数 — 要求传入的类型必须可比较

public class Student <T extends Comparable<T>> implements Comparable<Student<T>> {private T score; // 传入的 T 继承了 Comparable<T>, 表示是可比较的public Student(T score) {this.score = score;}@Overridepublic int compareTo(Student<T> s) {// 传入若为null, 必然比本身小if (s == null) return 1;// 若自身的score不为null, 则调用compareTo与传入的进行比较if (score != null) return pareTo(s.score); // 此时, 自身的score为null, 若传入的score也为null则视为相同, 否则就是传入的大return s.score == null ? 0 : -1;}@Overridepublic String toString() {return "Student [score=" + score + "]";}}

public class Main {public static void main(String[] args) {Student<Integer>[] stus = new Student[3];stus[0] = new Student<>(18);stus[1] = new Student<>(38);stus[2] = new Student<>(28);// Student [score=38]System.out.println(getMax(stus));}static <T extends Comparable<T>> T getMax(T[] array) {if (array == null || array.length == 0) return null;T max = array[0];for (int i = 0; i < array.length; i++) {if (array[i] == null) continue;if (array[i].compareTo(max) <= 0) continue;max = array[i];}return max;}}

通配符（Wildcards）

在泛型中，问号?被称为是通配符通常用作变量类型、返回值类型的类型参数不能用作泛型方法调用、泛型类型实例化、泛型类型定义的类型参数

通配符 — 上界（extends）

可以通过extends设置类型参数的上界

基本使用：

// 类型参数必须是Number类型或者是Number的子类型void testUpper(Box<? extends Number> box) {}

// Integer是Number的子类Box<Integer> p1 = null; testUpper(p1); // 可以// Number类型可以作为参数Box<Number> p2 = null;testUpper(p2); // 可以// ? extends Number 表示参数是Number的子类Box<? extends Number> p3 = null; // 可以testUpper(p3);// ? extends Integer 表示参数是Integer的子类, Integer是Number的子类Box<? extends Integer> p4 = null; // 可以testUpper(p4);// String不是Number的子类, 传入testUpeer会报错Box<String> p5 = null;// testUpper(p5); // 报错

示例：对泛型数组的元素求和方法（传入的必须是Number的子类型）

public class Main {public static void main(String[] args) {List<Integer> is = Arrays.asList(1, 2, 3);System.out.println(sum(is)); // 6.0List<Double> ds = Arrays.asList(1.2, 2.3, 3.5);System.out.println(sum(ds)); // 7.0}static double sum(List<? extends Number> list) {double s= 0.0;for (Number n : list) {s += n.doubleValue();}return s;}}

通配符 — 下界（super）

可以通过super设置类型参数的下界

基本使用：

// 类型参数必须是Integer类型或者是Integer的父类型void testLower(Box<? super Integer> box) {

Box<Integer> p1 = null;testLower(p1);Box<Number> p2 = null;testLower(p2);Box<? super Integer> p3 = null;testLower(p3);Box<? super Number> p4 = null;testLower(p4);

示例：往泛型数组中添加元素（传入的必须是Integer的父类型）

public class Main {public static void main(String[] args) {List<Integer> is = new ArrayList<>();addNumbers(is); System.out.println(is); // [1, 2, 3, 4, 5]List<Number> ns = new ArrayList<>();addNumbers(ns);System.out.println(ns); // [1, 2, 3, 4, 5]}static void addNumbers(List<? super Integer> list) {for (int i = 1; i <= 5; i++) {list.add(i);}} }

通配符 — 无限制

// 类型参数是什么类型都可以void test(Box<?> box) {}

Box<Integer> p1 = null;Box<Integer> p2 = null;Box<Integer> p3 = null;Box<? extends Number> p4 = null;Box<? super String> p5 = null;Box<?> p6 = null;test(p1);test(p2);test(p3);test(p4);test(p5);test(p6);

示例：打印泛型数组的元素（无限制，任何类型都可以）

public class Main {public static void main(String[] args) {List<Integer> is = Arrays.asList(1, 2, 3);printList(is); // 1 2 3List<Double> ds = Arrays.asList(1.2, 2.3, 3.5);printList(ds); // 1.2 2.3 3.5}static void printList(List<?> list) {for (Object object : list) {System.out.print(object + " ");}System.out.println();}}

通配符 – 继承

无限制的绝对是最顶层的，其余的按正常继承关系理解即可。

通配符 — 注意点

泛型的使用限制

这里列出一些常用的误区，不必死记，过一遍理解即可。