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

泛型可以应用于同一个类，该类可以针对多种类型使用，例如构建一个RedisTemplateService组件，用于处理当前应用中所有对象的缓存操作。这篇文章主要介绍泛型应用于接口、方法和匿名内部类的一些知识点和使用案例，也包括《Java编程思想》中对应的练习题的解读。

泛型接口

泛型应用于接口，是工厂方法设计模式的一种应用。我使用《Java编程思想》中的例子进行了练习。

下面这个例子中，CoffeeGenerator用于生成随机的Coffee对象。

  1. package org.java.learn.generics.coffee;
  3. import org.apache.commons.lang3.RandomUtils;
  4. import org.java.learn.util.Generator;
  6. import java.util.Iterator;
  8. /**
  9.  * 实现Iterable接口，表示当前类可以用在循环语句中
  10.  *
  11.  * 作用: User: duqi Date: 2017/11/30 Time: 22:58
  12.  */
  13. public class CoffeeGenerator implements Generator<Coffee>, Iterable<Coffee> {
  14.     private Class[] types = {Latte.class, Mocha.class, Cappuccino.class, Americano.class, Breve.class};
  15.     private int size = 0;
  17.     public CoffeeGenerator() {
  18.     }
  20.     /**
  21.      * 末端哨兵，在case2中for-each语句中，告诉程序什么时候停止
  22.      * @param size
  23.      */
  24.     public CoffeeGenerator(int size) {
  25.         this.size = size;
  26.     }
  28.     @Override
  29.     public Coffee next() {
  30.         try {
  31.             return (Coffee) types[RandomUtils.nextInt(0, types.length-1)].newInstance();
  32.         } catch (Exception e) {
  33.             throw new RuntimeException();
  34.         }
  35.     }
  37.     class CoffeeIterator implements Iterator<Coffee> {
  38.         /**
  39.          * 内部类可以直接访问外部类的属性
  40.          */
  41.         int count = size;
  43.         @Override
  44.         public boolean hasNext() {
  45.             return count > 0;
  46.         }
  48.         @Override
  49.         public Coffee next() {
  50.             count--;
  51.             return CoffeeGenerator.this.next();
  52.         }
  54.         @Override
  55.         public void remove() {
  56.             throw new UnsupportedOperationException();
  57.         }
  58.     }
  60.     @Override
  61.     public Iterator<Coffee> iterator() {
  62.         return new CoffeeIterator();
  63.     }
  65.     public static void main(String[] args) {
  66.         //case1：测试CoffeeGenerator的next()方法；
  67.         CoffeeGenerator gen = new CoffeeGenerator();
  68.         for (int i = 0; i < 5; i++) {
  69.             System.out.println(gen.next());
  70.         }
  72.         //case2: 测试在for-each语句中生成对象
  73.         for (Coffee coffee: new CoffeeGenerator(5)) {
  74.             System.out.println(coffee);
  75.         }
  76.     }
  77. }

再看一个例子，使用Generator接口生成Fibonacci数列。

  1. package org.java.learn.generics.coffee;
  3. import org.java.learn.util.Generator;
  5. /**
  6.  * 作用: User: duqi Date: 2017/12/2 Time: 13:59
  7.  */
  8. public class Fibonacci implements Generator<Integer> {
  10.     private int count = 0; //全部是int基本类型，但是类型参数是Integer
  12.     @Override
  13.     public Integer next() {
  14.         return fib(count++);
  15.     }
  17.     private int fib(int n) {
  18.         if (n < 2) {
  19.             return 1;
  20.         }
  21.         return fib(n - 2) + fib(n - 1);
  22.     }
  24.     public static void main(String[] args) {
  25.         Fibonacci fibonacci = new Fibonacci();
  26.         for (int i = 0; i < 18; i++) {
  27.             System.out.print(fibonacci.next() + " ");
  28.         }
  29.     }
  30. }

如果希望将这个Fibonacci生成器用于循环语句，书中的例子用的是继承Fibonacci，写一个IterableFibonacci类，该类实现了Iterable接口。在练习7中，作者提示可以使用“组合代替继承”实现同样的功能，我尝试自己做了下，这是我的实现：

  1. package org.java.learn.generics;
  3. import java.util.Iterator;
  5. /**
  6.  * 组合代替继承，实现适配器模式
  7.  *
  8.  * IterableFibonacci2适配Fibonacci为可被循环语句使用的生成器
  9.  *
  10.  * 作用: User: duqi Date: 2017/12/2 Time: 14:08
  11.  */
  12. public class IterableFibonacci2 implements Iterable<Integer> {
  14.       //末端哨兵
  15.     private int n;
  17.     private Fibonacci fibonacci; //组合代替继承
  19.     public IterableFibonacci2(int n, Fibonacci fibonacci) {
  20.         this.n = n;
  21.         this.fibonacci = fibonacci;
  22.     }
  24.     @Override
  25.     public Iterator<Integer> iterator() {
  26.         return new Iterator<Integer>() {
  27.             @Override
  28.             public boolean hasNext() {
  29.                 return n > 0;
  30.             }
  32.             @Override
  33.             public Integer next() {
  34.                 n--;
  35.                 return fibonacci.next();
  36.             }
  38.             @Override
  39.             public void remove() {
  40.                 throw new UnsupportedOperationException();
  41.             }
  42.         };
  43.     }
  45.     public static void main(String[] args) {
  46.         for (int i: new IterableFibonacci2(18, new Fibonacci())) {
  47.             System.out.print(i + " ");
  48.         }
  49.     }
  50. }
  • 上面三个例子中，提到了两种设计模式：工厂方法设计模式和适配器模式。
  • 在泛型中，基本类型无法作为类型参数，但是Java提供了自动打包和拆包的功能；

泛型方法

知识点总结

  • 如果使用泛型方法可以取代将整个类（或接口）泛型化，那么就应该只使用泛型方法；
  • static方法要使用泛型能力，就必须成为泛型方法；

  • 类型推断：这是编译器的特性。在使用泛型类的时候，必须在创建对象的时候指定类型参数的值，但是在使用泛型方法时候，不必指明参数类型。

    • 类型推断只对赋值操作有效
  • 泛型方法与可变参数可以一起使用

例子1：使用Generator的泛型方法

  1. package org.java.learn.generics;
  3. import org.java.learn.generics.coffee.Coffee;
  4. import org.java.learn.generics.coffee.CoffeeGenerator;
  5. import org.java.learn.util.Generator;
  7. import java.util.ArrayList;
  8. import java.util.Collection;
  10. /**
  11.  * 作用: User: duqi Date: 2017/12/2 Time: 14:58
  12.  */
  13. public class Generators {
  15.     /**
  16.      * 泛型方法的定义格式——将泛型参数列表放在方法的返回值左面
  17.      */
  18.     public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen, int n) {
  19.         for (int i = 0; i < n; i++) {
  20.             coll.add(gen.next());
  21.         }
  22.         return coll;
  23.     }
  25.     public static void main(String[] args) {
  26.         Collection<Coffee> coffees = fill(new ArrayList<>(), new CoffeeGenerator(), 4);
  27.         for (Coffee coffee : coffees) {
  28.             System.out.println(coffee);
  29.         }
  31.         Collection<Integer> numers = fill(new ArrayList<>(), new Fibonacci(), 12);
  32.         for (int i : numers) {
  33.             System.out.print(i + " ");
  34.         }
  35.     }
  36. }

例子2：一个通用的Generator

下面这个例子，是一个通用的生成器，只需要传入指定的类型，就可以生成对应类型的对象。

  1. package org.java.learn.util;
  3. /**
  4.  * 作用: User: duqi Date: 2017/12/2 Time: 15:04
  5.  */
  6. public class BasicGenerator<T> implements Generator<T> {
  8.     private Class<T> type;
  10.     public BasicGenerator(Class<T> type) {
  11.         this.type = type;
  12.     }
  14.     @Override
  15.     public T next() {
  16.         try {
  17.             return type.newInstance();
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.             throw new RuntimeException(e);
  21.         }
  22.     }
  24.     public static <T> Generator<T> create(Class<T> type) {
  25.         return new BasicGenerator<>(type);
  26.     }
  27. }

上面这段代码可以创建什么类的对象呢？（1）public的类；（2）含有默认构造器的类；这里给出一个例子：

  1. package org.java.learn.generics;
  3. /**
  4.  * 作用: User: duqi Date: 2017/12/2 Time: 15:10
  5.  */
  6. public class CountedObject {
  8.     private static long counter = 0;
  9.     private final long id = counter++;
  11.     public long getId() {
  12.         return id;
  13.     }
  15.     @Override
  16.     public String toString() {
  17.         return "CounteredObject " + id;
  18.     }
  19. }

然后再给出一个使用上述构造器的例子，书中的例子是使用BasicGenerator的create()方法，我这里还实现了练习14中提到的方法，参见：

  1. package org.java.learn.generics;
  3. import org.java.learn.util.BasicGenerator;
  4. import org.java.learn.util.Generator;
  6. /**
  7.  * 作用: User: duqi Date: 2017/12/2 Time: 15:11
  8.  */
  9. public class BasicGeneratorDemo {
  11.     public static void main(String[] args) {
  12.         Generator<CountedObject> gen = BasicGenerator.create(CountedObject.class);
  13.         for (int i = 0; i < 5; i++) {
  14.             System.out.println(gen.next());
  15.         }
  17.         //练习14：不使用create方法，使用显式的构造器
  18.         Generator<CountedObject> generator = new BasicGenerator<>(CountedObject.class);
  19.         for (int i = 0; i < 5; i++) {
  20.             System.out.println(generator.next());
  21.         }
  22.     }
  23. }

例子3：简化元组的使用

之前的一篇文章里，已经实现过TwoTuple、ThreeTuple等工具类，但是使用的时候还不太方便，这里利用泛型方法实现一个工具类，可以简化元组的使用。

  1. package org.java.learn.util.tuple;
  3. /**
  4.  * 作用: User: duqi Date: 2017/12/2 Time: 15:21
  5.  */
  6. public class Tuple {
  8.     public static <A, B> TwoTuple<A, B> tuple(A a, B b) {
  9.         return new TwoTuple<>(a, b);
  10.     }
  12.     public static <A, B, C> ThreeTuple<A, B, C> tuple(A a, B b, C c) {
  13.         return new ThreeTuple<>(a, b, c);
  14.     }
  16.     public static <A, B, C, D> FourTuple<A, B, C, D> tuple(A a, B b, C c, D d) {
  17.         return new FourTuple<>(a, b, c, d);
  18.     }
  19. }

这个工具类的使用例子如下：

  1. package org.java.learn.util.tuple;
  3. import org.java.learn.generics.coffee.Breve;
  4. import org.java.learn.generics.coffee.Cappuccino;
  6. import static org.java.learn.util.tuple.Tuple.*;
  8. /**
  9.  * 作用: User: duqi Date: 2017/12/2 Time: 15:24
  10.  */
  11. public class TupleTest {
  13.     static TwoTuple<String, Integer> f() {
  14.         return tuple("hi", 47);
  15.     }
  17.     static TwoTuple f2() {
  18.         return tuple("hi", 47);
  19.     }
  21.     static ThreeTuple<Breve, String, Integer> g() {
  22.         return tuple(new Breve(), "hi", 44);
  23.     }
  25.     static FourTuple<Cappuccino, Breve, String, Integer> h() {
  26.         return tuple(new Cappuccino(), new Breve(), "hi", 447);
  27.     }
  29.     public static void main(String[] args) {
  30.         TwoTuple<String, Integer> ttsi = f();
  31.         System.out.println(ttsi);
  32.         /**
  33.          * 这里没有发出告警，是因为我们将f2()的返回值直接返回，并没有再尝试转为参数化对象；
  34.          */
  35.         System.out.println(f2());
  36.         System.out.println(g());
  37.         System.out.println(h());
  39.         /**
  40.          * 练习15：这里尝试将f2的返回值转为一个参数化对象，就收到了报警
  41.          */
  42.         TwoTuple<String, Integer> ttsi2 = f2();
  43.     }
  44. }

例子4：一个Set实用工具

书中提供了一个Sets工具类，用于实现常用的集合操作，代码如下：

  1. package org.java.learn.util;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. /**
  7.  * 作用: User: duqi Date: 2017/12/2 Time: 15:40
  8.  */
  9. public class Sets {
  11.     /**
  12.      * A和B的并集
  13.      * @param a
  14.      * @param b
  15.      * @param <T>
  16.      * @return
  17.      */
  18.     public static <T> Set<T> union(Set<T> a, Set<T> b) {
  19.         Set<T> result = new HashSet<>(a);
  20.         result.addAll(b);
  21.         return result;
  22.     }
  24.     /**
  25.      * A和B的交集
  26.      * @param a
  27.      * @param b
  28.      * @param <T>
  29.      * @return
  30.      */
  31.     public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
  32.         Set<T> result = new HashSet<>(a);
  33.         result.retainAll(b);
  34.         return result;
  35.     }
  37.     /**
  38.      * A和B的差集，将A中移除B中的元素
  39.      * @param superset
  40.      * @param subset
  41.      * @param <T>
  42.      * @return
  43.      */
  44.     public static <T> Set<T> difference(Set<T> superset, Set<T> subset) {
  45.         Set<T> result = new HashSet<>(superset);
  46.         result.removeAll(subset);
  47.         return result;
  48.     }
  50.     /**
  51.      * A和B中所有的元素，减去A和B的交集，剩下的元素
  52.      * @param a
  53.      * @param b
  54.      * @param <T>
  55.      * @return
  56.      */
  57.     public static <T> Set<T> complement(Set<T> a, Set<T> b) {
  58.         return difference(union(a, b), intersection(a, b));
  59.     }
  61. }

# 总结

  1. 本节涉及的知识点：泛型接口、泛型方法
  2. 本节练习用的代码：LearnJava

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