Java 泛型总结（一）：基本用法与类型擦除

时间 2019-11-06

标签 java 总结基本用法类型擦除栏目 Java 繁體版

原文原文链接

简介

Java 在 1.5 引入了泛型机制，泛型本质是参数化类型，也就是说变量的类型是一个参数，在使用时再指定为具体类型。泛型能够用于类、接口、方法，经过使用泛型可使代码更简单、安全。然而 Java 中的泛型使用了类型擦除，因此只是伪泛型。这篇文章对泛型的使用以及存在的问题作个总结，主要参考自《Java 编程思想》。编程

这个系列的另外两篇文章：segmentfault

基本用法

泛型类

若是有一个类 Holder 用于包装一个变量，这个变量的类型多是任意的，怎么编写 Holder 呢？在没有泛型以前能够这样：设计模式

public class Holder1 {
    private Object a;

    public Holder1(Object a) {
        this.a = a;
    }

    public void set(Object a) {
        this.a = a;
    }
    public Object get(){
        return a;
    }

    public static void main(String[] args) {
        Holder1 holder1 = new Holder1("not Generic");
        String s = (String) holder1.get();
        holder1.set(1);
        Integer x = (Integer) holder1.get();
    }

}数组

在 Holder1 中，有一个用 Object 引用的变量。由于任何类型均可以向上转型为 Object，因此这个 Holder 能够接受任何类型。在取出的时候 Holder 只知道它保存的是一个 Object 对象，因此要强制转换为对应的类型。在 main 方法中， holder1 先是保存了一个字符串，也就是 String 对象，接着又变为保存一个 Integer 对象(参数 1 会自动装箱)。从 Holder 中取出变量时强制转换已经比较麻烦，这里还要记住不一样的类型，要是转错了就会出现运行时异常。安全

下面看看 Holder 的泛型版本：ui

public class Holder2<T> {

    private T a;
    public Holder2(T a) {
        this.a = a;
    }

    public T get() {
        return a;
    }

    public void set(T a) {
        this.a = a;
    }

    public static void main(String[] args) {
        Holder2<String> holder2 = new Holder2<>("Generic");
        String s = holder2.get();

        holder2.set("test");
        holder2.set(1);//没法编译   参数 1 不是 String 类型

    }

}this

在 Holder2 中，变量 a 是一个参数化类型 T，T 只是一个标识，用其它字母也是能够的。建立 Holder2 对象的时候，在尖括号中传入了参数 T 的类型，那么在这个对象中，全部出现 T 的地方至关于都用 String 替换了。如今的 get 的取出来的不是 Object ，而是 String 对象，所以不须要类型转换。另外，当调用 set 时，只能传入 String 类型，不然编译没法经过。这就保证了 holder2 中的类型安全，避免因为不当心传入错误的类型。设计

经过上面的例子能够看出泛使得代码更简便、安全。引入泛型以后，Java 库的一些类，好比经常使用的容器类也被改写为支持泛型，咱们使用的时候都会传入参数类型，如：ArrayList<Integer> list = ArrayList<>();。code

泛型方法

泛型不只能够针对类，还能够单独使某个方法是泛型的，举个例子：对象

public class GenericMethod {
    public <K,V> void f(K k,V v) {
        System.out.println(k.getClass().getSimpleName());
        System.out.println(v.getClass().getSimpleName());
    }

    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.f(new Integer(0),new String("generic"));
    }
}

代码输出：
    Integer
    String

GenericMethod 类自己不是泛型的，建立它的对象的时候不须要传入泛型参数，可是它的方法 f 是泛型方法。在返回类型以前是它的参数标识 <K,V>，注意这里有两个泛型参数，因此泛型参数能够有多个。

调用泛型方法时能够不显式传入泛型参数，上面的调用就没有。这是由于编译器会使用参数类型推断，根据传入的实参的类型 (这里是 integer 和 String) 推断出 K 和 V 的类型。

类型擦除

什么是类型擦除

Java 的泛型使用了类型擦除机制，这个引来了很大的争议，以致于 Java 的泛型功能受到限制，只能说是”伪泛型“。什么叫类型擦除呢？简单的说就是，类型参数只存在于编译期，在运行时，Java 的虚拟机 ( JVM ) 并不知道泛型的存在。先看个例子：

public class ErasedTypeEquivalence {
    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2);
    }
}

上面的代码有两个不一样的 ArrayList：ArrayList<Integer> 和 ArrayList<String>。在咱们看来它们的参数化类型不一样，一个保存整性，一个保存字符串。可是经过比较它们的 Class 对象，上面的代码输出是 true。这说明在 JVM 看来它们是同一个类。而在 C++、C# 这些支持真泛型的语言中，它们就是不一样的类。

泛型参数会擦除到它的第一个边界，好比说上面的 Holder2 类，参数类型是一个单独的 T，那么就擦除到 Object,至关于全部出现 T 的地方都用 Object 替换。因此在 JVM 看来，保存的变量 a 仍是 Object 类型。之因此取出来自动就是咱们传入的参数类型，这是由于编译器在编译生成的字节码文件中插入了类型转换的代码，不须要咱们手动转型了。若是参数类型有边界那么就擦除到它的第一个边界，这个下一节再说。

擦除带来的问题

擦除会出现一些问题，下面是一个例子：

class HasF {
    public void f() {
        System.out.println("HasF.f()");
    }
}
public class Manipulator<T> {
    private T obj;

    public Manipulator(T obj) {
        this.obj = obj;
    }

    public void manipulate() {
        obj.f(); //没法编译 找不到符号 f()
    }

    public static void main(String[] args) {
        HasF hasF  = new HasF();
        Manipulator<HasF> manipulator = new Manipulator<>(hasF);
        manipulator.manipulate();

    }

}

上面的 Manipulator 是一个泛型类，内部用一个泛型化的变量 obj，在 manipulate 方法中，调用了 obj 的方法 f()，可是这行代码没法编译。由于类型擦除，编译器不肯定 obj 是否有 f() 方法。解决这个问题的方法是给 T 一个边界:

class Manipulator2<T extends HasF> {
    private T obj;
    public Manipulator2(T x) { obj = x; }
    public void manipulate() { obj.f(); }
}

如今 T 的类型是 <T extends HasF>，这表示 T 必须是 HasF 或者 HasF 的导出类型。这样，调用 f() 方法才安全。HasF 就是 T 的边界，所以经过类型擦除后，全部出现 T 的
地方都用 HasF 替换。这样编译器就知道 obj 是有方法 f() 的。

可是这样就抵消了泛型带来的好处，上面的类彻底能够改为这样：

class Manipulator3 {
    private HasF obj;
    public Manipulator3(HasF x) { obj = x; }
    public void manipulate() { obj.f(); }
}

因此泛型只有在比较复杂的类中才体现出做用。可是像 <T extends HasF> 这种形式的东西不是彻底没有意义的。若是类中有一个返回 T 类型的方法，泛型就有用了，由于这样会返回准确类型。好比下面的例子：

class ReturnGenericType<T extends HasF> {
    private T obj;
    public ReturnGenericType(T x) { obj = x; }
    public T get() { return obj; }
}

这里的 get() 方法返回的是泛型参数的准确类型，而不是 HasF。

类型擦除的补偿

类型擦除致使泛型丧失了一些功能，任何在运行期须要知道确切类型的代码都没法工做。好比下面的例子：

public class Erased<T> {
    private final int SIZE = 100;
    public static void f(Object arg) {
    if(arg instanceof T) {} // Error
    T var = new T(); // Error
    T[] array = new T[SIZE]; // Error
    T[] array = (T)new Object[SIZE]; // Unchecked warning
    }
}

经过 new T() 建立对象是不行的，一是因为类型擦除，二是因为编译器不知道 T 是否有默认的构造器。一种解决的办法是传递一个工厂对象而且经过它建立新的实例。

interface FactoryI<T> {
    T create();
}
class Foo2<T> {
    private T x;
    public <F extends FactoryI<T>> Foo2(F factory) {
    x = factory.create();
    }
    // ...
}
class IntegerFactory implements FactoryI<Integer> {
    public Integer create() {
    return new Integer(0);
    }
}
class Widget {
    public static class Factory implements FactoryI<Widget> {
        public Widget create() {
            return new Widget();
        }
    }
}
public class FactoryConstraint {
    public static void main(String[] args) {
        new Foo2<Integer>(new IntegerFactory());
        new Foo2<Widget>(new Widget.Factory());
    }
}

另外一种解决的方法是利用模板设计模式：

abstract class GenericWithCreate<T> {
    final T element;
    GenericWithCreate() { element = create(); }
    abstract T create();
}
class X {}
class Creator extends GenericWithCreate<X> {
    X create() { return new X(); }
    void f() {
    System.out.println(element.getClass().getSimpleName());
    }
}
public class CreatorGeneric {
    public static void main(String[] args) {
        Creator c = new Creator();
        c.f();
    }
}

具体类型的建立放到了子类继承父类时，在 create 方法中建立实际的类型并返回。

总结

本文介绍了 Java 泛型的使用，以及类型擦除相关的问题。通常状况下泛型的使用比较简单，可是某些状况下，尤为是本身编写使用泛型的类或者方法时要注意类型擦除的问题。接下来会介绍数组与泛型的关系以及通配符的使用，有兴趣的读者可进入下一篇：Java 泛型总结（二）：泛型与数组。

参考

Java 编程思想

若是个人文章对您有帮助，不妨点个赞支持一下(^_^)