关于程序员:什么是-Java-泛型

本文首发自「慕课网」，想理解更多IT干货内容，程序员圈内热闻，欢送关注！

作者| 慕课网精英讲师 ColorfulC

通过本篇文章你将理解到什么是泛型，为什么须要泛型，如何应用泛型，如何自定义泛型，类型通配符等常识。1. 什么是泛型泛型不只是 Java 语言所特有的个性，泛型是程序设计语言的一种个性。容许程序员在强类型的程序设计语言中编写代码时定义一些可变局部，那些局部在应用前必须做出申明。Java 中的汇合类是反对泛型的，它在代码中是这个样子的：

代码中的<Integer>就是泛型，咱们把类型像参数一样传递，尖括号两头就是数据类型，咱们能够称之为理论类型参数，这里理论类型参数的数据类型只能为援用数据类型。那么为什么须要泛型呢？咱们马上就见分晓。2. 为什么须要泛型咱们在应用ArrayList实现类的时候，如果没有指定泛型，IDEA会给出正告，代码仿佛也是能够顺利运行的。请看如下实例：import java.util.ArrayList;

public class GenericsDemo1 {

public static void main(String[] args) {    ArrayList arrayList = new ArrayList();    arrayList.add("Hello");    String str = (String) arrayList.get(0);    System.out.println("str=" + str);}

}
代码块123456789101112运行后果：str=Hello
代码块1尽管运行时没有产生任何异样，但这样做有两个毛病：须要强制类型转换：因为ArrayList外部就是一个Object[]数组，在get()元素的时候，返回的是Object类型，所以在ArrayList外获取该对象，须要强制类型转换。其它的Collection、Map如果不应用泛型，也存在这个问题；可向汇合中增加任意类型的对象，存在类型不平安危险。例如如下代码中，咱们向列表中既增加了Integer类型，又增加了String类型：import java.util.ArrayList;

public class GenericsDemo2 {

public static void main(String[] args) {    ArrayList arrayList = new ArrayList();    arrayList.add(123);    arrayList.add("Hello");    String str = (String) arrayList.get(0);    System.out.println("element=" + str);}

}
代码块1234567891011运行后果：Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')

at GenericsDemo2.main(GenericsDemo2.java:8)

代码块12因为咱们的“忽略”，列表第 1 个元素实际上是整型，但被咱们强制转换为字符串类型，这是行不通的，因而会抛出ClassCastException异样。应用泛型能够解决这些问题。泛型有如下长处：能够缩小类型转换的次数，代码更加简洁；程序更加强壮：只有编译期没有正告，运行期就不会抛出ClassCastException异样；进步了代码的可读性：编写汇合的时候，就限定了汇合中能寄存的类型。3. 如何应用泛型3.1 泛型应用在代码中，这样应用泛型：List<String> list = new ArrayList<String>();
// Java 7 及当前的版本中，构造方法中能够省略泛型类型：
List<String> list = new ArrayList<>();
代码块123要留神的是，变量申明的类型必须与传递给理论对象的类型保持一致，上面是谬误的例子：List<Object> list = new ArrayList<String>();
List<Number> numbers = new ArrayList(Integer);
代码块123.2 自定义泛型类3.2.1 Java 源码中泛型的定义在自定义泛型类之前，咱们来看下java.util.ArrayList是如何定义的：

类名前面的<E>就是泛型的定义，E不是 Java 中的一个具体的类型，它是 Java 泛型的通配符（留神是大写的，实际上就是Element的含意），可将其了解为一个占位符，将其定义在类上，应用时才确定类型。此处的命名不受限制，但最好有肯定含意，例如java.lang.HashMap的泛型定义为HashMap<K,V>，K示意Key，V示意Value。3.2.2 自定义泛型类实例1上面咱们来自定义一个泛型类，自定义泛型依照约定俗成能够叫<T>，具备Type的含意，实例如下：实例演示public class NumberGeneric<T> { // 把泛型定义在类上

private T number; // 定义在类上的泛型，在类外部能够应用public T getNumber() {    return number;}public void setNumber(T number) {    this.number = number;}public static void main(String[] args) {    // 实例化对象，指定元素类型为整型    NumberGeneric<Integer> integerNumberGeneric = new NumberGeneric<>();    // 别离调用set、get办法    integerNumberGeneric.setNumber(123);    System.out.println("integerNumber=" + integerNumberGeneric.getNumber());    // 实例化对象，指定元素类型为长整型    NumberGeneric<Long> longNumberGeneric = new NumberGeneric<>();    // 别离调用set、get办法    longNumberGeneric.setNumber(20L);    System.out.println("longNumber=" + longNumberGeneric.getNumber());    // 实例化对象，指定元素类型为双精度浮点型    NumberGeneric<Double> doubleNumberGeneric = new NumberGeneric<>();    // 别离调用set、get办法    doubleNumberGeneric.setNumber(4000.0);    System.out.println("doubleNumber=" + doubleNumberGeneric.getNumber());}

}
123456789101112131415161718192021222324252627282930313233运行后果：integerNumber=123
longNumber=20
doubleNumber=4000.0
代码块123咱们在类的定义处也定义了泛型：NumberGeneric<T>；在类外部定义了一个T类型的number变量，并且为其增加了setter和getter办法。对于泛型类的应用也很简略，在主办法中，创建对象的时候指定T的类型别离为Integer、Long、Double，类就能够主动转换成对应的类型了。3.2.3 自定义泛型类实例2下面咱们晓得了如何定义含有单个泛型的类，那么对于含有多个泛型的类，如何定义呢？咱们能够看一下HashMap类是如何定义的。如下是 Java 源码的截图：

参照HashMap<K,V>类的定义，上面咱们来看看如何定义含有两个泛型的类，实例如下：实例演示public class KeyValueGeneric<K,V> { // 把两个泛型K、V定义在类上

/** * 类型为K的key属性 */private K key;/** * 类型为V的value属性 */private V value;public K getKey() {    return key;}public void setKey(K key) {    this.key = key;}public V getValue() {    return value;}public void setValue(V value) {    this.value = value;}public static void main(String[] args) {    // 实例化对象，别离指定元素类型为整型、长整型    KeyValueGeneric<Integer, Long> integerLongKeyValueGeneric = new KeyValueGeneric<>();    // 调用setter、getter办法    integerLongKeyValueGeneric.setKey(200);    integerLongKeyValueGeneric.setValue(300L);    System.out.println("key=" + integerLongKeyValueGeneric.getKey());    System.out.println("value=" + integerLongKeyValueGeneric.getValue());    // 实例化对象，别离指定元素类型为浮点型、字符串类型    KeyValueGeneric<Float, String> floatStringKeyValueGeneric = new KeyValueGeneric<>();    // 调用setter、getter办法    floatStringKeyValueGeneric.setKey(0.5f);    floatStringKeyValueGeneric.setValue("零点五");    System.out.println("key=" + floatStringKeyValueGeneric.getKey());    System.out.println("value=" + floatStringKeyValueGeneric.getValue());}

}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546运行后果：key=200
value=300
key=0.5
value=零点五
代码块12343.3 自定义泛型办法后面咱们晓得了如何定义泛型类，在类上定义的泛型，在办法中也能够应用。上面咱们来看一下如何自定义泛型办法。泛型办法不肯定写在泛型类当中。当类的调用者总是关怀类中的某个泛型办法，不关怀其余属性，这个时候就没必要再整个类上定义泛型了。请查看如下实例：实例演示public class GenericMethod {

/** * 泛型办法show * @param t 要打印的参数 * @param <T> T */public <T> void show(T t) {    System.out.println(t);}public static void main(String[] args) {    // 实例化对象    GenericMethod genericMethod = new GenericMethod();    // 调用泛型办法show，传入不同类型的参数    genericMethod.show("Java");    genericMethod.show(222);    genericMethod.show(222.0);    genericMethod.show(222L);}

}
123456789101112131415161718192021运行后果：Java
222
222.0
222
代码块1234实例中，应用<T>来定义show办法的泛型，它接管一个泛型的参数变量并在办法体打印；调用泛型办法也很简略，在主办法中实例化对象，调用对象下的泛型办法，可传入不同类型的参数。4. 泛型类的子类泛型类也是一个 Java 类，它也具备继承的个性。泛型类的继承可分为两种状况：子类明确泛型类的类型参数变量；子类不明确泛型类的类型参数变量。上面咱们来别离看一下这两种状况。4.1 明确类型参数变量例如，有一个泛型接口：public interface GenericInterface<T> { // 在接口上定义泛型

void show(T t);

}
代码块123泛型接口的实现类如下：public class GenericInterfaceImpl implements GenericInterface<String> { // 明确泛型类型为String类型

@Overridepublic void show(String s) {    System.out.println(s);}

}
代码块123456子类实现明确了泛型的参数变量为String类型。因而办法show()的重写也将T替换为了String类型。4.2 不明确类型参数变量当实现类不确定泛型类的参数变量时，实现类须要定义类型参数变量，调用者应用子类时，也须要传递类型参数变量。如下是GenericInterface接口的另一个实现类：public class GenericInterfaceImpl1<T> implements GenericInterface<T> { // 实现类也须要定义泛型参数变量

@Overridepublic void show(T t) {    System.out.println(t);}

}
代码块123456在主办法中调用实现类的show()办法： public static void main(String[] args) {

    GenericInterfaceImpl1<Float> floatGenericInterfaceImpl1 = new GenericInterfaceImpl1<>();    floatGenericInterfaceImpl1.show(100.1f);}

代码块12345. 类型通配符咱们先来看一个泛型作为办法参数的实例：import java.util.ArrayList;
import java.util.List;

public class GenericDemo3 {

/** * 遍历并打印汇合中的每一个元素 * @param list 要接管的汇合 */public void printListElement(List<Object> list) {    for (Object o : list) {        System.out.println(o);    }}

}
代码块1234567891011121314察看下面的代码，参数list的限定的泛型类型为Object，也就是说，这个办法只能接管元素为Object类型的汇合，如果咱们想传递其余元素类型的汇合，是行不通的。例如，如果传递装载Integer元素的汇合，程序在编译阶段就会报错：

Tips：泛型中的List<Object>并不是List<Integer>的父类，它们不满足继承关系。5.1 有限定通配符想要解决这个问题，应用类型通配符即可，批改办法参数处的代码，将<>两头的Object改为?即可：public void printListElement(List<?> list) {
代码块1此处的?就是类型通配符，示意能够匹配任意类型，因而调用方能够传递任意泛型类型的列表。残缺实例如下：实例演示import java.util.ArrayList;
import java.util.List;

public class GenericDemo3 {

/** * 遍历并打印汇合中的每一个元素 * @param list 要接管的汇合 */public void printListElement(List<?> list) {    for (Object o : list) {        System.out.println(o);    }}public static void main(String[] args) {    // 实例化一个整型的列表    List<Integer> integers = new ArrayList<>();    // 增加元素    integers.add(1);    integers.add(2);    integers.add(3);    GenericDemo3 genericDemo3 = new GenericDemo3();    // 调用printListElement()办法    genericDemo3.printListElement(integers);    // 实例化一个字符串类型的列表    List<String> strings = new ArrayList<>();    // 增加元素    strings.add("Hello");    strings.add("慕课网");    // 调用printListElement()办法    genericDemo3.printListElement(strings);}

}
12345678910111213141516171819202122232425262728293031323334运行后果：1
2
3
Hello
慕课网
代码块123455.2 extends 通配符extends通配符用来限定泛型的下限。什么意思呢？仍旧以下面的实例为例，咱们来看一个新的需要，咱们心愿办法接管的List 汇合限定在数值类型内（float、integer、double、byte 等），不心愿其余类型能够传入（比方字符串）。此时，能够改写下面的办法定义，设定上界通配符：public void printListElement(List<? extends Number> list) {
代码块1这样的写法的含意为：List汇合装载的元素只能是Number本身或其子类（Number类型是所有数值类型的父类），残缺实例如下：实例演示import java.util.ArrayList;
import java.util.List;

public class GenericDemo4 {

/** * 遍历并打印汇合中的每一个元素 * @param list 要接管的汇合 */public void printListElement(List<? extends Number> list) {    for (Object o : list) {        System.out.println(o);    }}public static void main(String[] args) {    // 实例化一个整型的列表    List<Integer> integers = new ArrayList<>();    // 增加元素    integers.add(1);    integers.add(2);    integers.add(3);    GenericDemo4 genericDemo3 = new GenericDemo4();    // 调用printListElement()办法    genericDemo3.printListElement(integers);}

}
123456789101112131415161718192021222324252627运行后果：1
2
3
代码块1235.3 super 通配符既然曾经理解了如何设定通配符上界，也就不难理解通配符的下界了，能够限定传递的参数只能是某个类型的父类。语法如下：<? super Type>
代码块1

小结

在本篇文章中，咱们晓得了应用泛型能够防止强制类型转换，也能够防止运行期就抛出的ClassCastException异样。在应用泛型时，要留神变量申明的泛型类型要匹配传递给理论对象的类型， Java 7 及当前的版本中，构造方法中能够省略泛型类型，举荐间接省略。咱们也学习了如何自定义泛型类和泛型办法，在理论的开发中，咱们想要编写比拟通用的代码就防止不了应用泛型，大家能够在当前的开发中缓缓体悟。另外，泛型也是能够继承的。最初，咱们还解说了类型通配符的概念和应用场景。

欢送关注「慕课网」，发现更多IT圈优质内容，分享干货常识，帮忙你成为更好的程序员！