程序示例说明Java泛型到底是什么

Java泛型到底什么，在看《数据结构与算法分析》一书时我不禁问自己。其书中介绍甚为抽象，本人就想试着用程序实验一下java泛型。参考了小顾问@cnblogs的关于java泛型的博文。本人的理解Java泛型其实就是参数类型的类型。

泛型基础

/**
 * 
 * @author wqh 
 * 泛型基础
 */
public class GenericDemo1 {
    /**
     * 未使用泛型
     */
    public static void test0() {
        Map m = new HashMap();
        m.put("key", "yes");
        String s = (String) m.get("key");// 类型强制转换
    }

    /**
     * 未使用泛型
     *  没进行型强制转换，无法通过编译
     */
    public static void test1() {
        Map m = new HashMap();
        m.put("key", "yes");
        //String s = m.get("key");// 无类型强制转换，编译无法通过
    }

    /**
     * 未使用泛型
     *  map中保存了Integer类型的对象，运行时抛出 ClassCastException
     */
    public static void test2() {
        Map m = new HashMap();
        m.put("key", new Integer(3));// 值可为任意对象，编译可以通过
        String s = (String) m.get("key");// 类型强制转换
    }

    /**
     * 使用泛型
     * 注意Map的声明，声明时就指定了变量的类型,
     * Map<String, String>类型的对象，Map.put()方法参数类型必须为String,
     * Map.get()方法 将会得到 String 类型.
     * map中保存了Integer类型的对象，编译无法通过
     */
    public static void test3() {
        Map<String, String> m = new HashMap<String, String>();// 使用泛型
        // m.put("key", new Integer(3));//编译无法通过
        String s = m.get("key");// 不需要类型强制转换
    }

    /**
     * 使用泛型
     * 
     */
    public static void test4() {
        Map<String, String> m = new HashMap<String, String>();// 使用泛型
        m.put("key", "yes");// 编译通过
        String s = m.get("key");// 不需要类型强制转换
    }

    public static void main(String[] args) {
        test2();//抛出 ClassCastException

    }
    /**
     * 以上代码可以看出，如果使用泛型
     *  1.保存在Map中值的类型错误时不能编译通过，类型安全
     *  2.在获取值时不需要进行强制类型转换，提高可靠性并加快开发速度
     *  结论：泛型消除代码中的强制类型转换，并且进行类型检查！！！
     */
}

泛型通配符

/**
 * 
 * @author wqh
 *  泛型通配符
 */
public class GenericDemo2 {

    /**
     * 数组是协变的，意思是在可以需要用numberArray的地方使用intArray
     */
    private void test0() {
        Integer[] intArray = new Integer[10]; 
        Number[] numberArray = intArray;
    }
    /**
     * 泛型不是协变的，不可以在需要listObject的地方使用listString
     * String是Object的子类，但是List<String>和List<Object>却没有这种继承关系
     */
    public static void test1(){
        List<Object> listObject = new ArrayList<Object>();
        List<String> listString = new ArrayList<String>();


    }
    /**
     * 如果泛型协变的，就会违背泛型应该提供的类型安全
     * Integer和Float不是同一种类型
     */
    public void test2() {
        List<Integer> intList = new ArrayList<Integer>();
        List<Number> numberList = intList; // 编译不通过，无效代码
        numberList.add(new Float(3.1415));//违背泛型应该提供的类型安全
    }
    /**
     * printList1方法的参数类型只能是List<Object>，调用时传入List<Integer>编译不能通过
     * 
     */
    public void printList1(List<Object> l) { 
        for (Object o : l){
            System.out.println(o); 
        } 
    }

    /**
     * 为了灵活使用泛型，引入类型通配符。
     * printList2方法的参数类型可以是
     *  List<Object>、List<Integer> 或 List<List<List<Object>>> 
     * 
     */

    public void printList2(List<?> l) { 
        for (Object o : l) {
             System.out.println(o); 
        } 
    }
    /** 
     * 类型通配符?的作用
     * 编译器不知道 List的类型参数的值，但是编译器可以推理，
     * 它推断未知的类型参数必须扩展 Object
     * 1.但是编译器不能对 List的类型参数作出足够严密的推理，
     * 以确定将 Integer 传递给 List.add() 是类型安全的
     * 所以lu.add的方法编译不通过
     * 2.不依赖于编译器必须知道关于lu的类型参数的方法
     * 则是可以编译通过的，例如lu.clear()
     */
    public void test4() {
        List<Integer> li = new ArrayList<Integer>();
        li.add(new Integer(3));
        List<?> lu = li;
        System.out.println(lu.get(0));
        lu.add(new Integer(4)); // 编译无法通过
        lu.clear();
    }


}

泛型方法

/**
 * 
 * @author wqh 
 * 泛型方法
 *
 */
public class GenericDemo3 {
    /**
     * 泛型方法是为了想要在该方法的多个参数之间宣称一个类型约束
     * ifThenElse方法不用显式地告诉编译器T是什么值，
     * 编译器可以使用类型推理来推断出
     */
    public <T> T ifThenElse(boolean b, T first, T second) {
        return b ? first : second;
    }
    /**
     * 调用方法ifThenElse
     */
    private void test0() {
        String s1 = 
                ifThenElse(true, "a", "b");
        //编译通过："a","b"是String类型，类型相同

        Integer i = 
                ifThenElse(false, new Integer(1), new Integer(2));
        //编译通过：new Integer(1), new Integer(2)
        //是Integer类型

        String s2 = 
                ifThenElse(false, "pi", new Float(3.14));
        //编译不通过："pi", new Float(3.14)类型不同

    }
    /**
     *  在还没有完全指定类型参数时，需要对类型参数指定附加的约束
     *  类型参数 V 被判断为由 Number限制 。
     * 在没有类型限制时，假设类型参数由 Object限制
     */
    public class Matrix<V extends Number> { }
    /**
     * 允许创建Matrix<Number>、Matrix<Integer>类型的对象，
     * 但是不允许创建Matrix<String>的对象
     */
    private void test1() {
         new Matrix<Number>();//编译通过
         new Matrix<Integer>();//编译通过
         new Matrix<String>();//编译不通过

    }
}

泛型高级

/**
 * 
 * @author wqh
 * 泛型高级
 * 此部分内容本人理解也不是很好，不是很详尽，Selector的东西还需要研究
 */
public class GenericDemo4 {
    /**
     *  Java类库中的泛型
     * 该定义组合了通配符类型参数和有限制类型参数，
     * 允许您将 Collection<Integer> 的内容添加到 Collection<Number>。
     */
    interface Collection<V> {
        boolean addAll(Collection<? extends V> paramCollection);
     }

    /**
     * 二元 max() 方法的实现
     * 使用泛型方法和有限制类型参数
     */

    public static <T extends Comparable<T>> T max(T t1, T t2) {
        if (t1.compareTo(t2) > 0)
            return t1;
        else
            return t2;
    }
    /**
     * 让 T.class是 Class<T> 类型的好处是，通过类型推理，
     * 可以提高使用反射的代码的类型安全
     * 还不需要将 T.class.newInstance()强制类型转换为T
     * 此方法实现从数据库检索一组对象，并返回 JavaBeans 对象的一个集合
     * @throws IllegalAccessException 
     * @throws InstantiationException 

     */
    public static <T> List<T> getRecords(Class<T> c, Selector s) throws 
    InstantiationException, IllegalAccessException {
        // Use Selector to select rows
        List<T> list = new ArrayList<T>();
        for (/* iterate over results */;;) {
            T row = c.newInstance();
            // use reflection to set fields from result
            list.add(row); 
        }
    }
    /**
     * 用 Class<T> 替换 T[]
     * Collection 接口还没有改变为使用该技术，
     * 因为这会破坏许多现有的集合实现
     * 但是如果使用泛型从新构建 Collection，
     * 则当然会使用该方言来指定它想要返回值是哪种类型。
     * 调用：Integer[] integer = new GenericDemo4().toArray(Integer.class);
     * 
     */
    public   <T> T[] toArray(Class<T> returnType) {
        //未实现
        return null;
    }


}

一个简单的泛型类

/**
 * 
 * @author 小顾问@cnblogs
 *
 * @param <V>
 * 一个简单的泛型类，类似于 List，充当一个容器
 * 泛型类最常见的用例是容器类（比如集合框架）
 * 或者值持有者类（比如 WeakReference 或 ThreadLocal）
 */
public class SimpleGenericList<V> {
    private V[] array;
    private int size;

    public SimpleGenericList(int capacity) {
        array = (V[]) new Object[capacity];
        //List构造函数的一种可能的实现
    }

    public void add(V value) {
        if (size == array.length)
            throw new IndexOutOfBoundsException(Integer.toString(size));
        else if (value == null)
            throw new NullPointerException();
        array[size++] = value;
    }

    public void remove(V value) {
        int removalCount = 0;
        for (int i = 0; i < size; i++) {
            if (array[i].equals(value))
                ++removalCount;
            else if (removalCount > 0) {
                array[i - removalCount] = array[i];
                array[i] = null;
            }
        }
        size -= removalCount;
    }

    public int size() {
        return size;
    }

    public V get(int i) {
        if (i >= size)
            throw new IndexOutOfBoundsException(Integer.toString(i));
        return array[i];
    }
}

/**
 * 
 * @author 小顾问@cnblogs
 *  作为从原始集合类型迁移到泛型集合类型的帮助，
 *  集合框架添加了一些新的集合包装器，
 *  以便为一些类型安全 bug 提供早期警告
 */
public class Collections {
    public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type ) { 
        return new CheckedCollection<E>(c, type); 
    }
    //省略了部分Collection<E>中定义的接口的实现
    private static class CheckedCollection<E> implements Collection<E> { 
        private final Collection<E> c; 
        private final Class<E> type;

        CheckedCollection(Collection<E> c, Class<E> type) { 
          this.c = c; 
          this.type = type; 
        }

        public boolean add(E o) { 
          if (!type.isInstance(o)) 
            throw new ClassCastException(); 
          else
            return c.add(o); 
        } 
    } 
}