15.3 泛型接口 生成器(Generator)

        泛型可以应用于接口,例如生成器(Generator),这是一种专门创建对象的类，这是于工厂方法设计模式的一种应用，不过，当我们使用生成器创建对象的时候，我们不需要任何参数，而工厂方法一般需要参数，这也就是说，生成器无需额外的信息就可以生成对象。

        一般而言，生成器需要一个方法来创建对象

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

        下面是具体演示如何使用这个生成器：

public class Coffee {
    private static long counter=0;
    private final long id = counter++;
    public String toString( ){
        return getClass().getSimpleName() + " " + id;
    }
}

public class Latte extends Coffee {}

public class Mocha extends Coffee {}

public class Cappuccino extends Coffee {}

public class Breve extends Coffee {}

public class Americano 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);
    private int size = 0;

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

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

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

    class CoffeeIterator implements Iterator<Coffee> {
        int count = size;
        public boolean hasNext(){
            return count > 0;
        }

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

    public static void main(String[] args) {
        CoffeeGenerator gen = new CoffeeGenerator();

        IntStream.range(0,5).forEach(i -> System.out.println(gen.next()));

        CoffeeGenerator g = new CoffeeGenerator(5);
        g.forEach(coffee -> System.out.println(coffee));
    }

}

        上面这个类实现了生成器，可以自己调用next()方法

        同时提供了自己的迭代器，每一次迭代都会随机生成一个coffee对象，不过需要一个末端哨兵来探测尾部值，有参构造的意义就在此。

        下面是斐波那契数的一个实现：

    

public class Fibonacci implements Generator<Integer> {
    private int count = 0;

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

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

        我们发现了源码，确没有办法对它进行更改，这个时候可以使用适配器模式:

public class IterableFibonacci extends Fibonacci implements Iterable<Integer>{
    private int size = 0;
    public IterableFibonacci() {
    }

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

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

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

    public static void main(String[] args) {
        IterableFibonacci ifi = new IterableFibonacci(5);
        ifi.forEach(i -> System.out.println(i) );

        Generator gen = new Fibonacci();
        IntStream.range(0,5).forEach(i-> System.out.println(gen.next()));

    }
}

        对类进行了扩张和增强，不过上面的类在能修改的情况下，最好使用内部类的形式，因为继承普通类是一种很危险的形式，慎用