ITEEDU

Java Gossip: 几个定义泛型的例子

您可以在定义泛型类别时，宣告多个类型持有者，例如：

GenericFoo.java

public class GenericFoo< T1, T2> {
	private T1 foo1;
	private T2 foo2;
	public void setFoo1(T1 foo1) {
		this.foo1 = foo1;
	}
	public T1 getFoo1() {
		return foo1;
	}
	public void setFoo2(T2 foo2) {
		this.foo2 = foo2;
	}
	public T2 getFoo2() {
		return foo2;
	}
}

您可以如下使用GenericFoo类别，分别以Integer与Boolean取代T1与T2：

GenericFoo<Integer, Boolean> foo =new GenericFoo<Integer, Boolean>();

如果是数组的话，可以像这样：

GenericFoo.java

public class GenericFoo<T> {
	private T[] fooArray;
	public void setFooArray(T[] fooArray) {
		this.fooArray = fooArray;
	}
	public T[] getFooArray() {
		return fooArray;
	}
}

您可以像下面的方式来使用它：

String[] strs = {"caterpillar", "momor", "bush"};

GenericFoo<String> foo = new GenericFoo<String>();
foo.setFooArray(strs);
strs = foo.getFooArray();

来改写一下 Object 类别 中的 SimpleCollection：

SimpleCollection.java

public class SimpleCollection<T> {
	private T[] objArr;
	private int index = 0;
	public SimpleCollection() {
		objArr = (T[]) new Object[10]; // 预设10个对象空间
	}
	public SimpleCollection(int capacity) {
		objArr = (T[]) new Object[capacity];
	}
	public void add(T t) {
		objArr[index] = t;
		index++;
	}
	public int getLength() {
		return index;
	}
	public T get(int i) {
		return (T) objArr[i];
	}
}

现在您可以直接使用它来当作特定类型对象的容器，例如：

Test.java

public class Test {
	public static void main(String[] args) {
		SimpleCollection<Integer> c =
		new SimpleCollection<Integer>();
		for(int i = 0; i < 10; i++) {
			c.add(new Integer(i));
		}
		for(int i = 0; i < 10; i++) {
			Integer k = c.get(i);
		}
	}
}

另一个SimpleCollection的写法也可以如下，作用是一样的：

SimpleCollection.java

public class SimpleCollection<T> {
	private Object[] objArr;
	private int index = 0;
	public SimpleCollection() {
		objArr = new Object[10]; // 预设10个对象空间
	}
	public SimpleCollection(int capacity) {
		objArr = new Object[capacity];
	}
	public void add(T t) {
		objArr[index] = t;
		index++;
	}
	public int getLength() {
		return index;
	}
	public T get(int i) {
		return (T) objArr[i];
	}
}

如果您已经定义了一个泛型类别，想要用这个类别来于另一个泛型类别中宣告成员的话要如何作？举个实例，假设您已经定义了下面的类别：

GenericFoo.java

public class GenericFoo<T> {
	private T foo;
	public void setFoo(T foo) {
		this.foo = foo;
	}
	public T getFoo() {
		return foo;
	}
}

您想要写一个包装类别（Wrapper），这个类别必须也具有GenericFoo的泛型功能，您可以这么写：

WrapperFoo.java

public class WrapperFoo<T> {
	private GenericFoo<T> foo;
	public void setFoo(GenericFoo<T> foo) {
		this.foo = foo;
	}
	public GenericFoo<T> getFoo() {
		return foo;
	}
}

这么一来，您就可以保留型态持有者 T 的功能，一个使用的例子如下：

GenericFoo<Integer> foo = new GenericFoo<Integer>();
foo.setFoo(new Integer(10));

WrapperFoo<Integer> wrapper = new WrapperFoo<Integer>();
wrapper.setFoo(foo);