泛型接口

泛型接口的概念

泛型也可以运用于接口，例如生成器(generator)，这是一种专门负责创建对象的类，实际上，这是工厂方法设计模式的一种应用。不过两者之间不同的是，生成器的调用不需要任何参数，但是工厂方法一般需要参数来调用。这就意味着生成器不需要额外的信息去生成新的对象。

生成器接口的定义

一般来说，一个生成器只定义一个方法，该方法用于产生新的对象。在这里，就是next()方法。

public interface Generator<T> {
    T next();
}

创建Coffee生成器

首先我们需要一些类以供生成

// Coffee.java
public class Coffee {
    private static long counter = 0;
    private final long id = counter++;

    @Override
    public String toString() {
        return getClass().getSimpleName() + " " + id;
    }
}

// Latte.java
public class Latte extends Coffee{}

// Mocha.java
public class Mocha extends Coffee{}

// Cappuccino.java
public class Cappuccino extends Coffee{}

// Americano.java
public class Americano extends Coffee{}

// Breve.java
public class Breve extends Coffee{}

接着我们创建一个生成器

public class CoffeeGenerator implements Generator<Coffee>, Iterable<Coffee> {

    private Class[] types = {Latte.class, Mocha.class, Cappuccino.class, Americano.class, Breve.class};

    private Random rand = new Random(47);

    public CoffeeGenerator() {
    }

    private int size = 0;

    public CoffeeGenerator(int size) {
        this.size = size;
    }

    @Override
    public Coffee next() {
        try {
            return (Coffee) types[rand.nextInt(types.length)].newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    class CoffeeIterator implements Iterator<Coffee> {

        int count = size;

        public boolean hasNext() {
            return count > 0;
        }

        @Override
        public Coffee next() {
            count--;
            return CoffeeGenerator.this.next();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    @Override
    public Iterator<Coffee> iterator() {
        return new CoffeeIterator();
    }

    public static void main(String[] args) {
        CoffeeGenerator gen = new CoffeeGenerator();
        for (int i = 0; i < 5; i++) {
            System.out.println("gen.next() = " + gen.next());
        }
        for (Coffee coffee : new CoffeeGenerator(5)) {
            System.out.println("coffee = " + coffee);
        }
    }
}

// Outputs
gen.next() = Americano 0
gen.next() = Latte 1
gen.next() = Americano 2
gen.next() = Mocha 3
gen.next() = Mocha 4
coffee = Americano 5
coffee = Latte 6
coffee = Americano 7
coffee = Mocha 8
coffee = Mocha 9

参数化的Generatoer的接口确保next()的返回值是参数的类型。CoffeeGenerator同时还实现了Iterable接口,所以它可以在ForEach循环中被使用。不过，它还需要一个“末端哨兵”来判断何时停止，这正是第二个构造器的功能。

创建Fibonacci数列生成器

下面的类也实现了Generator<T>接口，它负责生成Fibonacci数列

public class Fibonacci implements Generator<Integer> {

    private int count = 0;

    public Integer next() {
        return fib(count++);
    }

    private int fib(int n) {
        if (n < 2) {
            return 1;
        }
        return fib(n - 2) + fib(n - 1);
    }

    public static void main(String[] args) {
        Fibonacci gen = new Fibonacci();
        for (int i = 0; i < 18; i++) {
            System.out.print(gen.next() + " ");
        }
    }
}

// Outputs
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584

这里注意到，虽然在Fibonacci里面使用的都是int类型，但是其参数类型确是Integer。这是因为Java泛型的局限性：基本类型无法作为类型参数。但是Java SE5提供了自动包装和拆包的功能，可以很方便地在基本类型和其相应的包装器类型之间进行转换。

编写实现了Iterable的Fibonacci生成器

如果还想更进一步，编写一个实现了Iterable的Fibonacci生成器。一个选择是重写这个类，令其实现Iterable接口。
但是我们并不能总是拥有源代码的控制权，并且，除非必须这么做，否则我们也不愿意重写一个类。而且我们还有另一种选择，就是创建一个适配器(adapter)来是实现所需的接口。

public class IterableFibonacci extends Fibonacci implements Iterable<Integer> {

    private int n;

    public IterableFibonacci(int count) {
        this.n = count;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            @Override
            public boolean hasNext() {
                return n > 0;
            }

            @Override
            public Integer next() {
                n--;
                return IterableFibonacci.this.next();
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    public static void main(String[] args) {
        for (int i : new IterableFibonacci(18)) {
            System.out.print(i + " ");
        }
    }
}

// Outputs
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584

这里通过使用了继承来实现了适配器。