码迷，mamicode.com
首页 > 编程语言 > 详细

JAVA泛型

时间：2016-07-12 19:10:30      阅读：249      评论：0      收藏：0      [点我收藏+]

标签：

 
泛型类
  1. publicclassContainer<K, V>{
  2.     private K key;
  3.     private V value;
  4.  
  5.     publicContainer(K k, V v){
  6.         key = k;
  7.         value = v;
  8.     }
  9.  
  10.     public K getKey(){
  11.         return key;
  12.     }
  13.  
  14.     publicvoid setKey(K key){
  15.         this.key = key;
  16.     }
  17.  
  18.     public V getValue(){
  19.         return value;
  20.     }
  21.  
  22.     publicvoid setValue(V value){
  23.         this.value = value;
  24.     }
  25. }
从泛型类派生子类：
  1. publicclass A extends Apple<T>  //错误
  2. publicclass A extends Apple<String>//正确，把Apple<T>中的T当作String处理
  3. publicclass A extends Apple  //可以，但泛型检查有警告：未检查或不安全的操作，Apple<T>中的T当作Object处理
 
泛型接口
泛型接口实现的两种方式：
1、定义子类：在子类的定义上也声明泛型类型：
  1. interface Info<T>{        // 在接口上定义泛型 
  2.     public T getVar();// 定义抽象方法，抽象方法的返回值就是泛型类型 
  3. } 
  4. classInfoImpl<T> implements Info<T>{   // 定义泛型接口的子类 
  5.     private T var ;             // 定义属性 
  6.     publicInfoImpl(T var){     // 通过构造方法设置属性内容 
  7.         this.setVar(var);   
  8.     } 
  9.     publicvoid setVar(T var){ 
  10.         this.var = var ; 
  11.     } 
  12.     public T getVar(){ 
  13.         returnthis.var ; 
  14.     } 
  15. }; 
  16. publicclassGenericsDemo24{ 
  17.     publicstaticvoid main(String arsg[]){ 
  18.         Info<String> i = null;        // 声明接口对象 
  19.         i =newInfoImpl<String>("李兴华");// 通过子类实例化对象 
  20.         System.out.println("内容："+ i.getVar()); 
  21.     } 
  22. };  
2、如果现在实现接口的子类不想使用泛型声明，则在实现接口的时候直接指定好其具体的操作类型即可：
  1. interface Info<T>{        // 在接口上定义泛型 
  2.     public T getVar();// 定义抽象方法，抽象方法的返回值就是泛型类型 
  3. } 
  4. classInfoImpl implements Info<String>{   // 定义泛型接口的子类 
  5.     privateString var ;                // 定义属性 
  6.     publicInfoImpl(String var){        // 通过构造方法设置属性内容 
  7.         this.setVar(var);   
  8.     } 
  9.     publicvoid setVar(String var){ 
  10.         this.var = var ; 
  11.     } 
  12.     publicString getVar(){ 
  13.         returnthis.var ; 
  14.     } 
  15. }; 
  16. publicclassGenericsDemo25{ 
  17.     publicstaticvoid main(String arsg[]){ 
  18.         Info i = null;      // 声明接口对象 
  19.         i =newInfoImpl("李兴华");   // 通过子类实例化对象 
  20.         System.out.println("内容："+ i.getVar()); 
  21.     } 
  22. };  
 
泛型方法
[访问权限]<泛型标识> 返回类型 函数名称（参数类型）
  1. classDemo{ 
  2.     public<T> T fun(T t){            // 可以接收任意类型的数据 
  3.         return t ;                  // 直接把参数返回 
  4.     } 
  5. }; 
  6. publicclassGenericsDemo26{ 
  7.     publicstaticvoid main(String args[]){ 
  8.         Demo d =newDemo();   // 实例化Demo对象 
  9.         String str = d.fun("李兴华");//  传递字符串 
  10.         int i = d.fun(30);     // 传递数字，自动装箱 
  11.         System.out.println(str);   // 输出内容 
  12.         System.out.println(i);     // 输出内容 
  13.     } 
  14. };  
 
泛型数组
  1. publicclassGenericsDemo30{ 
  2.     publicstaticvoid main(String args[]){ 
  3.         Integer i[]= fun1(1,2,3,4,5,6);   // 返回泛型数组 
  4.         fun2(i); 
  5.     } 
  6.     publicstatic<T> T[] fun1(T...arg){  // 接收可变参数 
  7.         return arg ;            // 返回泛型数组 
  8.     } 
  9.     publicstatic<T>void fun2(T param[]){   // 输出 
  10.         System.out.print("接收泛型数组："); 
  11.         for(T t:param){ 
  12.             System.out.print(t +"、"); 
  13.         } 
  14.     } 
  15. }; 
  16.  
 
类型擦除
使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。如：在代码中定义的List<Object>和List<String>等类型，在编译之后都会变成List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。类型擦除也是Java的泛型实现方式与C++模板机制实现方式之间的重要区别。
类型擦除的基本过程也比较简单，首先是找到用来替换类型参数的具体类：这个具体类一般是Object；如果指定了类型参数的上界的话，则使用这个上界。把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明，即去掉<>的内容。比如T.get()方法声明就变成了Object.get()；List<String>就变成了List。接下来就可能需要生成一些桥接方法（bridge method）。这是由于擦除了类型之后的类可能缺少某些必须的方法，这个时候就由编译器来动态生成这个方法。
  • 泛型类并没有自己独有的Class类对象，不管泛型类型的实际类型参数是什么，它们在运行时都有同样的类（class）。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。
  • Class c1 =newArrayList<Integer>().getClass();
  • Class c2 =newArrayList<String>().getClass();
  • System.out.println(c1 == c2);
  •  
  • /* Output
  • true
  • */
  • 静态变量是被泛型类的所有实例所共享的。对于声明为MyClass<T>的类，访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass<String>还是new MyClass<Integer>创建的对象，都是共享一个静态变量。所以在静态方法、静态变量的声明和初始化中不允许使用类型形参：
技术分享
  • instanceof运算符后不能使用泛型类
技术分享
 
类型擦除原因：
由于泛型并不是从Java诞生就存在的一个特性，而是等到SE5才被加入的，所以为了兼容之前并未使用泛型的类库和代码，不得不让编译器擦除掉代码中有关于泛型类型信息的部分，这样最后生成出来的代码其实是『泛型无关』的，我们使用别人的代码或者类库时也就不需要关心对方代码是否已经『泛化』，反之亦然。
 
在泛型代码内部，无法获得任何有关泛型参数类型的信息。泛型参数的类型对于JVM来说，实际上只是一堆占位符。
  1. publicclassMain<T>{
  2.  
  3.     public T[] makeArray(){
  4.         // error: Type parameter ‘T‘ cannot be instantiated directly
  5.         returnnew T[5];
  6.     }
  7. }
我们无法在泛型内部创建一个T类型的数组，原因也和之前一样，T仅仅是个占位符，并没有真实的类型信息，实际上，除了new表达式之外，instanceof操作和转型（会收到警告）在泛型内部都是无法使用的，而造成这个的原因就是之前讲过的编译器对类型信息进行了擦除。
 同时，面对泛型内部形如T var;的代码时，记得多念几遍：它只是个Object，它只是个Object……
 
对泛型数组的擦除补偿，本质方法还是通过显示地传递类型标签，通过Array.newInstance(type, size)来生成数组，同时也是最为推荐的在泛型内部生成数组的方法。泛型内部生成数组的方法：
  1. publicclassMain<T>{
  2.  
  3.     public T[] create(Class<T> type){
  4.         return(T[])Array.newInstance(type,10);
  5.     }
  6.  
  7.     publicstaticvoid main(String[] args){
  8.         Main<String> m =newMain<String>();
  9.         String[] strings = m.create(String.class);
  10.     }
  11. }
 
虽然有类型擦除的存在，使得编译器在泛型内部其实完全无法知道有关T的任何信息，但是编译器可以保证重要的一点：内部一致性，也是我们放进去的是什么类型的对象，取出来还是相同类型的对象，这一点让Java的泛型起码还是有用武之地的。
编译器承担了全部的类型检查工作：一个方法如果接收List<Object>作为形式参数，那么如果尝试将一个List<String>的对象作为实际参数传进去，会无法通过编译（抛出ClassCastException）。
在java中，一般情况下：子类是可以替换父类。比如在参数传递中，String[]可以替换Object[]，但List<String>是不能替换掉List<Object>的。Object是String的父类，但List<Object>不是List<String>的父类
  1. publicvoid inspect(List<Object>list){   
  2.     for(Object obj :list){       
  3.         System.out.println(obj);   
  4.     }   
  5.     list.add(1);//这个操作在当前方法的上下文是合法的。
  6. }
  7. publicvoid test(){   
  8.     List<String> strs =newArrayList<String>();   
  9.     inspect(strs);//编译错误
  10. }  
 
类型通配符<？>
通配符所代表的其实是一组类型，但具体的类型是未知的。如List<?>就声明了List中包含的元素类型是未知的。不能通过new ArrayList<?>()的方法来创建一个新的ArrayList对象或往List<?>中添加元素，因为编译器无法知道具体的类型是什么；但是对于 List<?>中的元素确总是可以用Object来引用的，如调用List的get方法来返回指定索引处的元素，因为虽然类型未知，但肯定是Object及其子类。
技术分享
 
使用上下界来限制未知类型的范围<? extends Shape>
List<? extends Number>说明List中可能包含的元素类型是Number及其子类
List<? super Number>说明List中包含的是Number及其父类。
当引入了上界之后，在使用类型的时候就可以使用上界类中定义的方法。比如访问 List<? extends Number>的时候，就可以使用Number类的intValue等方法。同样由于编译器无法知道具体的类型是什么，故不能往其中添加元素。
使用：
技术分享
 
  1. 通配符修饰的泛型不能用来直接创建变量对象。
  2. 通配符修饰相当于声明了一种变量，它可以作为参数在方法中传递。这么做带来的好处就是我们可以将应用于包含某些数据类型的列表的方法也应用到包含其子类型的列表中。相当于可以在列表中用到一些面向对象的特性。
 
最佳实践
  • 在代码中避免泛型类和原始类型的混用。比如List<String>和List不应该共同使用。这样会产生一些编译器警告和潜在的运行时异常。当需要利用JDK 5之前开发的遗留代码，而不得不这么做时，也尽可能的隔离相关的代码。
  • 在使用带通配符的泛型类的时候，需要明确通配符所代表的一组类型的概念。由于具体的类型是未知的，很多操作是不允许的。
  • 泛型类最好不要同数组一块使用。你只能创建new List<?>[10]这样的数组，无法创建new List<String>[10]这样的。这限制了数组的使用能力，而且会带来很多费解的问题。因此，当需要类似数组的功能时候，使用集合类即可。
  • 不要忽视编译器给出的警告信息。
 
 
参考与阅读：
https://segmentfault.com/a/1190000002646193（泛型类、泛型接口和泛型方法）
 

 

JAVA泛型

标签：

原文地址：http://www.cnblogs.com/Doing-what-I-love/p/5664472.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！