Java泛型的使用

package com.mycompany.mavenproject1;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author sunnymoon
 * 2010-10-16 16:07:40
 * 
 * 泛型使用：包括�上界和下界通配符；无界通配符；泛型类；泛型方法；泛型类的具体化�
 */
public class TestGeneral {

    public static void main(String[] args) {
        TestGeneral.test1();
        System.out.println("test1");
        TestGeneral.test2();
        System.out.println("test2");
        TestGeneral.test3();
        System.out.println("test3");
        TestGeneral.test4();
        System.out.println("test4");
        TestGeneral.test5();
        System.out.println("test5");
        TestGeneral.test6();
        System.out.println("test6");
    }

    /**
     * 集合风格(Collection-like)的泛型函数
     */
    public static void test1() {
        Pair<Integer, Boolean> pair1 = new Pair<Integer, Boolean>(123, true);
        System.out.println(pair1.first + "|" + pair1.second);
        Pair<Integer, Long> pair2 = new Pair<Integer, Long>(123, 123l);
        System.out.println(pair2.first + "|" + pair2.second);
    }

    /**
     * 集合之外风格的泛型函数
     */
    public static void test2() {
        DBFactory facotry = new PairDBFactory();
        System.out.println(facotry.createPair().first + "|" + facotry.createPair().second);
    }

    /**
     * 上界和下界通配符
     * A
     * ?
     * ?
     * A
     */
    public static void test3() {
        /**
         * 用面向对象继承的去思考上界只可读，下界只可写更容易
         * 不可指的是不安全，会在编译，运行时报异常
         */
        final ArrayList<Integer> list = new ArrayList<Integer>(1);
        list.add(100);
        final List<? extends Number> readList = list;
//        readList.add(new Integer(2));//不保证可写
        Number n = readList.get(0);
        System.out.println(n);
        List<? super Number> writeList = new ArrayList<Object>();
        writeList.add(new Integer(5));
//        System.out.println(writeList.get(0));//不保证可读
    }

    /**
     * 通配符
     * 无界通配符
     */
    public static void test4() {
        List<?> list = new ArrayList<Integer>();
        list = new ArrayList<Object>();
    }

    /**
     * 关于泛型方法
     */
    public static void test5() {
        PairMethod<Integer> pairMethod = new PairMethod<Integer>();
        pairMethod.pair(new ArrayList<Long>(1));
        pairMethod.pair2(3);
        pairMethod.pair2_1(4);
        pairMethod.pair3(4);
        PairMethod.pair4(123123l);
        PairMethod.pair4_1(pairMethod);
    }

    /**
     * 关于泛型具体化
     * 您可能想要构造一个数组T[]， new T[]是不允许的
     * 解决方案使用的是“类型令牌”
     */
    public static void test6() {
        ArrayExample<Double> example = new ArrayExample<Double>(Double.class);
        Double[] doubles = example.getArray(10);
        System.out.println(doubles.length);
    }
}

/**
 * 以下是测试时创建的类
 */
final class Pair<A, B> {

    public final A first;
    public final B second;

    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
}

abstract class DBFactory<T extends Pair> {

    protected abstract T createPair();

    public List<T> get(String constraint) {
        List<T> pairs = new ArrayList<T>();
        return pairs;
    }
}

final class PairDBFactory extends DBFactory {

    @Override
    protected Pair createPair() {
        return new Pair<Integer, Boolean>(123, false);
    }
}

final class PairMethod<R> {

    /**
     * 开始的<T>为所埯的类型型
     * @param <T>
     * @param list
     * @return
     */
    public <T> List<T> pair(List<T> list) {
        return list;
    }

    /**
     * 同上
     * @param <T>
     * @param obj
     * @return
     */
    public <T> List<T> pair2(T obj) {
        return null;
    }

    public <T> T pair2_1(T obj) {
        return obj;
    }

    /**
     * 打酱油的，实际是泛型类
     * @param obj
     * @return
     */
    public List<R> pair3(R obj) {
        return null;
    }

    /**
     * 静态方法也可
     * @param <T>
     * @param obj
     * @return
     */
    public static <T> List<T> pair4(T obj) {
        return null;
    }

    public static <T> T pair4_1(T obj) {
        return obj;
    }
}

final class ArrayExample<T> {

    private Class<T> clazz;

    public ArrayExample(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T[] getArray(int size) {
        return (T[]) Array.newInstance(clazz, size);
    }
}