关于泛型你要知道的二三事[3]

书接上文，我们继续接演：
上文地址：https://www.jianshu.com/p/4f9b47e44b0e

本文系原创文章，转载请注明出处：
https://www.jianshu.com/p/578b4d3e6cf5

4、注意事项：

确保数据的安全性

我们之前已经写过类似的实例，比如在一个集合中插入数据，通过泛型可以确保数据的安全性。避免我们显示的强转，另一方面，请看一下代码，会有问题吗？

实例代码1

public class Test01 {
    public static void main(String[] args) {
        //create generic type Gen instance and assign
        //generic type of Gen is Integer
        Gen<Integer> g1;
        //it`s use of autoboxing to encapsulate 
        //the value 12 within an Integer Object
        g1 = new Gen<Integer>(12);
        Gen<Integer> g2;
        //there is a problem
        g2 = new Gen<Double>(12.0);
        //create eneric type Gen instance and type of Gen is String
        Gen<String> g3 = new Gen<>("test generic");
        //the compile-time error
        //Type mismatch: cannot convert from Gen<String> to Gen<Integer>
        g1 = g3;
    }
}
//declared a generic type Gen
class Gen<T>{
    T t;
    public Gen(T t) {
        this.t = t;
    }
    public void getT(){
        System.out.println(t.getClass().getName());
    }

以上代码编译会出错，当然这中类型检查其实也是泛型的优点之一，可以确保类型安全，当然从jdk1.7之后创建实例时可以通过类型推断直接将对象的类型推断出来，不需要在后面继续添加泛型类型了，因为两个尖括号放在一起很像一个菱形，所以也叫菱形语法。而且1.8之后对于泛型的类型推断有进一步增强了。其次到最后的g3赋值给g1时，虽然类型都是Gen对象，但是泛型的具体类型不同，所以是无法正常赋值的。

实例代码2(相同的代码不加入泛型)

public class Test01 {
    public static void main(String[] args) {
        //create non-generic type NonGen instance
        //it`s use of autoboxing to encapsulate 
        //the value 12 within an Integer Object
        NonGen ng1 = new NonGen(12);
        //show the type of data used by ng1
        ng1.show();
        //get the value of ng1，a case is necessary
        Integer in = (Integer) ng1.get();
        System.out.println(in);
        //create other NonGen instance and store a string in it;
        NonGen ng2 = new NonGen("test non-generic");
        //show the type of data used by ng2
        ng2.show();
        //get the value of ng2 again and case is necessary
        String str = (String) ng2.get();
        System.out.println(str);
        //the compile-time is right and No syntax errors 
        //but there are semantic issues 
        ng1 = ng2;
        in = (Integer) ng1.get();// run-time exception java.lang.ClassCastException:
        System.out.println(in);
    }
    
}
//declared a non-generic type Gen
class NonGen{
    Object obj;//use object replace generic
    public NonGen(Object obj) {
        this.obj = obj;
    }
    public void show(){
        System.out.println(obj.getClass().getName());
    }
    public Object get(){
        return obj;
    }
}

如果不加入泛型，这里我们要做大量的类型转换。并且到最后我们看到的这个代码，因为都是NonGen的实例对象，所以它们之间是可以互相赋值的。虽然在语法层面讲没有问题，但是语义上是有问题的，因为下面通过get方法获取且强转时，因为本身ng2存储的是字符串对象，而这里赋值给了ng2对象变量，再通过get()方法获取时，获取到的还是String对象，强转为Integer报错。所以泛型可以保证数据数据的安全性，将运行时异常变成了编译时错误

泛型中不能使用基本数据类型

请看下面代码：

public static void main(String[] args) {
        //Syntax error, insert "Dimensions" to complete ReferenceType
        List<int> ls = new ArrayList<>();
        ls.add(123.123);
        
    }

这里编译出错，不能这样写。需要插如的是一个引用类型。很多人回想那我需要插如一个int数据怎么办呢？其实通过包装类就可以完成。而且包装类在某些时候确实要更加方便，当然包装类和基本数据类型的内容要展开说，还是有很多坑，我们下次再填补。

不同类型的泛型对象不能互相转换

我们在泛型确保安全性上面已经阐述过，这里在简单强调一下：

//the compile-time error
//Type mismatch: cannot convert from Gen<String> to Gen<Integer>
g1 = g3;

统一类型(比如都是Gen泛型类的对象)不同的泛型类型(g1是泛型类型是String，g2是Integer类型)不是兼容类型，这点一定要注意。

结论：泛型能够确保类型安全，其实用一句话简单概括就是：只要通过使用泛型不存在编译时的警告，那么就不会出现运行时的ClassCastException;【注意编译都不出警告。报错更不会了，这个很好理解吧】

反射对于泛型的影响：

测试用例：

public static void main(String[] args) throws Exception{
        List<String> ls = new ArrayList<>();
        //compile-time error not applicable for the arguments (Integer)
        ls.add(new Integer(12));
        //Gets the Class object filler value 
        Class clz = ls.getClass();
        Method m = clz.getMethod("add",Object.class);
        m.invoke(ls, new Integer(12));
        //out 12 in this list
        System.out.println(ls);
    }

通过反射可以在运行期间填充泛型没有指定的类型数据。因为泛型其实是一个编译器行为，而反射是运行期行为。所以我们通过反射可以在运行期间动态的往集合中填充泛型未指定的数据类型。但是如果直接填充Integer对象，在编译器就会报错。

类型通配符：

测试用例：编写一个方法用来遍历当前集合中的元素：

public static void main(String[] args) throws Exception{
        List<String> ls = new ArrayList<>();
        showAll(ls);
    }
    
    public static void showAll(List ls){
        for(int i = 0;i<ls.size();i++){
            System.out.println(ls.get(i));
        }
    }

这个方法本质上没有问题，但是注意这个方法在编译时会出警告，需要指定showAll方法中的参数化类型，其实就是指定List局部变量的泛型类型。改进一版如下：
测试用例1：

public static void main(String[] args) throws Exception{
        List<String> ls = new ArrayList<>();
        //compile-time error
        showAll(ls);
    }
    
    public static void showAll(List<Object>ls){
        for(int i = 0;i<ls.size();i++){
            System.out.println(ls.get(i));
        }
    }

这个结论我们在上面已经说过了，那这个时候如何解决呢？

测试用例2

public static void main(String[] args) throws Exception{
        List<String> ls = new ArrayList<>();
        //compile-time error
        showAll(ls);
    }
    
    public static void showAll(List<?>ls){
        for(int i = 0;i<ls.size();i++){
            System.out.println(ls.get(i));
        }
    }

结论：我们将?称之为通配符，占位符。注意最后经过类型擦除以后，我们也可以说?是Object，但是注意，我们这里其实将List<?>理解为所有List泛型的父类其实更好明白一点。但是这里还是有问题的，我们在showAll方法做操作：

测试用例3

image

这个例子特别有意思：
1、虽然我们说通过<?>带通配符的方式可以传入任何List对象，不论具体的泛型类型是什么，但是在编译阶段也就导致，List<?> ls也无法确定集合中的具体的类型是什么，因为我们查看List中的源码，public boolean add(E e) {}，这里必须传入一个E类型的子类或者时候E类型，但是?是无法确定，所以无法传入。所以你也无法传入一个Object对象。
2、但是我们可以传入null值，因为它是所有引用类型的实例。
3、那为什么我们调用get()方法可以？我们查看get方法的源码public E get(int index) {}；我们发现这个返回的时一个E类型，未知类型，那么肯定是一个Obejct，我们输出会自动调用该方法的toString,所以没有问题，我们甚至可以获取到之后赋值给一个Object类型的变量，也没有问题，但是如果要赋值给一个其他类型，要小心了，因为不可避免的可能会出现类型转换异常。