泛型可以应用于接口,例如生成器(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()));
}
}
对类进行了扩张和增强,不过上面的类在能修改的情况下,最好使用内部类的形式,因为继承普通类是一种很危险的形式,慎用