泛型

分别用几个demo说明一下泛型的用法。

1、 一个泛型变量

/**
 * 一个泛型
 *
 * @param <T> 泛型(类型变量)
 */
public class GenericFoo<T>
{
    private T foo;

    public T getFoo()
    {
        return foo;
    }

    public void setFoo(T foo)
    {
        this.foo = foo;
    }
    
    @Override
    public String toString()
    {
        // TODO Auto-generated method stub
        return super.toString();
    }
    
    public static void main(String[] args)
    {
        //将类型变量具化为Bollean，foo即为Boolean类型
        GenericFoo<Boolean> foo1 = new GenericFoo<>();
        //将类型变量具化为Integer，foo即为Integer类型
        GenericFoo<Integer> foo2 = new GenericFoo<>();
        
        //由于类只定义了set和get方法。所以只能通过set方法赋值，get方法取值
        foo1.setFoo(new Boolean(false));
        foo2.setFoo(new Integer(888));
        
        Boolean b = foo1.getFoo();
        Integer i = foo2.getFoo();
        
        System.out.println(b);
        System.out.println(i);
        
        
    }

}

2、 两个泛型变量

/**
 * 两个泛型
 *
 * @param <T1> 泛型变量T1
 * @param <T2> 泛型变量T2
 */
public class Generic<T1, T2>
{
    private T1 foo1;
    
    private T2 foo2;

    public T1 getFoo1()
    {
        return foo1;
    }

    public void setFoo1(T1 foo1)
    {
        this.foo1 = foo1;
    }

    public T2 getFoo2()
    {
        return foo2;
    }

    public void setFoo2(T2 foo2)
    {
        this.foo2 = foo2;
    }
    
    public static void main(String[] args)
    {
        Generic<Integer, Boolean> foo = new Generic<>();
        
        foo.setFoo1(new Integer(88));
        foo.setFoo2(new Boolean(true));;
        
        System.out.println(foo.getFoo1());
        System.out.println(foo.getFoo2());
    }
}

3、 数组泛型

/**
 * 数组泛型
 *
 * @param <T> 泛型变量
 */
public class Generic2<T>
{
    private T[] fooArry;

    public T[] getFooArry()
    {
        return fooArry;
    }

    public void setFooArry(T[] fooArry)
    {
        this.fooArry = fooArry;
    }
    
    public static void main(String[] args)
    {
        Generic2<String> foo = new Generic2<>();
        
        String[] str1 = {"hi", "hello", "what"};
        
        foo.setFooArry(str1);
        
        String[] str2 =foo.getFooArry();
        for(String s : str2)
            System.out.println(s);
    }
}

4、 集合泛型

/**
 * 自定义集合泛型
 *
 * @param <T>
 */
public class SimpleCollection<T>
{
    private T[] objArr;
    
    private int index = 0;

    @SuppressWarnings("unchecked")
    public SimpleCollection()
    {
        //此处不能直接new T[10]。只能new一个Object数组,
        //如果objArr定义的是Object类型，此处不用强制转换，
        //但是取出来的时候需要强制转换为T类型
        this.objArr = (T[])new Object[10];
    }

    @SuppressWarnings("unchecked")
    public SimpleCollection(int capacity)
    {
        this.objArr = (T[])new Object[capacity];
    }
    
    public void add(T t)
    {
        this.objArr[index++] = t;
    }
    
    public T get(int i)
    {
        return this.objArr[i];
    }
    
    
    public static void main(String[] args)
    {
        SimpleCollection<Integer> coll = new SimpleCollection<>();
        
        for(int i = 0; i < 10; i++)
            coll.add(i);
        
        for(int i = 0; i < 10; i++)
        {
            Integer in = coll.get(i);
            System.out.println(in);
        }
    }   
}

5、泛型的泛型

/**
 * 泛型的泛型
 *
 * @param <T>
 */
public class WrapperFoo<T>
{
    private GenericFoo3<T> foo3;

    public GenericFoo3<T> getFoo3()
    {
        return foo3;
    }

    public void setFoo3(GenericFoo3<T> foo3)
    {
        this.foo3 = foo3;
    }

    public static void main(String[] args)
    {
        GenericFoo3<Integer> foo = new GenericFoo3<>();
        foo.setT(-10);
        
        WrapperFoo<Integer> wrapper = new WrapperFoo<>();
        wrapper.setFoo3(foo);
        
        GenericFoo3<Integer> g = wrapper.getFoo3();
        System.out.println(g.getT());
    }
    
}

/**
*一个泛型变量的泛型类
*/
class GenericFoo3<T>
{
    private T t;

    public T getT()
    {
        return t;
    }

    public void setT(T t)
    {
        this.t = t;
    }
    
}

上一篇：自定义TreeMap的比较器
下一篇：泛型高级进阶