Java泛型总结

源出处：尚硅谷：http://www.gulixueyuan.com/my/course/311

一、泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的 对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来 解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于 这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个 参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就 是类型参数，即泛型。

二、泛型的概念

• 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实 际的类型参数，也称为类型实参）。
• 从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念， 允许我们在创建集合时再指定集合元素的类型，正如：List，这表明 该List只能保存字符串类型的对象。
• JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持， 从而可以在声明集合变量、创建集合对象时传入类型实参

三、为什么要有泛型？

1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药 品都要辨别。

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException异常。同时，代码更加简洁、健壮

四、在集合中使用泛型

        ArrayList<Integer> list = new ArrayList<>();//类型推断
        list.add(78);
        list.add(88);
        list.add(77);
        list.add(66);
//遍历方式一：
        for(Integer i : list){
            //不需要强转
            System.out.println(i);
        }
//遍历方式二：
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("Tom1",34);
        map.put("Tom2",44);
        map.put("Tom3",33);
        map.put("Tom4",32); //添加失败
        // map.put(33, "Tom");
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String,Integer>> iterator =  entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry<String,Integer> entry = iterator.next();
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }

五、自定义泛型类

public class Student<T1,T2>{
    private T1 javaScore;
    private T2 oracleScore;
    //泛型声明时不能使用静态属性|静态方法
    //private static T1 test;
    
    public T1 getJavaScore(){
        return javaScore;
    }
    
    public void setJavaScore(T1 javaScore){
        this.javaScore = javaScore;
    }
 
    public T2 getOracleScore() {
	return oracleScore;
	}
 
    public void setOracleScore(T2 oracleScore) {
	this.oracleScore = oracleScore;
    }
 
    
    public static void main(String[] args){
    //使用时指定类型(引用类型)
    Student<String,Integer> stu = new Student<String,Integer> ();
    //1.安全：类型检查
    stu.setJavaScore("优秀");
    //2.省心：类型转换
    int it = stu.getOracleScore();  //自动拆箱
    } 
}

六、泛型方法

• 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
• 换句话说，泛型方法所属的类是不是泛型类都没有关系。
• 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

order.java:

public static <E> List<E> copyFromArrayToList(E[] arr) {

    ArrayList<E> list = new ArrayList<>();

    for (E e : arr) {
        list.add(e);
    }
    return list;
}

GenericTest.java:

    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);
        System.out.println(list);
    }

输出结果：[1, 2, 3, 4]

---

六、泛型在继承上的体现

如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的 类或接口，G<B>并不是G<A>的子类型！
比如：String是Object的子类，但是List<String >并不是List<Object> 的子类

        public void testGenericAndSubClass () {
            Person[] persons = null;
            Man[] mans = null; // 而 Person[] 是 Man[] 的父类. persons = mans;
            Person p = mans[0];
            // 在泛型的集合上
            List<Person> personList = null; 
            List<Man> manList = null;
            //personList = manList;(报错)
        }

七、通配符的使用

1. 使用类型通配符：？
   • 比如：List<?> ，Map<?,?>
   • List<?>是List、List等各种泛型List的父类。
2. 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型 是什么，它包含的都是Object。
3. 写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中 添加对象。
   唯一的例外是null，它是所有类型的成员。

• 将任意元素加入到其中不是类型安全的:

Collection<?> c = new ArrayList<String>(); 
c.add(new Object()); // 编译时错误 

因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集
合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知 道那是什么类型，所以我们无法传任何东西进去。

• 唯一的例外的是null，它是所有类型的成员。
• 另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的 类型，但是我们知道，它总是一个Object。

    public static void main(String[] args) {
        List<?> list = null;
        list = new ArrayList<String>();
        list = new ArrayList<Double>(); // list.add(3);//编译不通过 list.add(null);
        List<String> l1 = new ArrayList<String>();
        List<Integer> l2 = new ArrayList<Integer>();
        l1.add("尚硅谷");
        l2.add(15);
        read(l1);
        read(l2);
    }

    public static void read(List<?> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }

通配符的使用注意点

//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用? 
public static <?> void test(ArrayList<?> list){
...
}

//注意点2：编译错误：不能用在泛型类的声明上 
class GenericTypeClass<?>{
}

//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
 ArrayList<?> list2 = new ArrayList<?>();