:notebook: 本文已归档到:「 blog 」
:keyboard: 本文中的示例代码已归档到:「 javacore 」
为什么需要泛型呢?回答这个问题前,先让我们来看一个示例。
public class NoGenericsDemo { public static void main(String[] args) { List list = new ArrayList<>(); list.add("abc"); list.add(18); list.add(new double[] {1.0, 2.0}); Object obj1 = list.get(0); Object obj2 = list.get(1); Object obj3 = list.get(2); System.out.println("obj1 = [" + obj1 + "]"); System.out.println("obj2 = [" + obj2 + "]"); System.out.println("obj3 = [" + obj3 + "]"); int num1 = (int)list.get(0); int num2 = (int)list.get(1); int num3 = (int)list.get(2); System.out.println("num1 = [" + num1 + "]"); System.out.println("num2 = [" + num2 + "]"); System.out.println("num3 = [" + num3 + "]"); } } // Output: // obj1 = [abc] // obj2 = [18] // obj3 = [[D@47089e5f] // Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer // at io.github.dunwu.javacore.generics.NoGenericsDemo.main(NoGenericsDemo.java:23) 复制代码
示例说明:
在上面的示例中, List
容器没有指定存储数据类型,这种情况下,可以向 List
添加任意类型数据,编译器不会做类型检查,而是默默的将所有数据都转为 Object
。
假设,最初我们希望向 List
存储的是整形数据,假设,某个家伙不小心存入了其他数据类型。当你试图从容器中取整形数据时,由于 List
当成 Object
类型来存储,你不得不使用类型强制转换。在运行时,才会发现 List
中数据不存储一致的问题,这就为程序运行带来了很大的风险(无形伤害最为致命)。
而泛型的出现,解决了类型安全问题。
泛型具有以下优点:
泛型要求在声明时指定实际数据类型,Java 编译器在编译时会对泛型代码做强类型检查,并在代码违反类型安全时发出告警。早发现,早治理,把隐患扼杀于摇篮,在编译时发现并修复错误所付出的代价远比在运行时小。
未使用泛型:
List list = new ArrayList(); list.add("hello"); String s = (String) list.get(0); 复制代码
使用泛型:
List<String> list = new ArrayList<String>(); list.add("hello"); String s = list.get(0); // no cast 复制代码
通过使用泛型,程序员可以实现通用算法,这些算法可以处理不同类型的集合,可以自定义,并且类型安全且易于阅读。
泛型类型
是被参数化的类或接口。
泛型类的语法形式:
class name<T1, T2, ..., Tn> { /* ... */ } 复制代码
泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。由尖括号( <>
)分隔的类型参数部分跟在类名后面。它指定类型参数(也称为类型变量)T1,T2,...和 Tn。
一般将泛型中的类名称为 原型 ,而将 <>
指定的参数称为 类型参数 。
在泛型出现之前,如果一个类想持有一个可以为任意类型的数据,只能使用 Object
做类型转换。示例如下:
public class Info { private Object value; public Object getValue() { return value; } public void setValue(Object value) { this.value = value; } } 复制代码
public class Info<T> { private T value; public Info() { } public Info(T value) { this.value = value; } public T getValue() { return value; } public void setValue(T value) { this.value = value; } @Override public String toString() { return "Info{" + "value=" + value + '}'; } } public class GenericsClassDemo01 { public static void main(String[] args) { Info<Integer> info = new Info<>(); info.setValue(10); System.out.println(info.getValue()); Info<String> info2 = new Info<>(); info2.setValue("xyz"); System.out.println(info2.getValue()); } } // Output: // 10 // xyz 复制代码
在上面的例子中,在初始化一个泛型类时,使用 <>
指定了内部具体类型,在编译时就会根据这个类型做强类型检查。
实际上,不使用 <>
指定内部具体类型,语法上也是支持的(不推荐这么做),如下所示:
public static void main(String[] args) { Info info = new Info(); info.setValue(10); System.out.println(info.getValue()); info.setValue("abc"); System.out.println(info.getValue()); } 复制代码
示例说明:
上面的例子,不会产生编译错误,也能正常运行。但这样的调用就失去泛型类型的优势。
public class MyMap<K,V> { private K key; private V value; public MyMap(K key, V value) { this.key = key; this.value = value; } @Override public String toString() { return "MyMap{" + "key=" + key + ", value=" + value + '}'; } } public class GenericsClassDemo02 { public static void main(String[] args) { MyMap<Integer, String> map = new MyMap<>(1, "one"); System.out.println(map); } } // Output: // MyMap{key=1, value=one} 复制代码
public class GenericsClassDemo03 { public static void main(String[] args) { Info<String> info = new Info("Hello"); MyMap<Integer, Info<String>> map = new MyMap<>(1, info); System.out.println(map); } } // Output: // MyMap{key=1, value=Info{value=Hello}} 复制代码
接口也可以声明泛型。
泛型接口语法形式:
public interface Content<T> { T text(); } 复制代码
泛型接口有两种实现方式:
public class GenericsInterfaceDemo01 implements Content<Integer> { private int text; public GenericsInterfaceDemo01(int text) { this.text = text; } @Override public Integer text() { return text; } public static void main(String[] args) { GenericsInterfaceDemo01 demo = new GenericsInterfaceDemo01(10); System.out.print(demo.text()); } } // Output: // 10 复制代码
public class GenericsInterfaceDemo02<T> implements Content<T> { private T text; public GenericsInterfaceDemo02(T text) { this.text = text; } @Override public T text() { return text; } public static void main(String[] args) { GenericsInterfaceDemo02<String> gen = new GenericsInterfaceDemo02<>("ABC"); System.out.print(gen.text()); } } // Output: // ABC 复制代码
泛型方法是引入其自己的类型参数的方法。泛型方法可以是普通方法、静态方法以及构造方法。
泛型方法语法形式如下:
public <T> T func(T obj) {} 复制代码
泛型方法的语法包括一个类型参数列表,在尖括号内,它出现在方法的返回类型之前。对于静态泛型方法,类型参数部分必须出现在方法的返回类型之前。类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际类型参数的占位符。
使用泛型方法的时候,通常不必指明类型参数,因为编译器会为我们找出具体的类型。这称为类型参数推断(type argument inference)。类型推断只对赋值操作有效,其他时候并不起作用。如果将一个泛型方法调用的结果作为参数,传递给另一个方法,这时编译器并不会执行推断。编译器会认为:调用泛型方法后,其返回值被赋给一个 Object 类型的变量。
public class GenericsMethodDemo01 { public static <T> void printClass(T obj) { System.out.println(obj.getClass().toString()); } public static void main(String[] args) { printClass("abc"); printClass(10); } } // Output: // class java.lang.String // class java.lang.Integer 复制代码
泛型方法中也可以使用可变参数列表
public class GenericVarargsMethodDemo { public static <T> List<T> makeList(T... args) { List<T> result = new ArrayList<T>(); Collections.addAll(result, args); return result; } public static void main(String[] args) { List<String> ls = makeList("A"); System.out.println(ls); ls = makeList("A", "B", "C"); System.out.println(ls); } } // Output: // [A] // [A, B, C] 复制代码
Java 语言引入泛型是为了在编译时提供更严格的类型检查,并支持泛型编程。不同于 C++ 的模板机制, Java 泛型是使用类型擦除来实现的,使用泛型时,任何具体的类型信息都被擦除了 。
那么,类型擦除做了什么呢?它做了以下工作:
<>
的内容。比如 T get()
方法声明就变成了 Object get()
; List<String>
就变成了 List
。如有必要,插入类型转换以保持类型安全。 让我们来看一个示例:
public class GenericsErasureTypeDemo { public static void main(String[] args) { List<Object> list1 = new ArrayList<Object>(); List<String> list2 = new ArrayList<String>(); System.out.println(list1.getClass()); System.out.println(list2.getClass()); } } // Output: // class java.util.ArrayList // class java.util.ArrayList 复制代码
示例说明:
上面的例子中,虽然指定了不同的类型参数,但是 list1 和 list2 的类信息却是一样的。
这是因为: 使用泛型时,任何具体的类型信息都被擦除了 。这意味着: ArrayList<Object>
和 ArrayList<String>
在运行时,JVM 将它们视为同一类型。
Java 泛型的实现方式不太优雅,但这是因为泛型是在 JDK5 时引入的,为了兼容老代码,必须在设计上做一定的折中。
泛型不能用于显式地引用运行时类型的操作之中,例如:转型、instanceof 操作和 new 表达式。因为所有关于参数的类型信息都丢失了。当你在编写泛型代码时,必须时刻提醒自己,你只是看起来好像拥有有关参数的类型信息而已。
正是由于泛型时基于类型擦除实现的,所以, 泛型类型无法向上转型 。
向上转型是指用子类实例去初始化父类,这是面向对象中多态的重要表现。
Integer
继承了 Object
; ArrayList
继承了 List
;但是 List<Interger>
却并非继承了 List<Object>
。
这是因为,泛型类并没有自己独有的 Class
类对象。比如:并不存在 List<Object>.class
或是 List<Interger>.class
,Java 编译器会将二者都视为 List.class
。
List<Integer> list = new ArrayList<>(); List<Object> list2 = list; // Erorr 复制代码
有时您可能希望限制可在参数化类型中用作类型参数的类型。 类型边界
可以对泛型的类型参数设置限制条件 。例如,对数字进行操作的方法可能只想接受 Number
或其子类的实例。
要声明有界类型参数,请列出类型参数的名称,然后是 extends
关键字,后跟其限制类或接口。
类型边界的语法形式如下:
<T extends XXX> 复制代码
示例:
public class GenericsExtendsDemo01 { static <T extends Comparable<T>> T max(T x, T y, T z) { T max = x; // 假设x是初始最大值 if (y.compareTo(max) > 0) { max = y; //y 更大 } if (z.compareTo(max) > 0) { max = z; // 现在 z 更大 } return max; // 返回最大对象 } public static void main(String[] args) { System.out.println(max(3, 4, 5)); System.out.println(max(6.6, 8.8, 7.7)); System.out.println(max("pear", "apple", "orange")); } } // Output: // 5 // 8.8 // pear 复制代码
示例说明:
上面的示例声明了一个泛型方法,类型参数 T extends Comparable<T>
表明传入方法中的类型必须实现了 Comparable 接口。
类型边界可以设置多个,语法形式如下:
<T extends B1 & B2 & B3> 复制代码
注意:extends 关键字后面的第一个类型参数可以是类或接口,其他类型参数只能是接口。
示例:
public class GenericsExtendsDemo02 { static class A { /* ... */ } interface B { /* ... */ } interface C { /* ... */ } static class D1 <T extends A & B & C> { /* ... */ } static class D2 <T extends B & A & C> { /* ... */ } // 编译报错 static class E extends A implements B, C { /* ... */ } public static void main(String[] args) { D1<E> demo1 = new D1<>(); System.out.println(demo1.getClass().toString()); D1<String> demo2 = new D1<>(); // 编译报错 } } 复制代码
类型通配符
一般是使用 ?
代替具体的类型参数。例如 List<?>
在逻辑上是 List<String>
, List<Integer>
等所有 List<具体类型实参>
的父类。
可以使用** 上界通配符
**来缩小类型参数的类型范围。
它的语法形式为: <? extends Number>
public class GenericsUpperBoundedWildcardDemo { public static double sumOfList(List<? extends Number> list) { double s = 0.0; for (Number n : list) { s += n.doubleValue(); } return s; } public static void main(String[] args) { List<Integer> li = Arrays.asList(1, 2, 3); System.out.println("sum = " + sumOfList(li)); } } // Output: // sum = 6.0 复制代码
** 下界通配符
**将未知类型限制为该类型的特定类型或超类类型。
它的语法形式为: <? super Number>
public class GenericsLowerBoundedWildcardDemo { public static void addNumbers(List<? super Integer> list) { for (int i = 1; i <= 5; i++) { list.add(i); } } public static void main(String[] args) { List<Integer> list = new ArrayList<>(); addNumbers(list); System.out.println(Arrays.deepToString(list.toArray())); } } // Output: // [1, 2, 3, 4, 5] 复制代码
无界通配符有两种应用场景:
语法形式: <?>
public class GenericsUnboundedWildcardDemo { public static void printList(List<?> list) { for (Object elem : list) { System.out.print(elem + " "); } System.out.println(); } public static void main(String[] args) { List<Integer> li = Arrays.asList(1, 2, 3); List<String> ls = Arrays.asList("one", "two", "three"); printList(li); printList(ls); } } // Output: // 1 2 3 // one two three 复制代码
前面,我们提到: 泛型不能向上转型。但是,我们可以通过使用通配符来向上转型 。
public class GenericsWildcardDemo { public static void main(String[] args) { List<Integer> intList = new ArrayList<>(); List<Number> numList = intList; // Error List<? extends Integer> intList2 = new ArrayList<>(); List<? extends Number> numList2 = intList2; // OK } } 复制代码
扩展阅读:Oracle 泛型文档
Pair<int, char> p = new Pair<>(8, 'a'); // 编译错误 复制代码
public static <E> void append(List<E> list) { E elem = new E(); // 编译错误 list.add(elem); } 复制代码
public class MobileDevice<T> { private static T os; // error // ... } 复制代码
instanceof
public static <E> void rtti(List<E> list) { if (list instanceof ArrayList<Integer>) { // 编译错误 // ... } } 复制代码
List<Integer> li = new ArrayList<>(); List<Number> ln = (List<Number>) li; // 编译错误 复制代码
List<Integer>[] arrayOfLists = new List<Integer>[2]; // 编译错误 复制代码
// Extends Throwable indirectly class MathException<T> extends Exception { /* ... */ } // 编译错误 // Extends Throwable directly class QueueFullException<T> extends Throwable { /* ... */ // 编译错误 复制代码
public static <T extends Exception, J> void execute(List<J> jobs) { try { for (J job : jobs) // ... } catch (T e) { // compile-time error // ... } } 复制代码
public class Example { public void print(Set<String> strSet) { } public void print(Set<Integer> intSet) { } // 编译错误 } 复制代码
泛型一些约定俗成的命名: