关于程序员:什么是-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 类型

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

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

@Override
public 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 圈优质内容，分享干货常识，帮忙你成为更好的程序员！

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

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）