本文首发于个人网站：Java中的泛型（一）

本文主要介绍Java泛型的基本知识，包括目的、泛型类的基本用法和场景应用场景。

目的

  1. 编写更加“泛化”的代码，编写可以应付多重类型的代码
  2. Java中的泛型，用于实现“参数化类型”的概念
  3. 创造可以放不同类型对象的容器类，通过编译器来保证类型的正确；
  4. 能够简单&安全得创建复杂的模型

泛型类

定义

利用Java开发的时候，肯定会有一个类持有另一个或几个类的情况，在编写一些比较基础的组件，例如缓存操作组件，这类组件的逻辑差不多，但是希望能够处理不同的类型。

在Java SE5之前，我们可以通过Object这个类型来实现，举个例子：

  1. package org.java.learn.generics;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 15:45
  5.  */
  6. public class Holder2 {
  8.     private Object a;
  10.     public Holder2(Object a) {
  11.         this.a = a;
  12.     }
  14.     public void setA(Object a) {
  15.         this.a = a;
  16.     }
  18.     public Object getA() {
  19.         return a;
  20.     }
  22.     public static void main(String[] args) {
  23.         Holder2 h2 = new Holder2(new Automobile());
  24.         //这里需要进行类型的强制转换
  25.         Automobile automobile = (Automobile) h2.getA();
  27.         h2.setA("Not a Automobile");
  28.         String s = (String) h2.getA();
  30.         h2.setA(1); //这里发生了自动装箱
  31.         Integer x = (Integer) h2.getA();
  32.     }
  33. }

上面这段代码，确实满足了一个组件持有不同类型对象的需求，但是也有两个问题：（1）取出对象的时候，需要进行类型的强制转换；（2）同一个容器对象，可以随意存取不同类型的对象，有出错的风险。JavaSE5引入了“泛型”的概念，使得代码可以应用于多个类型，同时还能避免上述我说的两个问题，上面的代码，如果用Java泛型实现，则如下所示：

  1. package org.java.learn.generics;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 15:48
  5.  */
  6. public class Holder3<T> {
  8.     private T a;
  10.     public Holder3(T a) {
  11.         this.a = a;
  12.     }
  14.     public void setA(T a) {
  15.         this.a = a;
  16.     }
  18.     public T getA() {
  19.         return a;
  20.     }
  22.     public static void main(String[] args) {
  23.         Holder3<Automobile> h3 = new Holder3<>(new Automobile());
  24.         Automobile automobile = h3.getA(); //这里不需要强制转换类型
  26. //        h3.setA("Not an Automobile");  Error
  27. //        h3.setA(1);                    Error
  28.     }
  29. }

上面的Holder3是持有一个类型参数T，还可以持有三个相同类型（或不同类型的）类型参数，代码如下：

  1. package org.java.learn.generics;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 15:51
  5.  */
  6. public class Holder4<T> {
  8.     private T a;
  9.     private T b;
  10.     private T c;
  12.     public Holder4(T a, T b, T c) {
  13.         this.a = a;
  14.         this.b = b;
  15.         this.c = c;
  16.     }
  18.     public T getA() {
  19.         return a;
  20.     }
  22.     public T getB() {
  23.         return b;
  24.     }
  26.     public T getC() {
  27.         return c;
  28.     }
  30.     public void setA(T a) {
  31.         this.a = a;
  32.     }
  34.     public void setB(T b) {
  35.         this.b = b;
  36.     }
  38.     public void setC(T c) {
  39.         this.c = c;
  40.     }
  42.     public static void main(String[] args) {
  43.         Holder4<Automobile> holder4 = new Holder4<>(new Automobile(),new Automobile(), new Automobile());
  45.         Automobile a = holder4.getA();
  46.         Automobile b = holder4.getB();
  47.         Automobile c = holder4.getC();
  48.     }
  49. }

应用场景

元组

在实际开发中，常常会有“一次方法调用返回多个对象的需求”，我现在有时候会为每个返回值创建一个Class的写法，但是这块不太符合领域模型的思想——混淆了Entity和Object Value的概念。利用元组，可以实现Object Value的概念。

  1. package org.java.learn.util;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 16:18
  5.  */
  6. public class TwoTuple<A, B> {
  7.     public final A first;
  8.     public final B second;
  10.     public TwoTuple(A first, B second) {
  11.         this.first = first;
  12.         this.second = second;
  13.     }
  15.     @Override
  16.     public String toString() {
  17.           //这里隐含表示了：元祖中的元素是有顺序的
  18.         return "(" + first + ", " + second + ")";
  19.     }
  20. }

这个例子中的final关键字用的非常漂亮，有两个设计上的考虑

  • 访问安全，客户端可以读取first和second两个对象，但是无法修改它们；
  • 体现Object Value的含义，如果开发者需要一个不同元素的元组，必须重新构建一个；

利用继承机制，我们还可以实现元素更多的元组，下面的代码展示了三元组和四元组的实现。不过，从另一个角度考虑——如果一个方法调用需要返回四个以上元素的元组，是不是需要考虑下这个方法本身的设计是否合理了呢。

三元组

  1. package org.java.learn.util;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 16:32
  5.  */
  6. public class ThreeTuple<A, B, C> extends TwoTuple<A, B> {
  8.     public final C third;
  10.     public ThreeTuple(A first, B second, C third) {
  11.         super(first, second);
  12.         this.third = third;
  13.     }
  15.     @Override
  16.     public String toString() {
  17.         return "(" + first + ", " + second + ", " + third + ")";
  18.     }
  19. }

四元组

  1. package org.java.learn.util;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 16:36
  5.  */
  6. public class FourTuple<A, B, C, D> extends ThreeTuple<A, B, C> {
  8.     public final D forth;
  10.     public FourTuple(A first, B second, C third, D forth) {
  11.         super(first, second, third);
  12.         this.forth = forth;
  13.     }
  15.     @Override
  16.     public String toString() {
  17.         return "(" + first + ", " + second + ", " + third + "," + forth + ")";
  18.     }
  19. }

堆栈

再看一个比元祖复杂一点的例子，这里利用自己实现的链表存储机制构建了一个下推堆栈。

  1. package org.java.learn.util;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 16:40
  5.  */
  6. public class LinkedStack<T> {
  8.     private static class Node<U> {
  9.         U item;
  10.         Node<U> next;
  12.         public Node() {
  13.             item = null;
  14.             next = null;
  15.         }
  17.         public Node(U item, Node<U> next) {
  18.             this.item = item;
  19.             this.next = next;
  20.         }
  22.         /**
  23.          * 是否到达堆栈底部
  24.          *
  25.          * @return
  26.          */
  27.         boolean end() {
  28.             return item == null || next == null;
  29.         }
  30.     }
  32.     /**
  33.      * 末端哨兵
  34.      */
  35.     private Node<T> top = new Node<>();
  36.     public void push(T item) {
  37.         top = new Node<>(item, top);
  38.     }
  39.     public T pop() {
  40.         T res = top.item;
  41.         if (!top.end()) {
  42.             top = top.next;
  43.         }
  44.         return res;
  45.     }
  47.     public static void main(String[] args) {
  48.         LinkedStack<String> lss = new LinkedStack<>();
  49.         for (String s: "Phasers on stun!".split(" ")) {
  50.             lss.push(s);
  51.         }
  52.         String s;
  53.         while ((s = lss.pop()) != null) {
  54.             System.out.println(s);
  55.         }
  56.     }
  57. }

书中的练习题5：移除Node类上的类型参数，并修改LinkedStack.java的代码，说明内部类可以访问外部类的类型参数，我自己试了下，代码如下：

  1. package org.java.learn.util;
  3. /**
  4.  * 作用: User: duqi Date: 2017/11/19 Time: 16:40
  5.  */
  6. public class LinkedStack2<T> {
  8.     /**
  9.      * 这里不能使用静态内部类
  10.      */
  11.     private class Node {
  12.         T item;
  13.         Node next;
  15.         public Node() {
  16.             item = null;
  17.             next = null;
  18.         }
  20.         public Node(T item, Node next) {
  21.             this.item = item;
  22.             this.next = next;
  23.         }
  25.         /**
  26.          * 是否到达堆栈底部
  27.          *
  28.          * @return
  29.          */
  30.         boolean end() {
  31.             return item == null || next == null;
  32.         }
  33.     }
  35.     /**
  36.      * 末端哨兵
  37.      */
  38.     private Node top = new Node();
  39.     public void push(T item) {
  40.         top = new Node(item, top);
  41.     }
  42.     public T pop() {
  43.         T res = top.item;
  44.         if (!top.end()) {
  45.             top = top.next;
  46.         }
  47.         return res;
  48.     }
  50.     public static void main(String[] args) {
  51.         LinkedStack<String> lss = new LinkedStack<>();
  52.         for (String s: "Phasers on stun!".split(" ")) {
  53.             lss.push(s);
  54.         }
  55.         String s;
  56.         while ((s = lss.pop()) != null) {
  57.             System.out.println(s);
  58.         }
  59.     }
  60. }

代码显示，静态内部类，无法访问其外部类的类型参数，但是非静态内部类可以。

RandomList

书中还给出一个随机列表的例子——一个持有特定类型对象的列表，select()方法可以随机取出列表中的一个元素。这是一个抽奖demo，或者我们可以用它决定每天中午吃什么😜。

  1. package org.java.learn.generics;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Random;
  7. /**
  8.  * 作用: 持有特定类型对象的列表,select()方法可以随机取一个元素
  9.  * User: duqi
  10.  * Date: 2017/11/19
  11.  * Time: 17:08
  12.  */
  13. public class RandomList<T> {
  15.     private ArrayList<T> storage = new ArrayList<>();
  17.     private Random random = new Random(47);
  19.     public void add(T item) {
  20.         storage.add(item);
  21.     }
  22.     public T select() {
  23.         return storage.get(random.nextInt(storage.size()));
  24.     }
  26.     public static void main(String[] args) {
  27.         RandomList<String> randomList = new RandomList<>();
  28.         for (String s: "The queick brown for jumped over the lazy brown dog".split(" ")) {
  29.             randomList.add(s);
  30.         }
  31.         for (int i = 0; i < 11; i++) {
  32.             System.out.print(randomList.select() + " ");
  33.         }
  34.     }
  35. }

总结

泛型的东西很多，我之前看《Java核心技术》学过一遍，最近为了给团队的同学做分享，准备再结合《Java编程思想》复习一遍，发现《Java编程思想》这本书写得非常有深度，需要思考、实践和回味，才能准确得get到作者想要表达的意思。

本号专注于后端技术、JVM问题排查和优化、Java面试题、个人成长和自我管理等主题，为读者提供一线开发者的工作和成长经验，期待你能在这里有所收获。
Java泛型基础（一）：基本概念 - 图1