泛型实现原理_java泛型实现原理 - CSDN
精华内容
参与话题
  • java泛型实现原理

    2015-01-08 12:28:40
    一、Java泛型实现原理:类型擦出  Java的泛型是伪泛型。在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)。  Java中的泛型基本上都是在编译器这个层次来实现...

    一、Java泛型实现原理:类型擦出

           Java的泛型是伪泛型。在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)。

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

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

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

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

    Java代码  收藏代码
    1. class Pair<T> {    
    2.   private T value;    
    3.   public T getValue() {    
    4.     return value;    
    5.   }    
    6.   public void setValue(T  value) {    
    7.     this.value = value;    
    8.   }    
    9. }    

     Pair<T>的原始类型为:

    Java代码  收藏代码
    1. class Pair {    
    2.   private Object value;    
    3.   public Object getValue() {    
    4.     return value;    
    5.   }    
    6.   public void setValue(Object  value) {    
    7.     this.value = value;    
    8.   }    
    9. }  

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

     

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

    比如Pair这样声明:

    Java代码  收藏代码
    1. public class Pair<T extends Comparable& Serializable> {   

        那么原始类型就是Comparable

     

        注意:

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

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

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

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

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

    Java代码  收藏代码
    1. public class Test{    
    2.   public static void main(String[] args) {    
    3.     /**不指定泛型的时候*/    
    4.     int i=Test.add(12); //这两个参数都是Integer,所以T为Integer类型    
    5.     Number f=Test.add(11.2);//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Number    
    6.     Object o=Test.add(1"asd");//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Object    
    7.     
    8.     /**指定泛型的时候*/    
    9.     int a=Test.<Integer>add(12);//指定了Integer,所以只能为Integer类型或者其子类    
    10.     int b=Test.<Integer>add(12.2);//编译错误,指定了Integer,不能为Float    
    11.     Number c=Test.<Number>add(12.2); //指定为Number,所以可以为Integer和Float    
    12.   }    
    13.   
    14.   //这是一个简单的泛型方法    
    15.   public static <T> T add(T x,T y){    
    16.     return y;    
    17.   }    
    18. }    

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


    (三)数组与泛型

    当实现一个泛型类时,您可能想要构造一个数组T[]。因为泛型是通过擦除(erasure)实现的,所以这是不允许的。
    您可以尝试把Object[]强制转换为T[]。但这是不安全的。

    具体化解决方案
    按照泛型教程的惯例,解决方案使用的是“类型令牌”,通过向构造函数添加一个Class<T>参数,可以强制客户端为类的类型参数提供正确的类对象:

    public class ArrayExample<T> {
        private Class<T> clazz;

        public ArrayExample(Class<T> clazz) {
            this.clazz = clazz;
        }

        public T[] getArray(int size) {
            return (T[])Array.newInstance(clazz, size);
        }
    }

    为了构造ArrayExample<String>,客户端必须把String.class传递给构造函数,因为String.class的类型是Class<String>。
    拥有类对象使构造一个具有正确元素类型的数组成为可能。


    展开全文
  • Java 泛型的好处及实现原理

    万次阅读 2016-08-02 11:29:10
    简单易用 消除强制类型转换 保证类型安全 泛型好处:泛型简单易用 类型安全 泛型的主要目标是实现java的类型安全。 泛型可以使编译器知道一个对象的限定类型是什么,这样编译器就可以在一个高的程度上验证这个类型...

    做笔试模拟题遇到这样一个问题,平时常用泛型,好处也差不多知道,但是让写出来就不大写的出来了,所以在这边整理一下,以后也可以回顾回顾

    首先先总结一下好处:
    简单易用 消除强制类型转换 保证类型安全

    泛型好处:

    泛型简单易用

    类型安全 泛型的主要目标是实现java的类型安全。 泛型可以使编译器知道一个对象的限定类型是什么,这样编译器就可以在一个高的程度上验证这个类型

    消除了强制类型转换 使得代码可读性好,减少了很多出错的机会

    Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。

    泛型的实现原理

    泛型的实现是靠类型擦除技术 类型擦除是在编译期完成的 也就是在编译期 编译器会将泛型的类型参数都擦除成它的限定类型,如果没有则擦除为object类型之后在获取的时候再强制类型转换为对应的类型。 在运行期间并没有泛型的任何信息,因此也没有优化。

    泛型不考虑继承

    List 类型 是否 可以 赋值为 List类型 ?
    答案是不可以的
    虽然说在赋值之后 String类型可以当做 Object类型使用 但是还是会出现问题
    假设如下代码

    List<String> strings = new ArrayList<>();
        strings.add("哈哈哈哈");
        List<Object> objs = new ArrayList<>();
        objs = strings;  //编译会出错,这里我们假设成功  
        Object aa = objs.get(0);  //此处可以把String转换为Object使用 
        objs.add("呵呵呵呵");
        objs.add(new Object());  //这时 objs中 既有 String 类型 也有 Object类型 
        objes.get(2);  //这个时候 我们不会知道取出的到底是 Object对象 还是 String类型的对象  因此编译器为了防止出现这种情况  就提示编译出错

    更详细的可以参考下面这篇文章:
    java泛型(二)、泛型的内部原理:类型擦除以及类型擦除带来的问题

    展开全文
  • Java泛型实现原理

    千次阅读 2016-03-01 17:54:02
    由于前一段时间发现公司有些代码重复性很大,可以使用泛型方法简化,所以向领导提出,领导就让我整理了一下关于泛型的只是分享给大家。 一、Java泛型介绍    泛型是Java 1.5的新特性,泛型的本质是参数化类型,...

     由于前一段时间发现公司有些代码重复性很大,可以使用泛型方法简化,所以向领导提出,领导就让我整理了一下关于泛型的只是分享给大家。

    一、Java泛型介绍

     

        泛型是Java 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

     

           Java泛型被引入的好处是安全简单。

     

        在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。

     

        泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。

     

        泛型在使用中还有一些规则和限制:

     

    1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

     

    2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

     

    3、泛型的类型参数可以有多个。

     

    4、泛型的参数类型可以使用extends语句,例如。习惯上成为“有界类型”。

    5、泛型的参数类型还可以是通配符类型。

    Java代码  收藏代码
    1. Class<?> classType = Class.forName(java.lang.String);  

        泛型还有接口、方法等等,内容很多,需要花费一番功夫才能理解掌握并熟练应用。

    二、Java泛型实现原理:类型擦出

           Java的泛型是伪泛型。在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)。

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

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

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

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

    Java代码  收藏代码
    1. class Pair<T> {    
    2.   private T value;    
    3.   public T getValue() {    
    4.     return value;    
    5.   }    
    6.   public void setValue(T  value) {    
    7.     this.value = value;    
    8.   }    
    9. }    

     Pair<T>的原始类型为:

    Java代码  收藏代码
    1. class Pair {    
    2.   private Object value;    
    3.   public Object getValue() {    
    4.     return value;    
    5.   }    
    6.   public void setValue(Object  value) {    
    7.     this.value = value;    
    8.   }    
    9. }  

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

     

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

    比如Pair这样声明:

    Java代码  收藏代码
    1. public class Pair<T extends Comparable& Serializable> {   

        那么原始类型就是Comparable

     

        注意:

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

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

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

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

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

    Java代码  收藏代码
    1. public class Test{    
    2.   public static void main(String[] args) {    
    3.     /**不指定泛型的时候*/    
    4.     int i=Test.add(12); //这两个参数都是Integer,所以T为Integer类型    
    5.     Number f=Test.add(11.2);//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Number    
    6.     Object o=Test.add(1"asd");//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Object    
    7.     
    8.     /**指定泛型的时候*/    
    9.     int a=Test.<Integer>add(12);//指定了Integer,所以只能为Integer类型或者其子类    
    10.     int b=Test.<Integer>add(12.2);//编译错误,指定了Integer,不能为Float    
    11.     Number c=Test.<Number>add(12.2); //指定为Number,所以可以为Integer和Float    
    12.   }    
    13.   
    14.   //这是一个简单的泛型方法    
    15.   public static <T> T add(T x,T y){    
    16.     return y;    
    17.   }    
    18. }    

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

    四、C++模板实现

        虽然我不懂C++,但是我也在网上找了下C++的实现方式。

        在c++中为每个模板的实例化产生不同的类型,这一现象被称为“模板代码膨胀”。

    比如 vector<int>, vector<char>, vector<double>, 这里总共会生成3份不同的vector代码。

    展开全文
  • java泛型的作用及实现原理

    万次阅读 2016-07-31 10:13:20
    一、泛型的介绍 泛型是Java 1.5的新特性,泛型的本质是参数化类型,...在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这

    一、泛型的介绍
    泛型是Java 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

       Java泛型被引入的好处是安全简单。
    
    在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
    
    泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
    

    泛型在使用中还有一些规则和限制:
    1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

    2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

    3、泛型的类型参数可以有多个。

    4、泛型的参数类型可以使用extends语句,例如。习惯上成为“有界类型”。

    5、泛型的参数类型还可以是通配符类型。

    二、泛型的作用:
    (1)、限定类型就已经有很大作用了,特别是写基础架构的时候,不需要以前那样的检查,我们的代码量和开发速度都可以提升一大截;
    (2)、Think IN JAVA : 能够进行编译期间类型检查;(官方)
    (3)、限定类型啊 通俗点比喻 (箱子贴标签)这个箱子是放苹果的 那个箱子是放橘子的
    ( 4 )、封装一些共性问题,可以简化很多代码,使代码更加有层次,简单
    (5)、比object类范围明显缩小了,提高了程序运行的效率

    三、泛型的实现原理
    http://blog.csdn.net/wisgood/article/details/11762427
    http://irfen.iteye.com/blog/1888312

    这里写图片描述

    四、

    list<String>类型对象是否可以赋给一个List<Object>类型引用?
    public class Test {
        public static void main(String[] args) {
            List<String> a = null;
            List<Object> bNew = a;
        }
    }

    这段代码会报编译错误

    1、这里的Object 和 String 仅仅是给编译器做编译的时候检查用的。
    这里的List<Object> 和List<String> 并没有什么父子类的关系,仅仅是表示一个用来装Obejct型对像,一个用来装String型对像。

    2、这种转换只能在子类与父类之间转换,虽然Object是String的父类,但是List<Object>和List<String>在编译器看来,是两种完全不同的东西,不允许你这样转换。

    3、如果一定要转换:下面

    public static void main(String[] args) {
            List<String> a = null;
            List<Object> b = convert(a, Object.class);
        }
    
        @SuppressWarnings("unchecked")
        public static <T> List<T> convert(List<?> list, Class<T> c) {
            return (List<T>)list;
        }
    展开全文
  • Java泛型实现原理与问题

    万次阅读 2016-07-23 12:46:41
    很久没写博客了,因为项目和一些个人原因。最近复习找工作,看书+回想项目后有一些心得,加上博客停更这么长时间以来的积累,很是有些东西可写。...1. 泛型定义看了很多泛型的解释百度百科,解释1,解
  • 泛型的好处和实现原理

    千次阅读 2018-07-12 10:46:40
    泛型的好处 泛型简单易用 类型安全, 泛型的主要目标是实现java的类型安全。 泛型可以使编译器知道一个对象的限定类型是什么,这样编译器就可以在一个高的程度上验证这个类型 ...泛型实现原理 ...
  • 泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型?为什么要使用泛型泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递...
  • 泛型实现原理

    2020-03-23 14:40:35
    一、泛型是什么? Java泛型(generics)是JDK 5中引入的一个新特性,泛型提供了编译时类型安全监测机制,该机制允许我们在编译时检测到非法的类型数据结构; 泛型的本质就是参数化类型,也就是所操作的数据类型被...
  • (新) Kotlin搞起来 —— 5.泛型

    万次阅读 2017-07-28 17:33:14
    (新) Kotlin搞起来 —— 5.泛型 Java泛型的引入 Java中泛型的使用 Java假泛型实现原理 Java泛型通配符的引入 Kotlin中的型变 声明处型变 类型投影 *投影
  • java泛型(一)、泛型的基本介绍和使用

    万次阅读 多人点赞 2012-08-30 20:22:00
    现在开始深入学习java的泛型了,以前一直只是在集合中简单的使用泛型,根本就不明白泛型原理和作用。泛型在java中,是一个十分重要的特性,所以要好好的研究下。 一、泛型的基本概念  泛型的定义:泛型是...
  • Java获取泛型参数的类型的方法

    万次阅读 2012-05-27 21:25:48
    由于Java泛型实现机制,使用了泛型的代码在运行期间相关的泛型参数的类型会被擦除,我们无法在运行期间获知泛型参数的具体类型(所有的泛型类型在运行时都是Object类型)。 但是有的时候,我们确实需要获知泛型...
  • Java静态泛型方法

    万次阅读 2016-09-16 23:55:39
    Java在JDK 5中引入了泛型,使用起来方便了很多,下面是一段很常见的泛型使用: ListString> list = new ArrayListString>(); 泛型方法使用 不仅集合中可以使用,在定义类和方法的时候也是经常使用的,但是关于...
  • C#泛型应用及原理

    千次阅读 2019-08-19 14:03:04
    泛型(generic)是C#语言2.0和通用语言运行时(CLR)的一个新特性。泛型为.NET框架引入了类型参数(type parameters)的概念。类型参数使得设计类和方法时,不必指定方法有一个或多个具体参数,而是在调用方法的时候...
  • 泛型类型实现原理相关的两个概念:原始类型、类型擦除。原始类型Java总是会自动的为泛型类型提供一个相应的原始类型。所谓原始类型就是是指泛型的第一个限定类型(从左向右),无限定类型泛型的原始类型默认为Object...
  • 在Unity3D中使用泛型(上)

    千次阅读 2017-10-20 21:10:07
    在Unity3D中使用泛型(上)目录在Unity3D中使用泛型上 目录 为什么需要泛型机制 泛型的一个例子 泛型的好处 Unity3D中常见的泛型 小结为什么需要泛型机制泛型机制的出现,最主要的目的就是代码复用。在泛型机制出现...
  • 由于Java泛型实现机制,使用了泛型的代码在运行期间相关的泛型参数的类型会被擦除,我们无法在运行期间获知泛型参数的具体类型(所有的泛型类型在运行时都是Object类型)。 但是有的时候,我们确实需要获知泛型...
  • Java的泛型(参数化类型)

    万次阅读 多人点赞 2018-05-30 20:22:21
    泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也...
  • java面试之泛型

    千次阅读 2014-12-23 14:51:36
    泛型是JDK 1.5的一项新特性,在Java语言处于还没有出现泛型的版本时,只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。例如在哈希表的存取中,JDK 1.5之前使用HashMap的get()方法,...
  • Java泛型深入理解

    万次阅读 多人点赞 2020-09-20 12:36:53
    Java泛型,包括Java泛型实现泛型擦除以及相关面试题,通配符理解
  • 深入理解 Java 泛型

    万次阅读 多人点赞 2017-01-18 19:48:40
    首先提个问题: Java 泛型的作用是什么?泛型擦除是什么?泛型一般用在什么场景? 如果这个问题你答不上来,那这篇文章可能就对你有些价值。 读完本文你将了解到: ...擦除的实现原理 擦除导致
1 2 3 4 5 ... 20
收藏数 46,310
精华内容 18,524
关键字:

泛型实现原理