泛型擦除_java泛型擦除 - CSDN
精华内容
参与话题
  • java--深入理解泛型和类型擦除

    千次阅读 2018-07-10 14:29:37
    泛型,一个孤独的守门者。大家可能会有疑问,我为什么叫做泛型是一个守门者。这其实是我个人的看法而已,我的意思是说泛型没有其看起来那么深不可测,它并不神秘与神奇。泛型是 Java 中一个很小巧的概念,但同时也是...

    泛型,一个孤独的守门者。

    大家可能会有疑问,我为什么叫做泛型是一个守门者。这其实是我个人的看法而已,我的意思是说泛型没有其看起来那么深不可测,它并不神秘与神奇。泛型是 Java 中一个很小巧的概念,但同时也是一个很容易让人迷惑的知识点,它让人迷惑的地方在于它的许多表现有点违反直觉。

    文章开始的地方,先给大家奉上一道经典的测试题。

    List<String> l1 = new ArrayList<String>();
    List<Integer> l2 = new ArrayList<Integer>();

    System.out.println(l1.getClass() == l2.getClass());


    请问,上面代码最终结果输出的是什么?不了解泛型的和很熟悉泛型的同学应该能够答出来,而对泛型有所了解,但是了解不深入的同学可能会答错。

    正确答案是 true。

    上面的代码中涉及到了泛型,而输出的结果缘由是类型擦除。先好好说说泛型。

    泛型是什么?

    泛型的英文是 generics,generic 的意思是通用,而翻译成中文,泛应该意为广泛,型是类型。所以泛型就是能广泛适用的类型。

    但泛型还有一种较为准确的说法就是为了参数化类型,或者说可以将类型当作参数传递给一个类或者是方法。

    那么,如何解释类型参数化呢?

    public class Cache {
       Object value;

       public Object getValue({
           return value;
       }

       public void setValue(Object value{
           this.value = value;
       }

    }


    假设 Cache 能够存取任何类型的值,于是,我们可以这样使用它。

    Cache cache = new Cache();
    cache.setValue(134);
    int value = (int) cache.getValue();
    cache.setValue("hello");
    String value1 = (String) cache.getValue();


    使用的方法也很简单,只要我们做正确的强制转换就好了。

    但是,泛型却给我们带来了不一样的编程体验。

    public class Cache<T> {
       T value;

       public Object getValue() {
           return value;
       }

       public void setValue(T value) {
           this.value = value;
       }

    }


    这就是泛型,它将 value 这个属性的类型也参数化了,这就是所谓的参数化类型。再看它的使用方法。

    Cache<String> cache1 = new Cache<String>();
    cache1.setValue("123");
    String value2 = cache1.getValue();

    Cache<Integer> cache2 = new Cache<Integer>();
    cache2.setValue(456);
    int value3 = cache2.getValue();


    最显而易见的好处就是它不再需要对取出来的结果进行强制转换了。但,还有另外一点不同。 



    泛型除了可以将类型参数化外,而参数一旦确定好,如果类似不匹配,编译器就不通过。 
    上面代码显示,无法将一个 String 对象设置到 cache2 中,因为泛型让它只接受 Integer 的类型。

    所以,综合上面信息,我们可以得到下面的结论。

    1. 与普通的 Object 代替一切类型这样简单粗暴而言,泛型使得数据的类别可以像参数一样由外部传递进来。它提供了一种扩展能力。它更符合面向抽象开发的软件编程宗旨。

    2. 当具体的类型确定后,泛型又提供了一种类型检测的机制,只有相匹配的数据才能正常的赋值,否则编译器就不通过。所以说,它是一种类型安全检测机制,一定程度上提高了软件的安全性防止出现低级的失误。

    3. 泛型提高了程序代码的可读性,不必要等到运行的时候才去强制转换,在定义或者实例化阶段,因为 Cache<String> 这个类型显化的效果,程序员能够一目了然猜测出代码要操作的数据类型。


    下面的文章,我们正常介绍泛型的相关知识。

    泛型的定义和使用

    泛型按照使用情况可以分为 3 种。 
    1. 泛型类。 
    2. 泛型方法。 
    3. 泛型接口。

    泛型类

    我们可以这样定义一个泛型类。

    public class Test<T> {
       T field1;
    }


    尖括号 <> 中的 T 被称作是类型参数,用于指代任何类型。事实上,T 只是一种习惯性写法,如果你愿意。你可以这样写。

    public class Test<Hello> {
       Hello field1;
    }


    但出于规范的目的,Java 还是建议我们用单个大写字母来代表类型参数。常见的如: 
    1. T 代表一般的任何类。 
    2. E 代表 Element 的意思,或者 Exception 异常的意思。 
    3. K 代表 Key 的意思。 
    4. V 代表 Value 的意思,通常与 K 一起配合使用。 
    5. S 代表 Subtype 的意思,文章后面部分会讲解示意。

    如果一个类被 <T> 的形式定义,那么它就被称为是泛型类。

    那么对于泛型类怎么样使用呢?

    Test<String> test1 = new Test<>();
    Test<Integer> test2 = new Test<>();


    只要在对泛型类创建实例的时候,在尖括号中赋值相应的类型便是。T 就会被替换成对应的类型,如 String 或者是 Integer。你可以相像一下,当一个泛型类被创建时,内部自动扩展成下面的代码。


    public class Test<String> {
       String field1;
    }


    当然,泛型类不至接受一个类型参数,它还可以这样接受多个类型参数。

    public class MultiType <E,T>{
       E value1;
       T value2;

       public E getValue1(){
           return value1;
       }

       public T getValue2(){
           return value2;
       }
    }


    泛型方法

    public class Test1 {

       public <T> void testMethod(T t){

       }
    }


    泛型方法与泛型类稍有不同的地方是,类型参数也就是尖括号那一部分是写在返回值前面的。<T> 中的 T 被称为类型参数,而方法中的 T 被称为参数化类型,它不是运行时真正的参数。

    当然,声明的类型参数,其实也是可以当作返回值的类型的。

    public  <T> testMethod1(T t){
           return null;
    }


    泛型类与泛型方法的共存现象

    public class Test1<T>{

       public  void testMethod(T t){
           System.out.println(t.getClass().getName());
       }
       public  <T> testMethod1(T t){
           return t;
       }
    }


    上面代码中,Test1<T> 是泛型类,testMethod 是泛型类中的普通方法,而 testMethod1 是一个泛型方法。而泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的,泛型方法始终以自己定义的类型参数为准

    所以,针对上面的代码,我们可以这样编写测试代码。

    Test1<String> t = new Test1();
    t.testMethod("generic");
    Integer i = t.testMethod1(new Integer(1));


    泛型类的实际类型参数是 String,而传递给泛型方法的类型参数是 Integer,两者不想干。

    但是,为了避免混淆,如果在一个泛型类中存在泛型方法,那么两者的类型参数最好不要同名。比如,Test1<T> 代码可以更改为这样

    public class Test1<T>{

       public  void testMethod(T t){
           System.out.println(t.getClass().getName());
       }
       public  <E> testMethod1(E e){
           return e;
       }
    }


    泛型接口

    泛型接口和泛型类差不多,所以一笔带过。

    public interface Iterable<T{
    }


    通配符 ?

    除了用 <T> 表示泛型外,还有 <?> 这种形式。 被称为通配符。

    可能有同学会想,已经有了 <T> 的形式了,为什么还要引进 <?> 这样的概念呢?

    class Base{}

    class Sub extends Base{}

    Sub sub = new Sub();
    Base base = sub;


    上面代码显示,Base 是 Sub 的父类,它们之间是继承关系,所以 Sub 的实例可以给一个 Base 引用赋值,那么

    List<Sub> lsub = new ArrayList<>();
    List<Base> lbase = lsub;


    最后一行代码成立吗?编译会通过吗?

    答案是否定的。

    编译器不会让它通过的。Sub 是 Base 的子类,不代表 List<Sub> 和 List<Base> 有继承关系。

    但是,在现实编码中,确实有这样的需求,希望泛型能够处理某一范围内的数据类型,比如某个类和它的子类,对此 Java 引入了通配符这个概念。

    所以,通配符的出现是为了指定泛型中的类型范围

    通配符有 3 种形式。

    1. <?> 被称作无限定的通配符。

    2. <? extends T> 被称作有上限的通配符。

    3. <? super T> 被称作有下限的通配符。


    无限定通配符

    public void testWildCards(Collection<?> collection){
    }


    上面的代码中,方法内的参数是被无限定通配符修饰的 Collection 对象,它隐略地表达了一个意图或者可以说是限定,那就是 testWidlCards() 这个方法内部无需关注 Collection 中的真实类型,因为它是未知的。所以,你只能调用 Collection 中与类型无关的方法。

    我们可以看到,当 <?> 存在时,Collection 对象丧失了 add() 方法的功能,编译器不通过。 
    我们再看代码。

    List<?> wildlist = new ArrayList<String>();
    wildlist.add(123);// 编译不通过


    有人说,<?> 提供了只读的功能,也就是它删减了增加具体类型元素的能力,只保留与具体类型无关的功能。它不管装载在这个容器内的元素是什么类型,它只关心元素的数量、容器是否为空?我想这种需求还是很常见的吧。

    有同学可能会想,<?> 既然作用这么渺小,那么为什么还要引用它呢?

    个人认为,提高了代码的可读性,程序员看到这段代码时,就能够迅速对此建立极简洁的印象,能够快速推断源码作者的意图。

    <? extends T>

    <?> 代表着类型未知,但是我们的确需要对于类型的描述再精确一点,我们希望在一个范围内确定类别,比如类型 A 及 类型 A 的子类都可以。

    public void testSub(Collection<? extends Base> para){

    }


    上面代码中,para 这个 Collection 接受 Base 及 Base 的子类的类型。

    但是,它仍然丧失了写操作的能力。也就是说

    para.add(new Sub());
    para.add(new Base());


    仍然编译不通过。

    没有关系,我们不知道具体类型,但是我们至少清楚了类型的范围。

    <? super T>

    这个和 <? extends T> 相对应,代表 T 及 T 的超类。

    public void testSuper(Collection<? super Sub> para){
    }


    <? super T> 神奇的地方在于,它拥有一定程度的写操作的能力。

    public void testSuper(Collection<? super Sub> para){
       para.add(new Sub());//编译通过
       para.add(new Base());//编译不通过
    }


    通配符与类型参数的区别

    一般而言,通配符能干的事情都可以用类型参数替换。 
    比如

    public void testWildCards(Collection<?> collection){}


    可以被

    public <T> void test(Collection<T> collection){}


    取代。

    值得注意的是,如果用泛型方法来取代通配符,那么上面代码中 collection 是能够进行写操作的。只不过要进行强制转换。

    public <T> void test(Collection<T> collection){
       collection.add((T)new Integer(12));
       collection.add((T)"123");
    }


    需要特别注意的是,类型参数适用于参数之间的类别依赖关系,举例说明。

    public class Test2 <T,E extends T>{
       T value1;
       E value2;
    }


    public <D,S extends D> void test(D d,S s){

       }


    E 类型是 T 类型的子类,显然这种情况类型参数更适合。 
    有一种情况是,通配符和类型参数一起使用。

    public <T> void test(T t,Collection<? extends T> collection){

    }


    如果一个方法的返回类型依赖于参数的类型,那么通配符也无能为力。

    public T test1(T t){
       return value1;
    }


    类型擦除

    泛型是 Java 1.5 版本才引进的概念,在这之前是没有泛型的概念的,但显然,泛型代码能够很好地和之前版本的代码很好地兼容。

    这是因为,泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,专业术语叫做类型擦除

    通俗地讲,泛型类和普通类在 java 虚拟机内是没有什么特别的地方。回顾文章开始时的那段代码

    List<String> l1 = new ArrayList<String>();
    List<Integer> l2 = new ArrayList<Integer>();

    System.out.println(l1.getClass() == l2.getClass());


    打印的结果为 true 是因为 List<String> 和 List<Integer> 在 jvm 中的 Class 都是 List.class。

    泛型信息被擦除了。

    可能同学会问,那么类型 String 和 Integer 怎么办?

    答案是泛型转译。

    public class Erasure <T>{
       T object;

       public Erasure(T object) {
           this.object = object;
       }

    }


    Erasure 是一个泛型类,我们查看它在运行时的状态信息可以通过反射。

    Erasure<String> erasure = new Erasure<String>("hello");
    Class eclz = erasure.getClass();
    System.out.println("erasure class is:"+eclz.getName());


    打印的结果是

    erasure class is:com.frank.test.Erasure


    Class 的类型仍然是 Erasure 并不是 Erasure<T> 这种形式,那我们再看看泛型类中 T 的类型在 jvm 中是什么具体类型。

    Field[] fs = eclz.getDeclaredFields();
    for ( Field f:fs) {
       System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
    }


    打印结果是

    Field name object type:java.lang.Object


    那我们可不可以说,泛型类被类型擦除后,相应的类型就被替换成 Object 类型呢?

    这种说法,不完全正确。

    我们更改一下代码。

    public class Erasure <T extends String>{
    //  public class Erasure <T>{
       T object;

       public Erasure(T object) {
           this.object = object;
       }

    }


    现在再看测试结果:

    Field name object type:java.lang.String


    我们现在可以下结论了,在泛型类被类型擦除的时候,之前泛型类中的类型参数部分如果没有指定上限,如 <T> 则会被转译成普通的 Object 类型,如果指定了上限如 <T extends String> 则类型参数就被替换成类型上限。

    所以,在反射中。

    public class Erasure <T>{
       T object;

       public Erasure(T object) {
           this.object = object;
       }

       public void add(T object){

       }

    }


    add() 这个方法对应的 Method 的签名应该是 Object.class。

    Erasure<String> erasure = new Erasure<String>("hello");
    Class eclz = erasure.getClass();
    System.out.println("erasure class is:"+eclz.getName());

    Method[] methods = eclz.getDeclaredMethods();
    for ( Method m:methods ){
       System.out.println(" method:"+m.toString());
    }


    打印结果是

    method:public void com.frank.test.Erasure.add(java.lang.Object)


    也就是说,如果你要在反射中找到 add 对应的 Method,你应该调用 getDeclaredMethod("add",Object.class) 否则程序会报错,提示没有这么一个方法,原因就是类型擦除的时候,T 被替换成 Object 类型了。

    类型擦除带来的局限性

    类型擦除,是泛型能够与之前的 java 版本代码兼容共存的原因。但也因为类型擦除,它会抹掉很多继承相关的特性,这是它带来的局限性。

    理解类型擦除有利于我们绕过开发当中可能遇到的雷区,同样理解类型擦除也能让我们绕过泛型本身的一些限制。比如

    正常情况下,因为泛型的限制,编译器不让最后一行代码编译通过,因为类似不匹配,但是,基于对类型擦除的了解,利用反射,我们可以绕过这个限制。

    public interface List<Eextends Collection<E>{

        boolean add(E e);
    }


    上面是 List 和其中的 add() 方法的源码定义。

    因为 E 代表任意的类型,所以类型擦除时,add 方法其实等同于

    boolean add(Object obj);


    那么,利用反射,我们绕过编译器去调用 add 方法。

    public class ToolTest {


       public static void main(String[] args{
           List<Integer> ls = new ArrayList<>();
           ls.add(23);
    //      ls.add("text");
           try {
               Method method = ls.getClass().getDeclaredMethod("add",Object.class);


               method.invoke(ls,"test");
               method.invoke(ls,42.9f);
           } catch (NoSuchMethodException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           } catch (SecurityException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           } catch (IllegalAccessException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           } catch (IllegalArgumentException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           } catch (InvocationTargetException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }

           for ( Object o: ls){
               System.out.println(o);
           }

       }

    }


    打印结果是:

    23
    test
    42.9


    可以看到,利用类型擦除的原理,用反射的手段就绕过了正常开发中编译器不允许的操作限制。

    泛型中值得注意的地方

    泛型类或者泛型方法中,不接受 8 种基本数据类型。

    所以,你没有办法进行这样的编码。

    List<int> li = new ArrayList<>();
    List<boolean> li = new ArrayList<>();


    需要使用它们对应的包装类。

    List<Integer> li = new ArrayList<>();
    List<Boolean> li1 = new ArrayList<>();


    对泛型方法的困惑

    public <T> test(T t){
       return null;
    }


    有的同学可能对于连续的两个 T 感到困惑,其实 <T> 是为了说明类型参数,是声明,而后面的不带尖括号的 T 是方法的返回值类型。 
    你可以相像一下,如果 test() 这样被调用

    test("123");


    那么实际上相当于

    public String test(String t);


    Java 不能创建具体类型的泛型数组

    这句话可能难以理解,代码说明。

    List<Integer>[] li2 = new ArrayList<Integer>[];
    List<Boolean> li3 = new ArrayList<Boolean>[];


    这两行代码是无法在编译器中编译通过的。原因还是类型擦除带来的影响。

    List<Integer> 和 List<Boolean> 在 jvm 中等同于List<Object> ,所有的类型信息都被擦除,程序也无法分辨一个数组中的元素类型具体是 List<Integer>类型还是 List<Boolean> 类型。

    但是,

    List<?>[] li3 = new ArrayList<?>[10];
    li3[1] = new ArrayList<String>();
    List<?> v = li3[1];


    借助于无限定通配符却可以,前面讲过  代表未知类型,所以它涉及的操作都基本上与类型无关,因此 jvm 不需要针对它对类型作判断,因此它能编译通过,但是,只提供了数组中的元素因为通配符原因,它只能读,不能写。比如,上面的 v 这个局部变量,它只能进行 get() 操作,不能进行 add() 操作,这个在前面通配符的内容小节中已经讲过。

    泛型,并不神奇

    我们可以看到,泛型其实并没有什么神奇的地方,泛型代码能做的非泛型代码也能做。

    而类型擦除,是泛型能够与之前的 java 版本代码兼容共存的原因。

    可量也正因为类型擦除导致了一些隐患与局限。

    但,我还是要建议大家使用泛型,如官方文档所说的,如果可以使用泛型的地方,尽量使用泛型。

    毕竟它抽离了数据类型与代码逻辑,本意是提高程序代码的简洁性和可读性,并提供可能的编译时类型转换安全检测功能。

    类型擦除不是泛型的全部,但是它却能很好地检测我们对于泛型这个概念的理解程度。

    我在文章开头将泛型比作是一个守门人,原因就是他本意是好的,守护我们的代码安全,然后在门牌上写着出入的各项规定,及“xxx 禁止出入”的提醒。但是同我们日常所遇到的那些门卫一般,他们古怪偏执,死板守旧,我们可以利用反射基于类型擦除的认识,来绕过泛型中某些限制,现实生活中,也总会有调皮捣蛋者能够基于对门卫们生活作息的规律,选择性地绕开他们的监视,另辟蹊径溜进或者溜出大门,然后扬长而去,剩下守卫者一个孤独的身影。

    所以,我说泛型,并不神秘,也不神奇

    展开全文
  • java 泛型擦除

    千次阅读 2018-09-20 22:07:32
    一、Java泛型的实现方法:类型擦除 前面已经说了,Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢?因为,在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)...

    说明:

    本博客是转载,原博客地址https://blog.csdn.net/lonelyroamer/article/details/7868820#

    一、Java泛型的实现方法:类型擦除

    前面已经说了,Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢?因为,在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)。

    Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会在编译器在编译的时候去掉。这个过程就称为类型擦除。

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

    可以通过两个简单的例子,来证明java泛型的类型擦除。

    例1、

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

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

    例2、

    
    public class Test4 {  
        public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {  
            ArrayList<Integer> arrayList3=new ArrayList<Integer>();  
            arrayList3.add(1);//这样调用add方法只能存储整形,因为泛型类型的实例为Integer  
            arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");  
            for (int i=0;i<arrayList3.size();i++) {  
                System.out.println(arrayList3.get(i));  
            }  
        }  

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

    二、类型擦除后保留的原始类型

    在上面,两次提到了原始类型,什么是原始类型?原始类型(raw type)就是擦除去了泛型信息,最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型,相应的原始类型都会被自动地提供。类型变量被擦除(crased),并使用其限定类型(无限定的变量用Object)替换。

    例3:Pair<T>的原始类型为:

    class Pair {  
        private Object value;  
        public Object getValue() {  
            return value;  
        }  
        public void setValue(Object  value) {  
            this.value = value;  
        }  
    }  

    因为在Pair<T>中,T是一个无限定的类型变量,所以用Object替换。其结果就是一个普通的类,如同泛型加入java变成语言之前已经实现的那样。在程序中可以包含不同类型的Pair,如Pair<String>或Pair<Integer>,但是,擦除类型后它们就成为原始的Pair类型了,原始类型都是Object。

    从上面的那个例2中,我们也可以明白ArrayList<Integer>被擦除类型后,原始类型也变成了Object,所以通过反射我们就可以存储字符串了。

    如果类型变量有限定,那么原始类型就用第一个边界的类型变量来替换。

    比如Pair这样声明

    例4

     

    public class Pair<T extends Comparable& Serializable> {  
    }

    那么原始类型就是Comparable

    注意:

    如果Pair这样声明public class Pair<T extends Serializable&Comparable> ,那么原始类型就用Serializable替换,而编译器在必要的时要向Comparable插入强制类型转换。为了提高效率,应该将标签(tagging)接口(即没有方法的接口)放在边界限定列表的末尾。

    要区分原始类型和泛型变量的类型

    在调用泛型方法的时候,可以指定泛型,也可以不指定泛型。

    在不指定泛型的情况下,泛型变量的类型为 该方法中的几种类型的同一个父类的最小级,直到Object。

    在指定泛型的时候,该方法中的几种类型必须是该泛型实例类型或者其子类。

    public class Test2{  
        public static void main(String[] args) {  
            /**不指定泛型的时候*/  
            int i=Test2.add(1, 2); //这两个参数都是Integer,所以T为Integer类型  
            Number f=Test2.add(1, 1.2);//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Number  
            Object o=Test2.add(1, "asd");//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Object  
      
                    /**指定泛型的时候*/  
            int a=Test2.<Integer>add(1, 2);//指定了Integer,所以只能为Integer类型或者其子类  
            int b=Test2.<Integer>add(1, 2.2);//编译错误,指定了Integer,不能为Float  
            Number c=Test2.<Number>add(1, 2.2); //指定为Number,所以可以为Integer和Float  
        }  
          
        //这是一个简单的泛型方法  
        public static <T> T add(T x,T y){  
            return y;  
        }  
    }  
    


    其实在泛型类中,不指定泛型的时候,也差不多,只不过这个时候的泛型类型为Object,就比如ArrayList中,如果不指定泛型,那么这个ArrayList中可以放任意类型的对象。

    举例:

    public static void main(String[] args) {  
            ArrayList arrayList=new ArrayList();  
            arrayList.add(1);  
            arrayList.add("121");  
            arrayList.add(new Date());  
        }  
    

     

    三、类型擦除引起的问题及解决方法

    因为种种原因,Java不能实现真正的泛型,只能使用类型擦除来实现伪泛型,这样虽然不会有类型膨胀的问题,但是也引起了许多新的问题。所以,Sun对这些问题作出了许多限制,避免我们犯各种错误。

    1、先检查,在编译,以及检查编译的对象和引用传递的问题

    既然说类型变量会在编译的时候擦除掉,那为什么我们往ArrayList<String> arrayList=new ArrayList<String>();所创建的数组列表arrayList中,不能使用add方法添加整形呢?不是说泛型变量Integer会在编译时候擦除变为原始类型Object吗,为什么不能存别的类型呢?既然类型擦除了,如何保证我们只能使用泛型变量限定的类型呢?

    java是如何解决这个问题的呢?java编译器是通过先检查代码中泛型的类型,然后再进行类型擦除,在进行编译的。

    举个例子说明:

    public static  void main(String[] args) {  
            ArrayList<String> arrayList=new ArrayList<String>();  
            arrayList.add("123");  
            arrayList.add(123);//编译错误  
        }  

    在上面的程序中,使用add方法添加一个整形,在eclipse中,直接就会报错,说明这就是在编译之前的检查。因为如果是在编译之后检查,类型擦除后,原始类型为Object,是应该运行任意引用类型的添加的。可实际上却不是这样,这恰恰说明了关于泛型变量的使用,是会在编译之前检查的。

    那么,这么类型检查是针对谁的呢?我们先看看参数化类型与原始类型的兼容

    以ArrayList举例子,以前的写法:

    ArrayList arrayList=new ArrayList();  

    现在的写法:

    ArrayList<String>  arrayList=new ArrayList<String>();  


    如果是与以前的代码兼容,各种引用传值之间,必然会出现如下的情况:

    ArrayList<String> arrayList1=new ArrayList(); //第一种 情况  

     

    ArrayList arrayList2=new ArrayList<String>();//第二种 情况  


    这样是没有错误的,不过会有个编译时警告。

    不过在第一种情况,可以实现与 完全使用泛型参数一样的效果,第二种则完全没效果。

    因为,本来类型检查就是编译时完成的。new ArrayList()只是在内存中开辟一个存储空间,可以存储任何的类型对象。而真正涉及类型检查的是它的引用,因为我们是使用它引用arrayList1 来调用它的方法,比如说调用add()方法。所以arrayList1引用能完成泛型类型的检查。

    而引用arrayList2没有使用泛型,所以不行。

    举例子:

    public class Test10 {  
        public static void main(String[] args) {  
              
            //  
            ArrayList<String> arrayList1=new ArrayList();  
            arrayList1.add("1");//编译通过  
            arrayList1.add(1);//编译错误  
            String str1=arrayList1.get(0);//返回类型就是String  
              
            ArrayList arrayList2=new ArrayList<String>();  
            arrayList2.add("1");//编译通过  
            arrayList2.add(1);//编译通过  
            Object object=arrayList2.get(0);//返回类型就是Object  
              
            new ArrayList<String>().add("11");//编译通过  
            new ArrayList<String>().add(22);//编译错误  
            String string=new ArrayList<String>().get(0);//返回类型就是String  
        }  
    }  

     

    通过上面的例子,我们可以明白,类型检查就是针对引用的,谁是一个引用,用这个引用调用泛型方法,就会对这个引用调用的方法进行类型检测,而无关它真正引用的对象。

    从这里,我们可以再讨论下 泛型中参数化类型为什么不考虑继承关系

    在Java中,像下面形式的引用传递是不允许的:

    ArrayList<String> arrayList1=new ArrayList<Object>();//编译错误  
    ArrayList<Object> arrayList1=new ArrayList<String>();//编译错误  

    我们先看第一种情况,将第一种情况拓展成下面的形式:

    ArrayList<Object> arrayList1=new ArrayList<Object>();  
    arrayList1.add(new Object());  
    arrayList1.add(new Object());  
    ArrayList<String> arrayList2=arrayList1;//编译错误  

     实际上,在第4行代码的时候,就会有编译错误。那么,我们先假设它编译没错。那么当我们使用arrayList2引用用get()方法取值的时候,返回的都是String类型的对象(上面提到了,类型检测是根据引用来决定的。),可是它里面实际上已经被我们存放了Object类型的对象,这样,就会有ClassCastException了。所以为了避免这种极易出现的错误,Java不允许进行这样的引用传递。(这也是泛型出现的原因,就是为了解决类型转换的问题,我们不能违背它的初衷)。

    在看第二种情况,将第二种情况拓展成下面的形式:

    
    ArrayList<String> arrayList1=new ArrayList<String>();  
    arrayList1.add(new String());  
    arrayList1.add(new String());  
    ArrayList<Object> arrayList2=arrayList1;//编译错误  

    没错,这样的情况比第一种情况好的多,最起码,在我们用arrayList2取值的时候不会出现ClassCastException,因为是从String转换为Object。可是,这样做有什么意义呢,泛型出现的原因,就是为了解决类型转换的问题。我们使用了泛型,到头来,还是要自己强转,违背了泛型设计的初衷。所以java不允许这么干。再说,你如果又用arrayList2往里面add()新的对象,那么到时候取得时候,我怎么知道我取出来的到底是String类型的,还是Object类型的呢?

    所以,要格外注意,泛型中的引用传递的问题。

    2、自动类型转换

    因为类型擦除的问题,所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题,既然都被替换为原始类型,那么为什么我们在获取的时候,不需要进行强制类型转换呢?看下ArrayList和get方法:

    public E get(int index) {  
        RangeCheck(index);  
        return (E) elementData[index];  
     }  

    可以看到,在return之前,会根据泛型变量进行强转。

    写了个简单的测试代码:

    public class Test {  
        public static void main(String[] args) {  
            ArrayList<Date> list=new ArrayList<Date>();  
            list.add(new Date());  
            Date myDate=list.get(0);  
    }  

    然后反编了下字节码,如下

    public static void main(java.lang.String[]);  
    Code:  
    0: new #16 // class java/util/ArrayList  
    3: dup  
    4: invokespecial #18 // Method java/util/ArrayList."<init  
    :()V  
    7: astore_1  
    8: aload_1  
    9: new #19 // class java/util/Date  
    12: dup  
    13: invokespecial #21 // Method java/util/Date."<init>":()  
      
    16: invokevirtual #22 // Method java/util/ArrayList.add:(L  
    va/lang/Object;)Z  
    19: pop  
    20: aload_1  
    21: iconst_0  
    22: invokevirtual #26 // Method java/util/ArrayList.get:(I  
    java/lang/Object;  
    25: checkcast #19 // class java/util/Date  
    28: astore_2  
    29: return  

    看第22 ,它调用的是ArrayList.get()方法,方法返回值是Object,说明类型擦除了。然后第25,它做了一个checkcast操作,即检查类型#19, 在在上面找#19引用的类型,他是
    9: new #19 // class java/util/Date
    是一个Date类型,即做Date类型的强转。
    所以不是在get方法里强转的,是在你调用的地方强转的。

    附关于checkcast的解释:
    checkcast checks that the top item on the operand stack (a reference to an object or array) can be cast to a given type. For example, if you write in Java:

    return ((String)obj);

    then the Java compiler will generate something like:

    aload_1 ; push -obj- onto the stack
    checkcast java/lang/String ; check its a String
    areturn ; return it

    checkcast is actually a shortand for writing Java code like:

    if (! (obj == null || obj instanceof <class>)) {
    throw new ClassCastException();
    }
    // if this point is reached, then object is either null, or an instance of
    // <class> or one of its superclasses.

    3、类型擦除与多态的冲突和解决方法

    现在有这样一个泛型类:

    class Pair<T> {  
        private T value;  
        public T getValue() {  
            return value;  
        }  
        public void setValue(T value) {  
            this.value = value;  
        }  
    }  

    然后我们想要一个子类继承它

    class DateInter extends Pair<Date> {  
        @Override  
        public void setValue(Date value) {  
            super.setValue(value);  
        }  
        @Override  
        public Date getValue() {  
            return super.getValue();  
        }  
    }  

    在这个子类中,我们设定父类的泛型类型为Pair<Date>,在子类中,我们覆盖了父类的两个方法,我们的原意是这样的:

    将父类的泛型类型限定为Date,那么父类里面的两个方法的参数都为Date类型:“

    public Date getValue() {  
        return value;  
    }  
    public void setValue(Date value) {  
        this.value = value;  
    }  

     所以,我们在子类中重写这两个方法一点问题也没有,实际上,从他们的@Override标签中也可以看到,一点问题也没有,实际上是这样的吗?

    分析:

    实际上,类型擦除后,父类的的泛型类型全部变为了原始类型Object,所以父类编译之后会变成下面的样子:

    class Pair {  
        private Object value;  
        public Object getValue() {  
            return value;  
        }  
        public void setValue(Object  value) {  
            this.value = value;  
        }  
    }  

    再看子类的两个重写的方法的类型:

    @Override  
    public void setValue(Date value) {  
        super.setValue(value);  
    }  
    @Override  
    public Date getValue() {  
        return super.getValue();  
    }  

    先来分析setValue方法,父类的类型是Object,而子类的类型是Date,参数类型不一样,这如果是在普通的继承关系中,根本就不会是重写,而是重载。
    我们在一个main方法测试一下:

    
    public static void main(String[] args) throws ClassNotFoundException {  
            DateInter dateInter=new DateInter();  
            dateInter.setValue(new Date());                  
            dateInter.setValue(new Object());//编译错误  
     }  

    如果是重载,那么子类中两个setValue方法,一个是参数Object类型,一个是Date类型,可是我们发现,根本就没有这样的一个子类继承自父类的Object类型参数的方法。所以说,却是是重写了,而不是重载了。

    为什么会这样呢?

    原因是这样的,我们传入父类的泛型类型是Date,Pair<Date>,我们的本意是将泛型类变为如下:

    class Pair {  
        private Date value;  
        public Date getValue() {  
            return value;  
        }  
        public void setValue(Date value) {  
            this.value = value;  
        }  
    }  

    然后在子类中重写参数类型为Date的那两个方法,实现继承中的多态。

    可是由于种种原因,虚拟机并不能将泛型类型变为Date,只能将类型擦除掉,变为原始类型Object。这样,我们的本意是进行重写,实现多态。可是类型擦除后,只能变为了重载。这样,类型擦除就和多态有了冲突。JVM知道你的本意吗?知道!!!可是它能直接实现吗,不能!!!如果真的不能的话,那我们怎么去重写我们想要的Date类型参数的方法啊。

    于是JVM采用了一个特殊的方法,来完成这项功能,那就是桥方法。

    首先,我们用javap -c className的方式反编译下DateInter子类的字节码,结果如下:

    class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {  
      com.tao.test.DateInter();  
        Code:  
           0: aload_0  
           1: invokespecial #8                  // Method com/tao/test/Pair."<init>"  
    :()V  
           4: return  
      
      public void setValue(java.util.Date);  //我们重写的setValue方法  
        Code:  
           0: aload_0  
           1: aload_1  
           2: invokespecial #16                 // Method com/tao/test/Pair.setValue  
    :(Ljava/lang/Object;)V  
           5: return  
      
      public java.util.Date getValue();    //我们重写的getValue方法  
        Code:  
           0: aload_0  
           1: invokespecial #23                 // Method com/tao/test/Pair.getValue  
    :()Ljava/lang/Object;  
           4: checkcast     #26                 // class java/util/Date  
           7: areturn  
      
      public java.lang.Object getValue();     //编译时由编译器生成的巧方法  
        Code:  
           0: aload_0  
           1: invokevirtual #28                 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法  
    ;  
           4: areturn  
      
      public void setValue(java.lang.Object);   //编译时由编译器生成的巧方法  
        Code:  
           0: aload_0  
           1: aload_1  
           2: checkcast     #26                 // class java/util/Date  
           5: invokevirtual #30                 // Method setValue:(Ljava/util/Date;   去调用我们重写的setValue方法  
    )V  
           8: return  
    }  

    从编译的结果来看,我们本意重写setValue和getValue方法的子类,竟然有4个方法,其实不用惊奇,最后的两个方法,就是编译器自己生成的桥方法。可以看到桥方法的参数类型都是Object,也就是说,子类中真正覆盖父类两个方法的就是这两个我们看不到的桥方法。而打在我们自己定义的setvalue和getValue方法上面的@Oveerride只不过是假象。而桥方法的内部实现,就只是去调用我们自己重写的那两个方法。

    所以,虚拟机巧妙的使用了桥方法,来解决了类型擦除和多态的冲突。

    不过,要提到一点,这里面的setValue和getValue这两个桥方法的意义又有不同。

    setValue方法是为了解决类型擦除与多态之间的冲突。

    而getValue却有普遍的意义,怎么说呢,如果这是一个普通的继承关系:

    那么父类的setValue方法如下:

    public ObjectgetValue() {  
            return super.getValue();  
        }  

    而子类重写的方法是:

    
    public Date getValue() {  
            return super.getValue();  
        }  

    其实这在普通的类继承中也是普遍存在的重写,这就是协变。

    并且,还有一点也许会有疑问,子类中的桥方法  Object   getValue()和Date getValue()是同 时存在的,可是如果是常规的两个方法,他们的方法签名是一样的,也就是说虚拟机根本不能分别这两个方法。如果是我们自己编写Java代码,这样的代码是无法通过编译器的检查的,但是虚拟机却是允许这样做的,因为虚拟机通过参数类型和返回类型来确定一个方法,所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情,然后交给虚拟机去区别。

    4、泛型类型变量不能是基本数据类型

    不能用类型参数替换基本类型。就比如,没有ArrayList<double>,只有ArrayList<Double>。因为当类型擦除后,ArrayList的原始类型变为Object,但是Object类型不能存储double值,只能引用Double的值。

    5、运行时类型查询

    举个例子:

    ArrayList<String> arrayList=new ArrayList<String>();    
    

    因为类型擦除之后,ArrayList<String>只剩下原始类型,泛型信息String不存在了。

    那么,运行时进行类型查询的时候使用下面的方法是错误的

    if( arrayList instanceof ArrayList<String>)    

    java限定了这种类型查询的方式

    if( arrayList instanceof ArrayList<?>)    

    ? 是通配符的形式 

    6、异常中使用泛型的问题

    1、不能抛出也不能捕获泛型类的对象。事实上,泛型类扩展Throwable都不合法。例如:下面的定义将不会通过编译:

    try{  
    }catch(Problem<Integer> e1){  
    ... 
    }catch(Problem<Number> e2){  
    ...  
    }   

    为什么不能扩展Throwable,因为异常都是在运行时捕获和抛出的,而在编译的时候,泛型信息全都会被擦除掉,那么,假设上面的编译可行,那么,在看下面的定义:

    类型信息被擦除后,那么两个地方的catch都变为原始类型Object,那么也就是说,这两个地方的catch变的一模一样,就相当于下面的这样

    try{  
    }catch(Problem<Object> e1){  
    ...  
    }catch(Problem<Object> e2){  
    ...  

    这个当然就是不行的。就好比,catch两个一模一样的普通异常,不能通过编译一样:

    
    try{  
    }catch(Exception e1){  
    ...  
    }catch(Exception  e2){//编译错误  
    ...  

    2、不能在catch子句中使用泛型变量

    public static <T extends Throwable> void doWork(Class<T> t){  
            try{  
                ...  
            }catch(T e){ //编译错误  
                ...  
            }  
       }  

    因为泛型信息在编译的时候已经变为原始类型,也就是说上面的T会变为原始类型Throwable,那么如果可以在catch子句中使用泛型变量,那么,下面的定义呢:

    public static <T extends Throwable> void doWork(Class<T> t){  
            try{  
                ...  
            }catch(T e){ //编译错误  
                ...  
            }catch(IndexOutOfBounds e){  
            }                           
     }  

    根据异常捕获的原则,一定是子类在前面,父类在后面,那么上面就违背了这个原则。即使你在使用该静态方法的使用T是ArrayIndexOutofBounds,在编译之后还是会变成Throwable,ArrayIndexOutofBounds是IndexOutofBounds的子类,违背了异常捕获的原则。所以java为了避免这样的情况,禁止在catch子句中使用泛型变量。

    但是在异常声明中可以使用类型变量。下面方法是合法的。

    public static<T extends Throwable> void doWork(T t) throws T{  
        try{  
            ...  
        }catch(Throwable realCause){  
            t.initCause(realCause);  
            throw t;   
        }  

    上面的这样使用是没问题的。

    7、数组(这个不属于类型擦除引起的问题)

    不能声明参数化类型的数组。如:

    Pair<String>[] table = newPair<String>(10); //ERROR  

    这是因为擦除后,table的类型变为Pair[],可以转化成一个Object[]。

    Object[] objarray =table;  

      数组可以记住自己的元素类型,下面的赋值会抛出一个ArrayStoreException异常。

    objarray ="Hello"; //ERROR  

      对于泛型而言,擦除降低了这个机制的效率。下面的赋值可以通过数组存储的检测,但仍然会导致类型错误。  

    objarray =new Pair<Employee>();  

    提示:如果需要收集参数化类型对象,直接使用ArrayList:ArrayList<Pair<String>>最安全且有效。

    8、泛型类型的实例化 

    不能实例化泛型类型。如,

    first = new T(); //ERROR  

    是错误的,类型擦除会使这个操作做成new Object()。
    不能建立一个泛型数组。

    public<T> T[] minMax(T[] a){  
         T[] mm = new T[2]; //ERROR  
         ...  
    }  
    

    类似的,擦除会使这个方法总是构靠一个Object[2]数组。但是,可以用反射构造泛型对象和数组。
    利用反射,调用Array.newInstance:

    
    publicstatic <T extends Comparable> T[]minmax(T[] a)  
      
       {  
      
          T[] mm == (T[])Array.newInstance(a.getClass().getComponentType(),2);  
      
           ...  
      
          // 以替换掉以下代码  
      
          // Obeject[] mm = new Object[2];  
      
          // return (T[]) mm;  
      
       }  
     

    9、类型擦除后的冲突

    1、当泛型类型被擦除后,创建条件不能产生冲突。如果在Pair类中添加下面的equals方法:

    
    class Pair<T>   {  
        public boolean equals(T value) {  
            return null;  
        }  
          
    }  

    考虑一个Pair<String>。从概念上,它有两个equals方法:

    booleanequals(String); //在Pair<T>中定义

    boolean equals(Object); //从object中继承

    但是,这只是一种错觉。实际上,擦除后方法

    boolean equals(T)

    变成了方法 boolean equals(Object)

    这与Object.equals方法是冲突的!当然,补救的办法是重新命名引发错误的方法。

    2、泛型规范说明提及另一个原则“要支持擦除的转换,需要强行制一个类或者类型变量不能同时成为两个接口的子类,而这两个子类是同一接品的不同参数化。”

    下面的代码是非法的:

    class Calendar implements Comparable<Calendar>{ ... }  

    class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...} //ERROR  

    GregorianCalendar会实现Comparable<Calender>和Compable<GregorianCalendar>,这是同一个接口的不同参数化实现。

    这一限制与类型擦除的关系并不很明确。非泛型版本:

    class Calendar implements Comparable{ ... }  
    class GregorianCalendar extends Calendar implements Comparable{...} //ERROR

    10、泛型在静态方法和静态类中的问题

    泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数

    举例说明:

    public class Test2<T> {    
        public static T one;   //编译错误    
        public static  T show(T one){ //编译错误    
            return null;    
        }    
    }    

    因为泛型类中的泛型参数的实例化是在定义对象的时候指定的,而静态变量和静态方法不需要使用对象来调用。对象都没有创建,如何确定这个泛型参数是何种类型,所以当然是错误的。

    但是要注意区分下面的一种情况:

     

    public class Test2<T> {    
        
        public static <T >T show(T one){//这是正确的    
            return null;    
        }    
    }    

     

    展开全文
  • Java 泛型,你了解类型擦除吗?

    万次阅读 多人点赞 2019-09-04 16:18:19
    泛型,一个孤独的守门者。 大家可能会有疑问,我为什么叫做泛型是一个守门者。这其实是我个人的看法而已,我的意思是说泛型没有其看起来那么深不可测,它并不神秘与神奇。泛型是 Java 中一个很小巧的概念,但同时也...

    泛型,一个孤独的守门者。

    大家可能会有疑问,我为什么叫做泛型是一个守门者。这其实是我个人的看法而已,我的意思是说泛型没有其看起来那么深不可测,它并不神秘与神奇。泛型是 Java 中一个很小巧的概念,但同时也是一个很容易让人迷惑的知识点,它让人迷惑的地方在于它的许多表现有点违反直觉。

    文章开始的地方,先给大家奉上一道经典的测试题。

    List<String> l1 = new ArrayList<String>();
    List<Integer> l2 = new ArrayList<Integer>();
    		
    System.out.println(l1.getClass() == l2.getClass());
    
    

    请问,上面代码最终结果输出的是什么?不了解泛型的和很熟悉泛型的同学应该能够答出来,而对泛型有所了解,但是了解不深入的同学可能会答错。

    正确答案是 true。

    上面的代码中涉及到了泛型,而输出的结果缘由是类型擦除。先好好说说泛型。

    泛型是什么?

    泛型的英文是 generics,generic 的意思是通用,而翻译成中文,泛应该意为广泛,型是类型。所以泛型就是能广泛适用的类型。

    但泛型还有一种较为准确的说法就是为了参数化类型,或者说可以将类型当作参数传递给一个类或者是方法。

    那么,如何解释类型参数化呢?

    public class Cache {
    	Object value;
    
    	public Object getValue() {
    		return value;
    	}
    
    	public void setValue(Object value) {
    		this.value = value;
    	}
    	
    }
    

    假设 Cache 能够存取任何类型的值,于是,我们可以这样使用它。

    Cache cache = new Cache();
    cache.setValue(134);
    int value = (int) cache.getValue();
    cache.setValue("hello");
    String value1 = (String) cache.getValue();
    

    使用的方法也很简单,只要我们做正确的强制转换就好了。

    但是,泛型却给我们带来了不一样的编程体验。

    public class Cache<T> {
    	T value;
    
    	public Object getValue() {
    		return value;
    	}
    
    	public void setValue(T value) {
    		this.value = value;
    	}
    	
    }
    

    这就是泛型,它将 value 这个属性的类型也参数化了,这就是所谓的参数化类型。再看它的使用方法。

    Cache<String> cache1 = new Cache<String>();
    cache1.setValue("123");
    String value2 = cache1.getValue();
    		
    Cache<Integer> cache2 = new Cache<Integer>();
    cache2.setValue(456);
    int value3 = cache2.getValue();
    
    

    最显而易见的好处就是它不再需要对取出来的结果进行强制转换了。但,还有另外一点不同。
    这里写图片描述
    泛型除了可以将类型参数化外,而参数一旦确定好,如果类似不匹配,编译器就不通过。
    上面代码显示,无法将一个 String 对象设置到 cache2 中,因为泛型让它只接受 Integer 的类型。

    所以,综合上面信息,我们可以得到下面的结论。

    1. 与普通的 Object 代替一切类型这样简单粗暴而言,泛型使得数据的类别可以像参数一样由外部传递进来。它提供了一种扩展能力。它更符合面向抽象开发的软件编程宗旨。
    2. 当具体的类型确定后,泛型又提供了一种类型检测的机制,只有相匹配的数据才能正常的赋值,否则编译器就不通过。所以说,它是一种类型安全检测机制,一定程度上提高了软件的安全性防止出现低级的失误。
    3. 泛型提高了程序代码的可读性,不必要等到运行的时候才去强制转换,在定义或者实例化阶段,因为 Cache<String>这个类型显化的效果,程序员能够一目了然猜测出代码要操作的数据类型。

    下面的文章,我们正常介绍泛型的相关知识。

    泛型的定义和使用

    泛型按照使用情况可以分为 3 种。

    1. 泛型类。
    2. 泛型方法。
    3. 泛型接口。

    泛型类

    我们可以这样定义一个泛型类。

    public class Test<T> {
    	T field1;
    }
    

    尖括号 <>中的 T 被称作是类型参数,用于指代任何类型。事实上,T 只是一种习惯性写法,如果你愿意。你可以这样写。

    public class Test<Hello> {
    	Hello field1;
    }
    

    但出于规范的目的,Java 还是建议我们用单个大写字母来代表类型参数。常见的如:

    1. T 代表一般的任何类。
    2. E 代表 Element 的意思,或者 Exception 异常的意思。
    3. K 代表 Key 的意思。
    4. V 代表 Value 的意思,通常与 K 一起配合使用。
    5. S 代表 Subtype 的意思,文章后面部分会讲解示意。

    如果一个类被 <T>的形式定义,那么它就被称为是泛型类。

    那么对于泛型类怎么样使用呢?

    Test<String> test1 = new Test<>();
    Test<Integer> test2 = new Test<>();
    
    

    只要在对泛型类创建实例的时候,在尖括号中赋值相应的类型便是。T 就会被替换成对应的类型,如 String 或者是 Integer。你可以相像一下,当一个泛型类被创建时,内部自动扩展成下面的代码。

    public class Test<String> {
    	String field1;
    }
    
    
    

    当然,泛型类不至接受一个类型参数,它还可以这样接受多个类型参数。

    public class MultiType <E,T>{
    	E value1;
    	T value2;
    	
    	public E getValue1(){
    		return value1;
    	}
    	
    	public T getValue2(){
    		return value2;
    	}
    }
    
    
    

    泛型方法

    public class Test1 {
    
    	public <T> void testMethod(T t){
    		
    	}
    }
    

    泛型方法与泛型类稍有不同的地方是,类型参数也就是尖括号那一部分是写在返回值前面的。<T>中的 T 被称为类型参数,而方法中的 T 被称为参数化类型,它不是运行时真正的参数。

    当然,声明的类型参数,其实也是可以当作返回值的类型的。

    public  <T> T testMethod1(T t){
    		return null;
    }
    

    泛型类与泛型方法的共存现象

    public class Test1<T>{
    
    	public  void testMethod(T t){
    		System.out.println(t.getClass().getName());
    	}
    	public  <T> T testMethod1(T t){
    		return t;
    	}
    }
    

    上面代码中,Test1<T>是泛型类,testMethod 是泛型类中的普通方法,而 testMethod1 是一个泛型方法。而泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的,泛型方法始终以自己定义的类型参数为准

    所以,针对上面的代码,我们可以这样编写测试代码。

    Test1<String> t = new Test1();
    t.testMethod("generic");
    Integer i = t.testMethod1(new Integer(1));
    
    

    泛型类的实际类型参数是 String,而传递给泛型方法的类型参数是 Integer,两者不想干。

    但是,为了避免混淆,如果在一个泛型类中存在泛型方法,那么两者的类型参数最好不要同名。比如,Test1<T>代码可以更改为这样

    public class Test1<T>{
    
    	public  void testMethod(T t){
    		System.out.println(t.getClass().getName());
    	}
    	public  <E> E testMethod1(E e){
    		return e;
    	}
    }
    

    泛型接口

    泛型接口和泛型类差不多,所以一笔带过。

    public interface Iterable<T> {
    }
    

    通配符 ?

    除了用 <T>表示泛型外,还有 <?>这种形式。 被称为通配符。

    可能有同学会想,已经有了 <T>的形式了,为什么还要引进 <?>这样的概念呢?

    class Base{}
    
    class Sub extends Base{}
    
    Sub sub = new Sub();
    Base base = sub;			
    

    上面代码显示,Base 是 Sub 的父类,它们之间是继承关系,所以 Sub 的实例可以给一个 Base 引用赋值,那么

    		
    List<Sub> lsub = new ArrayList<>();
    List<Base> lbase = lsub;
    
    

    最后一行代码成立吗?编译会通过吗?

    答案是否定的。

    编译器不会让它通过的。Sub 是 Base 的子类,不代表 List<Sub>List<Base>有继承关系。

    但是,在现实编码中,确实有这样的需求,希望泛型能够处理某一范围内的数据类型,比如某个类和它的子类,对此 Java 引入了通配符这个概念。

    所以,通配符的出现是为了指定泛型中的类型范围

    通配符有 3 种形式。

    1. <?>被称作无限定的通配符。
    2. <? extends T>被称作有上限的通配符。
    3. <? super T>被称作有下限的通配符。

    无限定通配符 <?>

    无限定通配符经常与容器类配合使用,它其中的 ? 其实代表的是未知类型,所以涉及到 ? 时的操作,一定与具体类型无关。

    public void testWildCards(Collection<?> collection){
    }
    

    上面的代码中,方法内的参数是被无限定通配符修饰的 Collection 对象,它隐略地表达了一个意图或者可以说是限定,那就是 testWidlCards() 这个方法内部无需关注 Collection 中的真实类型,因为它是未知的。所以,你只能调用 Collection 中与类型无关的方法。
    这里写图片描述

    我们可以看到,当 <?>存在时,Collection 对象丧失了 add() 方法的功能,编译器不通过。
    我们再看代码。

    List<?> wildlist = new ArrayList<String>();
    wildlist.add(123);// 编译不通过
    

    有人说,<?>提供了只读的功能,也就是它删减了增加具体类型元素的能力,只保留与具体类型无关的功能。它不管装载在这个容器内的元素是什么类型,它只关心元素的数量、容器是否为空?我想这种需求还是很常见的吧。

    有同学可能会想,<?>既然作用这么渺小,那么为什么还要引用它呢?

    个人认为,提高了代码的可读性,程序员看到这段代码时,就能够迅速对此建立极简洁的印象,能够快速推断源码作者的意图。

    <? extends T>

    <?>代表着类型未知,但是我们的确需要对于类型的描述再精确一点,我们希望在一个范围内确定类别,比如类型 A 及 类型 A 的子类都可以。

    <? extends T> 代表类型 T 及 T 的子类。 ```java public void testSub(Collection<? extends Base> para){ } ``` 上面代码中,para 这个 Collection 接受 Base 及 Base 的子类的类型。 但是,它仍然丧失了写操作的能力。也就是说 ```java para.add(new Sub()); para.add(new Base()); ``` 仍然编译不通过。 没有关系,我们不知道具体类型,但是我们至少清楚了类型的范围。 ## ```<? super T> ``` 这个和 ```<? extends T>```相对应,代表 T 及 T 的超类。 ```java public void testSuper(Collection<? super Sub> para){ } ``` ```<? super T>```神奇的地方在于,它拥有一定程度的写操作的能力。 ```java public void testSuper(Collection<? super Sub> para){ para.add(new Sub());//编译通过 para.add(new Base());//编译不通过 } ``` # 通配符与类型参数的区别 一般而言,通配符能干的事情都可以用类型参数替换。 比如 ```java public void testWildCards(Collection<?> collection){}
    可以被
    ```java
    public <T> void test(Collection<T> collection){}
    

    取代。

    值得注意的是,如果用泛型方法来取代通配符,那么上面代码中 collection 是能够进行写操作的。只不过要进行强制转换。

    public <T> void test(Collection<T> collection){
    	collection.add((T)new Integer(12));
    	collection.add((T)"123");
    }
    

    需要特别注意的是,类型参数适用于参数之间的类别依赖关系,举例说明。

    public class Test2 <T,E extends T>{
    	T value1;
    	E value2;
    }
    
    
    public <D,S extends D> void test(D d,S s){
    		
    	}
    

    E 类型是 T 类型的子类,显然这种情况类型参数更适合。
    有一种情况是,通配符和类型参数一起使用。

    public <T> void test(T t,Collection<? extends T> collection){
    	
    }
    

    如果一个方法的返回类型依赖于参数的类型,那么通配符也无能为力。

    public T test1(T t){
    	return value1;
    }
    

    类型擦除

    泛型是 Java 1.5 版本才引进的概念,在这之前是没有泛型的概念的,但显然,泛型代码能够很好地和之前版本的代码很好地兼容。

    这是因为,泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,专业术语叫做类型擦除

    通俗地讲,泛型类和普通类在 java 虚拟机内是没有什么特别的地方。回顾文章开始时的那段代码

    List<String> l1 = new ArrayList<String>();
    List<Integer> l2 = new ArrayList<Integer>();
    		
    System.out.println(l1.getClass() == l2.getClass());
    

    打印的结果为 true 是因为 List<String>List<Integer>在 jvm 中的 Class 都是 List.class。

    泛型信息被擦除了。

    可能同学会问,那么类型 String 和 Integer 怎么办?

    答案是泛型转译。

    public class Erasure <T>{
    	T object;
    
    	public Erasure(T object) {
    		this.object = object;
    	}
    	
    }
    
    

    Erasure 是一个泛型类,我们查看它在运行时的状态信息可以通过反射。

    Erasure<String> erasure = new Erasure<String>("hello");
    Class eclz = erasure.getClass();
    System.out.println("erasure class is:"+eclz.getName());
    
    

    打印的结果是

    erasure class is:com.frank.test.Erasure
    

    Class 的类型仍然是 Erasure 并不是 Erasure<T>这种形式,那我们再看看泛型类中 T 的类型在 jvm 中是什么具体类型。

    Field[] fs = eclz.getDeclaredFields();
    for ( Field f:fs) {
    	System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
    }
    

    打印结果是

    Field name object type:java.lang.Object
    

    那我们可不可以说,泛型类被类型擦除后,相应的类型就被替换成 Object 类型呢?

    这种说法,不完全正确。

    我们更改一下代码。

    public class Erasure <T extends String>{
    //	public class Erasure <T>{
    	T object;
    
    	public Erasure(T object) {
    		this.object = object;
    	}
    	
    }
    

    现在再看测试结果:

    Field name object type:java.lang.String
    

    我们现在可以下结论了,在泛型类被类型擦除的时候,之前泛型类中的类型参数部分如果没有指定上限,如 <T>则会被转译成普通的 Object 类型,如果指定了上限如 <T extends String>则类型参数就被替换成类型上限。

    所以,在反射中。

    public class Erasure <T>{
    	T object;
    
    	public Erasure(T object) {
    		this.object = object;
    	}
    	
    	public void add(T object){
    		
    	}
    	
    }
    
    

    add() 这个方法对应的 Method 的签名应该是 Object.class。

    Erasure<String> erasure = new Erasure<String>("hello");
    Class eclz = erasure.getClass();
    System.out.println("erasure class is:"+eclz.getName());
    
    Method[] methods = eclz.getDeclaredMethods();
    for ( Method m:methods ){
    	System.out.println(" method:"+m.toString());
    }
    

    打印结果是

     method:public void com.frank.test.Erasure.add(java.lang.Object)
    

    也就是说,如果你要在反射中找到 add 对应的 Method,你应该调用 getDeclaredMethod("add",Object.class)否则程序会报错,提示没有这么一个方法,原因就是类型擦除的时候,T 被替换成 Object 类型了。

    类型擦除带来的局限性

    类型擦除,是泛型能够与之前的 java 版本代码兼容共存的原因。但也因为类型擦除,它会抹掉很多继承相关的特性,这是它带来的局限性。

    理解类型擦除有利于我们绕过开发当中可能遇到的雷区,同样理解类型擦除也能让我们绕过泛型本身的一些限制。比如
    这里写图片描述

    正常情况下,因为泛型的限制,编译器不让最后一行代码编译通过,因为类似不匹配,但是,基于对类型擦除的了解,利用反射,我们可以绕过这个限制。

    public interface List<E> extends Collection<E>{
    	
    	 boolean add(E e);
    }
    
    

    上面是 List 和其中的 add() 方法的源码定义。

    因为 E 代表任意的类型,所以类型擦除时,add 方法其实等同于

    boolean add(Object obj);
    

    那么,利用反射,我们绕过编译器去调用 add 方法。

    public class ToolTest {
    
    
    	public static void main(String[] args) {
    		List<Integer> ls = new ArrayList<>();
    		ls.add(23);
    //		ls.add("text");
    		try {
    			Method method = ls.getClass().getDeclaredMethod("add",Object.class);
    			
    			
    			method.invoke(ls,"test");
    			method.invoke(ls,42.9f);
    		} catch (NoSuchMethodException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalArgumentException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (InvocationTargetException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		for ( Object o: ls){
    			System.out.println(o);
    		}
    	
    	}
    
    }
    
    

    打印结果是:

    23
    test
    42.9
    

    可以看到,利用类型擦除的原理,用反射的手段就绕过了正常开发中编译器不允许的操作限制。

    泛型中值得注意的地方

    泛型类或者泛型方法中,不接受 8 种基本数据类型。

    所以,你没有办法进行这样的编码。

    List<int> li = new ArrayList<>();
    List<boolean> li = new ArrayList<>();
    
    

    需要使用它们对应的包装类。

    List<Integer> li = new ArrayList<>();
    List<Boolean> li1 = new ArrayList<>();
    

    对泛型方法的困惑

    public <T> T test(T t){
    	return null;
    }
    
    

    有的同学可能对于连续的两个 T 感到困惑,其实 <T>是为了说明类型参数,是声明,而后面的不带尖括号的 T 是方法的返回值类型。
    你可以相像一下,如果 test() 这样被调用

    test("123");
    

    那么实际上相当于

    public String test(String t);
    

    Java 不能创建具体类型的泛型数组

    这句话可能难以理解,代码说明。

    List<Integer>[] li2 = new ArrayList<Integer>[];
    List<Boolean> li3 = new ArrayList<Boolean>[];
    
    

    这两行代码是无法在编译器中编译通过的。原因还是类型擦除带来的影响。

    List<Integer>List<Boolean>在 jvm 中等同于List<Object>,所有的类型信息都被擦除,程序也无法分辨一个数组中的元素类型具体是 List<Integer>类型还是 List<Boolean>类型。

    但是,

    List<?>[] li3 = new ArrayList<?>[10];
    li3[1] = new ArrayList<String>();
    List<?> v = li3[1];
    

    借助于无限定通配符却可以,前面讲过 代表未知类型,所以它涉及的操作都基本上与类型无关,因此 jvm 不需要针对它对类型作判断,因此它能编译通过,但是,只提供了数组中的元素因为通配符原因,它只能读,不能写。比如,上面的 v 这个局部变量,它只能进行 get() 操作,不能进行 add() 操作,这个在前面通配符的内容小节中已经讲过。

    泛型,并不神奇

    我们可以看到,泛型其实并没有什么神奇的地方,泛型代码能做的非泛型代码也能做。

    而类型擦除,是泛型能够与之前的 java 版本代码兼容共存的原因。

    可量也正因为类型擦除导致了一些隐患与局限。

    但,我还是要建议大家使用泛型,如官方文档所说的,如果可以使用泛型的地方,尽量使用泛型。

    毕竟它抽离了数据类型与代码逻辑,本意是提高程序代码的简洁性和可读性,并提供可能的编译时类型转换安全检测功能。

    类型擦除不是泛型的全部,但是它却能很好地检测我们对于泛型这个概念的理解程度。

    我在文章开头将泛型比作是一个守门人,原因就是他本意是好的,守护我们的代码安全,然后在门牌上写着出入的各项规定,及“xxx 禁止出入”的提醒。但是同我们日常所遇到的那些门卫一般,他们古怪偏执,死板守旧,我们可以利用反射基于类型擦除的认识,来绕过泛型中某些限制,现实生活中,也总会有调皮捣蛋者能够基于对门卫们生活作息的规律,选择性地绕开他们的监视,另辟蹊径溜进或者溜出大门,然后扬长而去,剩下守卫者一个孤独的身影。

    所以,我说泛型,并不神秘,也不神奇

    读者们都在下面的二维码所示的免费的知识星球问我问题:
    在这里插入图片描述

    展开全文
  • 泛型 擦除

    千次阅读 2019-03-12 15:17:54
    java泛型是使用擦除来实现的 原始类型 就是删去类型参数后的泛型类型名。 擦除类型变量,并替换为限定类型(边界类型) 若无显示的边界 则默认以类型Object为边界 在泛型代码内部 无法获取任何有关泛型类型的...

    擦除

    java泛型是使用擦除来实现的

    原始类型 就是删去类型参数后的泛型类型名。

    擦除类型变量,并替换为限定类型(边界类型)

    若无显示的边界 则默认以类型Object为边界

    在泛型代码内部 无法获取任何有关泛型类型的信息,

    可以知道类型参数的标识符 和 泛型类型边界,却无法知道用来创建特定实例的实际类型参数


    使用Class<T> 是获取运行时所需的类型信息的唯一的方式  让用户显示的传入一个Class引用 通常是作为一个方法中的参数传入  之后 使用反射来显示地引入该类并创建实例


    1. 不能用基本类型实例化类型参数 如: ArrayList<int
    2. 不能用instanceof中操作测试泛型类型         a instanceof pair<String>   //Error                                                                                instanceof 语法规则 :  A instanceof B  ;//A必须可以被解析为解析为变量 比如常量  对象 局部变量                                                                                                      //  B必须可以被解析为类型,比如类 接口 枚举
    3. 不能创建参数化类型的数组
    • Pair <String> [] table = new Pair<String>[10];
    • 可以这样创建 Pair <String> [] table = new Pair[10]; 
      或者 Pair <String> [] table = (Pair<String>[]) new Pair<?>[10];
      比较推荐的方法 ArrayList<Pair<String>>
      
    • 实际上可以向方法传入不定数参数
      public void p(T...a){
          for (T c:a) {
              System.out.println(c.toString());
          }
      }

      4.不能实例化类型变量  不能这样使用 :new T(..) , new T[..] 或T.class  
      解决:在泛型类中构造一个 方法提供

    • // 调用 让用户提供一个构造器表达式 Pair.makePair(String::new) 
       public static <T> Pair<T> makePair (Supplier<T> constr){
              try{return new Pair<>(constr.get(),constr.get());}
              catch (Exception e){return null;}
          }
      //调用 Pair.makePair(String.class)
          public static <T> Pair<T> makePair(Class<T> c1){
              try{ return new Pair<>(c1.newInstance(),c1.newInstance()); }
              catch(Exception e) {return null;}
      }
      

      5.不能构造泛型数组
      如public static <T extends Comparable> T[] minmax(T[] a){ T[] mm=new T[2];return a;}//Error 不能创建泛型数组

    • import java.lang.reflect.Array;
      import java.util.function.IntFunction;
      public static <T extends Comparable> T[] minmax(IntFunction<T[]> constr,T...a){
          T[] mm=constr.apply(2);...}
      public static <T extends Comparable> T[] minmax(IntFunction<T[]> constr,T...a){
          T[] mm=(T[])Array.newInstance(a.getClass().getComponentType(),2);...}

      6.泛型类的静态上下文中类型变量无效,即不能在静态域中使用类型变量,但static可以修饰泛型方法
      7.不能抛出或捕获泛型类的实例(),泛型类扩展Throwable都是不合法的
      泛型类不能扩展Throwable

      
      public static <T extends Throwable> void doWork(Class<T> t){
      try{ do work}
      catch(T e)
      { Logger.global.info(...)}
      }

       

    List<String> v = new ArrayList<String>();
    System.out.println(v instanceof List<String>);
    //编译器报错:不能对参数化类型列表执行instanceof检查
    //使用 List<?> 代替 因为进一步的泛型类型信息将在运行时被删除
    //就是说可以改为 v instanceof List<?>

    不能让类实现两个看上去不同的泛型接口

    public abstract class Test implements List<String> , List<Date>{ }
    //编译器报错:不能使用不同的参数 List<Date> 和 List<String> 来多次实现接口 List
    //原因由于泛型是使用擦除来实现的 它们在运行时是相同的

    原始类型:每个泛型都有一个原始类型 比如List<String> List<Integer> ,List就是原始类型

    参数化类型 与 原始类型 的相互赋值

    //原始类型            泛型类型
    List list = new ArrayList<Date>();//警告 List 是原始类型。应该将对通用类型 List<E> 的引用参数化
    //泛型类型            原始类型
    List<Date> dates = new ArrayList();//未受检警告 类型安全:类型 ArrayList 的表达式需要进行未经检查的转换以符合 
    //不允许 明显不兼容的内容赋值
    List<Date> dates = new ArrayList<String>();
    //报错 类型不匹配:不能从 ArrayList<String> 转换为List<Date>

    泛型与继承

    继承只适用于"基本"泛型类型,而不适合参数类型

    仅有两个泛型类型都是基于完全相同的参数类型进行实例化的时候 赋值才适用

    //前提 1.List接口是COllection接口的子类
    //     2.List<x> Collocation<y> x完全等于y 
    Collection<Date> cd;
    List<Date> ld = new ArrayList<Date>();
    cd = ld ; //ok
    	    	Collection<Date> cd = new ArrayList<Date>();
    	    	List<Date> ld ;
    	    //	  ld=cd ;  //编译器报错 但可以强制类型转换
    	    	  ld=(List<Date>) cd ; //ok
    Collection<Object> cd;
    List<Date> ld = new ArrayList<Date>();
    cd = ld ;//Error 类型不匹配

    数组引用类型实例类型不匹配造成的运行时错误移到编译期

    class Fruit { }
    class Apple extends Fruit {}                        // Fruit
    class Jonathan extends Apple { }            //   Apple         //Orange
    class Orange extends Fruit { }                // Jonathan
    public  class CovarianArrays {
            public static void main(String [] args){
    	        Fruit [] fruit = new Apple [10];
    	        fruit[0] = new Apple();
    	        fruit[1] = new Jonathan();
                System.out.println(fruit.getClass().getName()); //[LApple;
    	        try{
    	            fruit[0] = new Fruit();
    	        }catch(Exception e) {
    	            System.out.println(e);//ArrayStoreException
    	        }
    	        try{
    	            fruit[0] = new Orange();
    	        }catch(Exception e) {
    	            System.out.println(e);//ArrayStoreException
    	        }
        }    
    }

    将Fruit数组的引用指向  Apple数组的实例 

    编译期 因为实际上实例是Apple[] 所以可以放入Apple Jonathan

                  又因为因为引用类型为Fruit类型所以 可以接受Fruit Orange  

    但运行时的数组机制知道其类型为Apple[] 所以不允许放入Fruit 和Orange类型

    使用泛型将这种错误检查移入编译期

    List<Fruit> flist = new ArrayList<Apple>();
    //前面提到过 编译器会报错,不允许这种情况

    泛型数组也存在类似的引用类型"欺骗编译器的情况"

    	    	Collection<Date> cd = new TreeSet<Date>();
    	    	List<Date> ld ;
    	    	  ld=(List<Date>) cd ;
    //运行错误 Exception in thread "main" java.lang.ClassCastException: java.util.TreeSet cannot be cast to java.util.List

    数组类型的通配符

    • 数组必须是无界限通配符类型 因为数组的无界限通配符实例化中的每一个元素都可以保存任何类型               在运行时 并不一定要对类型的泛型部分进行运行检查 , ArrayList的任何实例对于ArrayList<?>都是可以赋值的

    • 因此只有原始类型检查是必须的


    来看一下Enum的声明

    Enum <E extends Enum<E> >{..}    //java不允许我们扩展Enum类型

    class Foo e xtends Enum<Foo> 1.满足Enum只能有自己的子类来实例化

               2.引用了类型变量E的父类Enum类的任何方法 现在都必须引用子类型

    E是某个参数化的Enum的一个子类

    展开全文
  • 泛型使用与泛型擦除

    千次阅读 2018-10-21 16:17:45
    Java 泛型 泛型(generics)是Java 1.5 中引入的特性。泛型的引入使得代码的灵活性和复用性得以增强,对于容器类的作用更为明显。 泛型可以加在类、接口、方法之上。如下所示: public class Generic1&amp;lt;T&...
  • Java泛型-类型擦除

    万次阅读 多人点赞 2011-05-08 13:10:00
    Java泛型-类型擦除一、概述 Java泛型在使用过程有诸多的问题,如不存在List.class, List不能赋值给List(不可协变),奇怪的ClassCastException等。 正确的使用Java泛型需要深入的了解Java的一些概念,如协变,...
  • 泛型擦除

    2019-11-20 12:52:55
    对于Java中泛型擦除,可以直接使用反射,通过代码来测试。关于反射反射的理解。 通过反射我们可以直接过去一个类中所有的属性(无论权限)与该类的所有信息。 先来看一段代码: 这段代码的输出结果后来为true...
  • 基础知识-Java泛型擦除(简洁明了)

    千次阅读 2018-03-21 15:31:42
    0.概念 Java 泛型的参数只可以代表类,不能代表个别对象。由于 Java 泛型的类型参数之实际类型在编译时会被消除,所以无法在运行时得知其类型参数的类型。Java 编译器在编译泛型时会自动加入类型转换的编码,故运行...
  • Java 泛型——类型擦除

    千次阅读 多人点赞 2018-09-01 20:20:24
    import java.util.*; public class t7 { public static void main(String[] args) { // TODO Auto-generated method stub List&lt;String&gt; ll = new ArrayList&... kk = ne...
  • 泛型:本质是参数化类型。 为什么要使用?创建集合的时候,往集合里面添加数据...泛型擦除?Java的泛型处理过程都是在编译器中进行的,编译器首先会生成bytecode码,这个过程是不包括泛型类型,泛型类型在编译的时候是
  • Java泛型--编译器类型擦除

    千次阅读 2016-11-30 17:54:06
    Java的泛型是伪泛型。在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)。 Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型...
  • 泛型的抽象继承与接口实现注意点

    千次阅读 2017-07-04 17:29:49
    * 不能子类擦除,父类泛型 * 继承有两种,子类为泛型或子类不为泛型 * 子类不为泛型则具体定义T,T1 * * 属性类型: * 父类中,随父类而定 * 子类中,随子类而定 * 方法重写: * 随父类而定 * @author ...
  • Java 泛型的好处及实现原理

    万次阅读 2016-08-02 11:29:10
    做笔试模拟题遇到这样一个问题,平时常用泛型,好处也差不多知道,但是让写出来就不大写的出来了,所以在这边整理一下,以后也可以回顾回顾首先先总结一下好处: 简单易用 消除强制类型转换 保证类型安全 泛型好处...
  • java反射技术的案例之泛型擦除

    千次阅读 2017-08-19 12:14:41
    java反射技术的案例之泛型擦除
  • JDK1.5开始实现了对泛型的支持,但是java对泛型支持的底层实现采用的是类型擦除的方式,这是一种伪泛型。这种实现方式虽然可用但有其缺陷. 《Thinking in Java》的作者 Bruce Eckel也曾撰文《这不是泛型》批评过JDK...
  • Java泛型对方法重载的影响(一)

    千次阅读 2017-04-09 16:41:17
    java泛型是在编译期有效,在运行期被删除,也就是说所有的泛型参数类型在编译后都会被清除掉。因为虚拟机没有泛型类型对象——所有对象都属于普通类。
  • Java泛型详解

    万次阅读 2020-03-05 10:04:28
    Class c1 = new ArrayList<Integer>().getClass(); Class c2 = new ArrayList<String>().getClass(); System.out.println(c1 == c2); //true ...//大括号非常重要,相当于匿名内部类 ...
  • Java泛型擦除和泛型的子类继承限制

    千次阅读 2017-09-12 11:31:21
    一、引 最近发现一个问题,LinkedList ls 不可以被赋值给LinkedList lo,这是为什么呢...LinkdedList被编译之后,class文件中其变成了LinkedList list,存在泛型擦除的过程。这样来看,上面两个LinkedList其实是可以包
  • 首先,java中有泛型擦除这一概念。如果不太了解这一概念的同学可以自己找一下度娘。(简单来说:就是如果使用了泛型,在编译期的时候泛型会被擦除掉,也就是说jvm所看到的class文件中是不存在泛型这一概念和东西的。) ...
  • Java -- 泛型 泛型擦除 泛型补偿

    千次阅读 热门讨论 2019-09-07 13:40:04
    运行时:会将泛型去掉,生成的class文件时不带泛型的-- 成为泛型擦除 (1)为什么会擦除? 为了兼容运行的类加载器,(jdk1.5之后引入了泛型,但与之对应的运行的类加载器没有升级) 当然,并不是每一个泛型...
1 2 3 4 5 ... 20
收藏数 15,537
精华内容 6,214
关键字:

泛型擦除