Java泛型

1、为什么需要泛型

package com.xiya.generic;

import java.util.ArrayList;
import java.util.List;

public class GenericTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("abc");
        list.add(111);//可以通过编译

        for (Object o : list) {
            String value = (String) o;//抛出ClassCastException异常(java.lang.Integer cannot be cast to java.lang.String)
            System.out.println(value);
        }
    }
}

如上，我们向List类型集合中加入了一个String类型的值和一个Integer类型的值（这样是合法的，因为此时list默认的存储类型为Object类型）。

上面的代码会在运行时抛出ClassCastException异常，因为它尝试将一个Integer转换为String java.lang.Integer cannot be cast to java.lang.String。接着，来看一下从java5开始，Collection的用法：

package com.xiya.generic;

import java.util.ArrayList;
import java.util.List;

public class GenericTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        //list.add(111);//不可以通过编译

        for (String s : list) {
            System.out.println(s);//无需任何强制类型转换
        }
    }
}

注意到，List的创建增加了类型参数String，因此只能向List中添加String类型对象，添加其他对象会抛出编译异常；
同样可以注意到，foreach循环不需要再添加任何强制类型转换，也就移除了运行时的ClassCastException异常。
泛型的两个好处：
- 编译时类型检查。
- 避免强制类型转换。

---

2、泛型类与泛型接口

考虑以下场景：您希望开发一个用于在应用中传递对象的容器。但对象类型并不总是相同。因此，需要开发一个能够存储各种类型对象的容器。
鉴于这种情况，要实现此目标，显然最好的办法是开发一个能够存储和检索 Object 类型本身的容器，然后在将该对象用于各种类型时进行类型转换。

package com.xiya.generic;

class ObjectContainer {
    private Object obj;

    /**
     * @return the obj
     */
    public Object getObj() {
        return obj;
    }

    /**
     * @param obj the obj to set
     */
    public void setObj(Object obj) {
        this.obj = obj;
    }
}

public class GenericTest {
    public static void main(String[] args) {
        ObjectContainer objectContainer = new ObjectContainer();
        objectContainer.setObj("Hello World");
        System.out.println(objectContainer.getObj());
    }
}

原始类的定义，容易引发ClassCastException。
现在来看一下泛型类来重新定义ObjectContainer使用<T>指定泛型参数，如下：

package com.xiya.generic;

class ObjectContainer<T> {
    private T obj;

    /**
     * @return the obj
     */
    public T getObj() {
        return obj;
    }

    /**
     * @param obj the obj to set
     */
    public void setObj(T obj) {
        this.obj = obj;
    }
}

public class GenericTest {
    public static void main(String[] args) {
        ObjectContainer<String> objectContainer = new ObjectContainer<>();
        objectContainer.setObj("Hello World");
        //objectContainer.setObj(111);//无法通过编译
        String str = objectContainer.getObj();
        System.out.println(str);
    }
}

接口的泛型应用和类的泛型应用很类似，如下：

public interface List <E> {
     void add(E x);
     Iterator<E> iterator();
}

public interface Iterator<E> {
     E next();
     boolean hasNext();
}

类似的，可以将此应用到自定义的接口与类当中。

---

3、泛型的命名规范

为了更好地去理解泛型，我们也需要去理解java泛型的命名规范。为了与java关键字区别开来，java泛型参数只是使用一个大写字母来定义。各种常用泛型参数的意义如下：
E — Element，常用在java Collection里，如：List< E >,Iterator< E >,Set< E >
K,V — Key，Value，代表Map的键值对
N — Number，数字
T — Type，类型，如String，Integer等等
S,U,V etc. - 2nd, 3rd, 4th 类型，和T的用法一样

---

4、泛型方法

定义泛型方法语法格式如下：

调用泛型方法语法格式如下：

public class GenericTest {
    public static <T> T getObject(Class<T> c) throws IllegalAccessException, InstantiationException {
        return c.newInstance();
    }
    public static void main(String[] args) {
        try {
            Person person = getObject(Person.class);
            person.setName("lgh");
            person.setAge(25);
            System.out.println(person);
        } catch (IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }
    }
}

<T> 和 T的区别？
其实说白了就是先声明后使用，和变量的使用没有本质区别。

---

5、泛型参数的界限

有时候，你会希望泛型类型只能是某一部分类型，比如操作数据的时候，你会希望是Number或其子类类型。这个想法其实就是给泛型参数添加一个界限。其定义形式为：
<T extends BoundingType>
此定义表示T应该是BoundingType的子类型（subtype）。T和BoundingType可以是类，也可以是接口。另外注意的是，此处的extends表示的子类型，不等同于继承。

public class GenericTest {
    public static <T extends Number> void test(List<T> list) {
        System.out.println(list);
    }
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Number> list2 = Arrays.asList(6, 7, 8, 9, 10);
        List<String> list3 = Arrays.asList("111", "222");
        test(list1);
        test(list2);
        //test(list3);//报错
    }
}

此外，泛型只在编译阶段有效。运行时会进行类型擦除。
即List<String> list = new ArrayList<>(); 编译后变成
List list = new ArrayList<>(); 。

package com.xiya.generic;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class GenericTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
//        list.add(333);
        try {
            Method method = list.getClass().getMethod("add", Object.class);
            method.invoke(list, 333);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println(list);
    }
}

参考：
http://peiquan.blog.51cto.com/7518552/1302898
https://www.ziwenxie.site/2017/03/01/java-generic/
http://www.oracle.com/technetwork/cn/articles/java/juneau-generics-2255374-zhs.html
http://www.infoq.com/cn/articles/cf-java-generics
https://www.ibm.com/developerworks/cn/java/j-lo-gj/index.html
http://oldratlee.com/278/tech/java/study-material-of-java-generic.html
http://blog.csdn.net/LonelyRoamer/article/category/1212099