泛型（2）：泛型接口

柔光的暖阳◎ 2023-07-14 10:40 1阅读 0赞

### 一、泛型接口 ###

泛型也可以应用于接口。例如生成器（Generator），这是一种专门负责创建对象的类。实际上，这是工厂方法设计模式的一种应用。不过，当使用生成器创建新的对象时，它不需要任何参数，而工厂方法一般需要参数。也就是说，生成器无需额外的信息就知道如何创建新对象。

一般而言，一个生成器只定义一个方法，该方法用以产生新的对象。在这里，就是next()方法。我将它收录在我的标准工具类库中：

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

方法next()的返回类型是参数化T。正如你所见到的，接口使用泛型与类使用泛型没什么区别。为了演示如何实现Generator接口，我们还需要一些别的类。例如，Coffee类层次结构如下：

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 Americano extends Coffee {
    }

public class Breve extends Coffee {
    }

现在，我们可以编写一个类，实现Generator<Coffee>接口，它能够随机生成不同类型的Coffee对象：

import java.util.Iterator;
    import java.util.Random;
    
    import com.buba.util.Generator;
    
    public class CoffeeGenerator implements Generator<Coffee>, Iterable<Coffee> {
    
    	private Class[] types = { Latte.class, Mocha.class, Cappuccino.class, Americano.class, Breve.class };
    	private static Random r = new Random();
    
    	public CoffeeGenerator() {
    	}
    
    	private int size = 0;
    
    	public CoffeeGenerator(int sz) {
    		size = sz;
    	}
    
    	@Override
    	public Coffee next() {
    		try {
    			return (Coffee) types[r.nextInt(types.length)].newInstance();
    		} catch (InstantiationException e) {
    			throw new RuntimeException(e);
    		} catch (IllegalAccessException e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	class CoffeeIterator implements Iterator<Coffee> {
    
    		int count = size;
    
    		@Override
    		public boolean hasNext() {
    			return count > 0;
    		}
    
    		@Override
    		public Coffee next() {
    			count--;
    			return CoffeeGenerator.this.next();
    		}
    	}
    
    	@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());
    		for (Coffee c : new CoffeeGenerator(5))
    			System.out.println(c);
    	}
    }

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

下面的类是Generator<T>接口的另一个实现，它负责生成Fibonacci（斐波那契）数列：

import com.buba.util.Generator;
    
    public class Fibonacci implements Generator<Integer> {
    
    	private int count = 0;
    
    	@Override
    	public Integer next() {
    		return fib(count++);
    	}
    
    	private Integer 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.println(gen.next() + " ");
    	}
    }

虽然我们在Fibonacci类的里里外外使用的都是int类型，但是其类型参数确实Integer。这个例子引出了java泛型的一个局限性：基本类型无法作为类型参数。不过，java SE5具备了自动打包和自动拆包的功能，可以很方便地在基本类型和其相应的包装器类型之间进行转换。通过这个例子中Fibonacci类对int的使用，我们已经看到了这种结果。

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

有多种方法可以实现适配器。例如，可以通过继承来创建适配器类：

import java.util.Iterator;
    
    public class IterableFibonacci extends Fibonacci implements Iterable<Integer> {
    
    	private int n;
    
    	public IterableFibonacci(int count) {
    		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();
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		for (int i : new IterableFibonacci(18))
    			System.out.print(i + " ");
    	}
    }

如果要在循环语句中使用IterableFibonacci，必须向IterableFibonacci的构造器中提供一个边界值，然后hasNext()方法才能知道何时应该返回false。

**如果本文对您有很大的帮助，还请点赞关注一下。**