Java泛型

2019-12-31 本文已影响0人安仔夏天勤奋

泛型的定义

Java 泛型（generics）是 JDK1. 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

我们为什么需要泛型？

先看一个需求：计算两个int值之和，两个float值之和,两个double值之和

public class NoGeneric {
    public int addInt(int x, int y) {
        return x + y;
    }
    public float addFloat(float x, float y) {
         return x + y;
    }
    public double addDouble(double x, double y) {
        return x + y;
    }
   
}

我们会发现其实计算两个数之和的逻辑是一样的，只是传入的参数类型不一样而已，那么泛型就是可以用于多种数据类型执行相同的代码。这就是我们要用泛型的原因。

再看一个例子

public class NoGeneric {
    public static void main(String[] args) {
        //定义一个集合    
        List datas = new ArrayList();
        datas.add("Android");
        datas.add("NDK");
        datas.add(100);

        for (int i=0; i<datas.size();i++ ) {
            //当i=2时 这段代码会报类型转化异常。
            String name = (String) datas.get(i);
            System.out.println("name:"+name);
        }
    }
}

List 集合没有强调存放类型，即可为任意类型（Object），当我们遍历时，取出名字并为强转为String类型时，发现Interger转换时就会报类型转换异常了。

在 JDK1.5 之前，集合是没有泛型的，添加的数据都是 Object 类型，因此可以往里面添加任意类型的数据，而在取出数据时，是需要判断类型，然后进行强制转化的，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的，对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现ClassCastException异常，这是本身就是一个安全隐患。

如果我们用了泛型指定了集合的存放类型List<String>，那么集合只能存放指定的类型。如果存放其他类型编译期间直接提示类型错误，而不是到运行时才发现。同时我们在使用时就避免强制转换类型。这就是使用泛型的另一个好处。

泛型的好处

在编译的时候能够检查类型安全，并且所有的强制转换都是自动和隐式的。
可以用于多种数据类型执行相同的代码，提高的运行效率。

泛型的作用

泛化

可以用A~Z任意一个字母代表任意类型。
类型安全

在编译期就能发现类型错误，从而减少运行期可能发生ClassCast Exception异常。
消除强制类型转换

消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。
向后兼容

支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。

泛型在类，接口以及方法的使用

泛型在类，接口以及方法的使用，都在下面代码中体现了。泛型使用 <T> 表示。

public class GenericsType<T> {

    private T t;
    //这个不是泛型方法，虽然该方法使用了泛型，但是这个泛型是在GenericsType中定义的，
    public T get() {
        return t;
    }
    public void set(T t) {
        this.t = t;
    }
    //不指定类型
    public void noSpecifyType(){
        GenericsType obj = new GenericsType();
        obj.set("hello");
        //需要强制类型转换
        String str = (String) obj.get();
        System.out.println(str);
    }

    //指定类型
    public void specifyType(){
        GenericsType<String> obj = new GenericsType<>();
        obj.set("word");
        //obj.set(100);//编译时候检查类型安全，提示类型错误
        //不需要强制类型转换
        String str = obj.get();
        System.out.println(str);
        //可以在编译时候检查类型安全，可以用在类，方法，接口上。
    }

    //泛型接口
    public interface CallBackInterface<Data>{
        void getData(Data data);
    }

    /***
     * 泛型方法 是在调用方法的时候指明泛型的具体类型，泛型方法可以在任何地方和任何场景中使用，包括普通类和泛型类。
     * 上面的get()方法是普通方法，返回的类型由泛型类的泛型决定而已。
     */
    private <K> K getData(K k){
        return k;
    }

}

泛型中通配符

在定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符，比如 T，E，K，V 等等，这些通配符又都是什么意思呢？
常用的 T，E，K，V，？
本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西，没有标准的。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个字母都可以或者使用多个字母组合作通配符也是可以的，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：

？表示不确定的 java 类型
T (type) 表示具体的一个java类型
K V (key value) 分别代表java键值中的Key Value，当然也可以表示java类型
E (element) 代表Element，当然也可以表示java类型

？无界通配符

先看一个计算动物有几条脚的例子：

public class TestGenerics {

    public static void main(String args[]){
        List<Dog> dogs = new ArrayList<>();
        List<Cat> cats = new ArrayList<>();
        TestGenerics test = new TestGenerics();
        test.countLegs1(dogs);//报错提示
        test.countLegs2(dogs);
        test.countLegs2(cats);
    }
    
    private int countLegs1(List<Animals> animals){
        int legs = 0;
        for (Animals animal : animals) {
            legs += animal.getLegs();
        }
        return legs;
    }
    private int countLegs2(List<? extends Animals> animals){
        int legs = 0;
        for (Animals animal : animals) {
            legs += animal.getLegs();
        }
        return legs;
    }
    private class Animals{
        public int getLegs(){
            return 0;
        }
    }
    private class Dog extends Animals{
    }
    private class Cat extends Animals{
    }
}

调用countLegs1(dogs)提示错误了

为什么要使用通配符而不是简单的泛型呢？通配符其实在声明局部变量时是没有什么意义的，但是当你为一个方法声明一个参数时，它是非常重要的。对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?>），表示可以持有任何类型。像 countLegs2 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

上界通配符 < ? extends X>

上界：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

在类型参数中使用 extends 表示这个泛型中的参数必须是 X 或者 E 的子类，这样有两个好处：

如果传入的类型不是 X 或者 X 的子类，编译不成功。
泛型中可以使用 X 的方法，要不然还得强转成X才能使用。

类型参数列表中如果有多个类型参数上限，用逗号分开。


public class A implements Comparable {
        @Override
        public boolean equals(Object obj) {
            return false;
        }
        @Override
        public int compareTo(Object o) {
            return 0;
        }
}
public class B implements Comparable {
        @Override
        public boolean equals(Object obj) {
            return false;
        }
        @Override
        public int compareTo(Object o) {
            return 0;
        }
}

private <K extends A, E extends B> E testCompare(K k1, E e1){
    E result = e1;
    e1.compareTo(k1);
    //.....
    return result;
}

public class GenericsType<T> {

    private T t;
    public T get() {
        return t;
    }
    public void set(T t) {
        this.t = t;
    }
    public GenericsType(T t) {
        this.t = t;
    }
    public GenericsType() {
    }

    public static void main(String []args){
        GenericsType<? extends Dog> obj = null;
        GenericsType<Animals> animal = new GenericsType<>();
        GenericsType<Dog> dog = new GenericsType<>();

        //Dog 是 Animals的子类
        obj = animal;//编译错误
        //<? extends Dog>接受Dog及其Dog子类
        obj = dog;//通过编译

        //set()知道传入的类型是Dog类型，但是具体是什么子类型，还是不清楚的。因此这种方式是不安全的。
        obj.set(new Dog());//编译错误   set方法的参数是一个伪泛型   编译时会被擦除
        obj.set(new BigDog());//编译错误

        //BigDog 是 Dog的子类
        obj = new GenericsType<>(new BigDog());
        Dog dog = obj.get();//通过编译

    }
}

编译不通过的原因：

obj = animal;//编译错误，原因：Dog 是Animals的子类
obj.set(new Dog());//编译错误
obj.set(new BigDog());//编译错误
原因：虽然知道set()传入的参数类型是Dog类或Dog的子类，但是具体是什么子类型，还是不清楚的，可把set方法参数理解一个伪泛型，在编译时会被擦除。因此这种方式是不安全的。

Dog dog = obj.get();//通过编译 为什么返回的是Dog类型？ obj.get()接受的数据一定会是 Dog或者 Dog的子类，但是不管是哪个，都是可以用 Dog这个父类去接受，可理解为Dog是一个占位符（? extends Dog == Dog）这个可以用多态去解释。注意：如果是Dog的子类接收，需要强转

上界：取(get)出来的类型不会丢失，存(set)放会丢失类型。(？代表容器里的元素类型为X基类类型，X是所有元素的基类，存（即set）进去就无法确定是那个具体的类型了，取(get)出来就没有问题，因为X是表示所有基类)

下界通配符 < ? super E>

用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object。

public class GenericType<T> {
    private T t;
    public T getData() {
        return t;
    }
    public void setData(T t) {
        this.t = t;
    }
}

//下界通配符 下界的父类为Dog 是Dog的超类都可以打印
    private static void println(GenericType<? super Dog> p){
        System.out.println(p.getData());
    }

    private static void  useSuper(){
        GenericType<Animal> animalGeneric = new GenericType<>();
        GenericType<Dog> dogGeneric = new GenericType<>();
        GenericType<BigDog> bigDogGeneric = new GenericType<>();
        GenericType<Cat> catGeneric = new GenericType<>();

        println(animalGeneric);
        println(dogGeneric);
//        println(bigDogGeneric);//BigDog是Dog的子类，不是Dog的超类，编译不通过
//        println(catGeneric);//Cat虽然和Dog是一个等级 Cat不是Dog的超类，编译不通过

       GenericType<? super Dog> g = new GenericType<>();
        g.setData(new Dog());
        g.setData(new BigDog());//BigDog是Dog的子类,不能安全转型为Dog
        g.setData(new Animal());//Animal不能安全转型为Dog

    }

    public class Animal {
    }
    public class Dog extends Animal {
    }
    public class BigDog extends Animal {
    }
    public class Cat extends Animal {
    }

上述的BigDog类和Cat类都不是Dog的超类，没有编译报错，反之是Dog本身或Dog的超类都可以打印。GenericType<? super Dog> g = new GenericType<>();setData(T t)方法，输入的t就是Dog类本身，如果传入BigDog类或Animal类时，编译报错，因为不能安全转型为Dog。

下界： 取（get）出来的类型会丢失，存（set）放不会丢失类型。（？代表容器里的元素类型为E基类类型，存（即set）进去的都是E的超类，取（get）出来就不知道是那个具体的类型，这样就没法统一基类类型了，全部都为Object。

泛型类型擦除（面试常问）

前面上界内容提到了Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦除（type erasure）。
Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方法与C++模版机制实现方式之间的重要区别。

下面通过两个例子，看看泛型类型是怎么擦除的。


public class Test {
    public static void main(String[] args) {
        ArrayList<String> arrayList1=new ArrayList<String>();
        arrayList1.add("abcde");
        ArrayList<Integer> arrayList2=new ArrayList<Integer>();
        arrayList2.add(1);
        System.out.println(arrayList1.getClass()==arrayList2.getClass());
    }
}

上述例子中，定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型，只能存储字符串。一个是ArrayList<Integer>泛型类型，只能存储整形。最后，我们通过arrayList1对象和arrayList2对象的getClass方法获取它们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

public class Test{
    public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        ArrayList<Integer> arrayList=new ArrayList<Integer>();
        arrayList.add(1);//调用add方法只能存储整形，因为泛型类型的实例为Integer
        //通过反射向arrayList存一个String值
        arrayList.getClass().getMethod("add", Object.class).invoke(arrayList, "aaaaaaa");
        for (int i=0;i<arrayList.size();i++) {
            System.out.println(arrayList.get(i));
        }
      }
}

上述代码中定义了一个ArrayList泛型类型实例化为Integer的对象，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明了Integer泛型实例在编译之后被擦除了，只保留了原始类型。

总结

重点理解上界和下界的特点和使用
重点理解泛型类型擦除原理

Java泛型

泛型的定义

我们为什么需要泛型？

泛型的好处

泛型的作用

泛型在类，接口以及方法的使用

泛型中通配符

？无界通配符

上界通配符 < ? extends X>

编译不通过的原因：

下界通配符 < ? super E>

泛型类型擦除（面试常问）

总结

猜你喜欢

热点阅读

Java泛型

泛型的定义

我们为什么需要泛型？

泛型的好处

泛型的作用

泛型在类，接口以及方法的使用

泛型中通配符

？无界通配符

上界通配符 < ? extends X>

编译不通过的原因：

下界通配符 < ? super E>

泛型类型擦除 （面试常问）

总结

猜你喜欢

热点阅读

泛型类型擦除（面试常问）