大可制作：QQ群：31564239（asp|jsp|php|mysql）

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);