快乐学习
前程无忧、中华英才非你莫属!

java泛型擦除的补偿

java泛型擦除的神秘之处


  1. package org.rui.generics.erasure;  

  2.   

  3. public class HasF {  

  4.     public void f(){  

  5.         System.out.println("hasf.f");  

  6.     }  

  7.   

  8. }  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2. /** 

  3.  * 边界 <T extneds Hasf>声明T必须具有类型HasF或者从Hasf导出的类型。 

  4.  * 如果情况确实如此,那么就可以安全地在obj上调用f()了 

  5.  * T擦除了 HasF 

  6.  * @author lenovo 

  7.  * 

  8.  * @param <T> 

  9.  */  

  10. //class Manipulator<T>  Error: 不能调用obj.f()  

  11.  class Manipulator<T extends HasF>   

  12.  {  

  13.     private T obj;  

  14.     public Manipulator(T x){obj=x;}  

  15.     public void manipulate(){obj.f();}  

  16.     //获取泛型类型  

  17.     public T getGenType(){return obj;}  

  18.       

  19.       

  20. }  

  21.   

  22.   

  23. public class Manipulation<T>   

  24. {  

  25.     public static void main(String[] args)   

  26.     {  

  27.         HasF h=new HasF();  

  28.         Manipulator<HasF> man=new Manipulator<HasF>(h);  

  29.         man.manipulate();  

  30.         System.out.println("genType:"+man.getGenType().getClass());  

  31.     }  

  32. }  

  33. /**output: 

  34. hasf.f 

  35. genType:class org.rui.generics.erasure.HasF 

  36. */  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2.   

  3. import java.lang.reflect.Array;  

  4. import java.util.Arrays;  

  5.   

  6. /** 

  7.  * 边界处的动作 

  8.  * 即失kind被存储为Class<T> 擦除也意味着它实际将被存储为 Class,没有任何参数 

  9.  * @author lenovo 

  10.  * 

  11.  */  

  12. public class ArrayMaker<T> {  

  13.     private Class<T> kind;  

  14.     public ArrayMaker(Class<T> kind)  

  15.     {  

  16.         this.kind=kind;  

  17.     }  

  18.       

  19.     @SuppressWarnings("unchecked")  

  20.     T[] create(int size)  

  21.     {  

  22.         return (T[])Array.newInstance(kind, size);  

  23.     }  

  24.       

  25.     public static void main(String[] args)   

  26.     {  

  27.         ArrayMaker<String> maker=new ArrayMaker<String>(String.class);  

  28.         String[] stringArray=maker.create(9);  

  29.         System.out.println(Arrays.toString(stringArray));  

  30.     }  

  31. }  

  32. /**output: 

  33.  * [null, null, null, null, null, null, null, null, null] 

  34.  */  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2.   

  3. import java.lang.reflect.Array;  

  4. import java.util.ArrayList;  

  5. import java.util.Arrays;  

  6. import java.util.List;  

  7.   

  8. /** 

  9.  * 边界处的动作 

  10.  * 容器而不是数组 情况不不同了 

  11.  * @author lenovo 

  12.  * 

  13.  */  

  14. public class ListMaker<T> {  

  15.     /*private Class<T> kind; 

  16.     public ListMaker(Class<T> kind) 

  17.     { 

  18.         this.kind=kind; 

  19.     }*/  

  20.       

  21.   

  22.     List<T> create(T t,int n)  

  23.     {  

  24.         List<T> list= new ArrayList<T>();  

  25.         for(int i=0;i<n;i++)  

  26.             list.add(t);  

  27.         return list;  

  28.     }  

  29.       

  30.     public static void main(String[] args)   

  31.     {  

  32.         ListMaker<String> maker=new ListMaker<String>();  

  33.         List<String> str=maker.create("hello",4);  

  34.         System.out.println(str);  

  35.     }  

  36. }  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2. /** 

  3.  * 擦除的补偿 

  4.  *  

  5.  * 编译器将确保类型标签可以匹配泛型参数 

  6.  * @author lenovo 

  7.  * 

  8.  */  

  9.   

  10. class Building{}  

  11. class House extends Building{}  

  12.   

  13. public class ClassTypeCapture<T> {  

  14.       

  15.     Class<T> kind;  

  16.     public ClassTypeCapture(Class<T> kind)  

  17.     {  

  18.         this.kind=kind;  

  19.     }  

  20.       

  21.     public boolean f(Object obj)  

  22.     {  

  23.         System.out.println(kind +"   isInstance    "+obj);  

  24.         return kind.isInstance(obj);  

  25.     }  

  26.       

  27.     public static void main(String[] args)  

  28.     {  

  29.         ClassTypeCapture<Building> ctc=  

  30.                 new ClassTypeCapture<Building>(Building.class);  

  31.         System.out.println(ctc.f(new Building()));  

  32.         //父类  与子对比  

  33.         System.out.println(ctc.f(new House()));  

  34.           

  35.         ClassTypeCapture<House> ctc2=  

  36.                 new ClassTypeCapture<House>(House.class);   

  37.         //House is building 子对比父=false  

  38.         System.out.println(ctc2.f(new Building()));  

  39.         System.out.println(ctc2.f(new House()));  

  40.           

  41.     }  

  42.   

  43. }  

  44. /** 

  45. output: 

  46. true 

  47. true 

  48. false 

  49. true 

  50. */  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2. /** 

  3.  * 创建类型实例 

  4.  *  

  5.  * @author lenovo 

  6.  * 

  7.  */  

  8.   

  9. class ClassAsFactory<T>  

  10. {  

  11.      T x;  

  12.      public ClassAsFactory(Class<T> kind)  

  13.      {  

  14.          try {  

  15.             x=kind.newInstance();  

  16.         } catch (Exception e)   

  17.         {  

  18.             e.printStackTrace();  

  19.         }   

  20.      }  

  21. }  

  22.   

  23. ////////////////////////////////////  

  24. class Employee{}  

  25.   

  26. public class InstantiateGenericType {  

  27.     public static void main(String[] args)   

  28.     {  

  29.         ClassAsFactory<Employee> caf=  

  30.                 new ClassAsFactory<Employee>(Employee.class);  

  31.         System.out.println("caf:"+caf.x);  

  32.           

  33.         /*try { 

  34.          //Integer 没有默认的构造器 

  35.             ClassAsFactory<Integer> cafInt= 

  36.                     new ClassAsFactory<Integer>(Integer.class); 

  37.         } catch (Exception e) { 

  38.             System.out.println("ClassAsFactory<Integer> failed"); 

  39.         }*/  

  40.       

  41.           

  42.           

  43.     }  

  44.       

  45.   

  46. }  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2.   

  3. interface FactoryI<T>  

  4. {  

  5.     T create();  

  6. }  

  7.   

  8. class Foo2<T>  

  9. {  

  10.     private T x;  

  11.     public <F extends FactoryI<T>> Foo2(F f)  

  12.     {  

  13.         x=f.create();  

  14.     }  

  15. }  

  16.   

  17. ///////////////////////////////////////////////////////////////////  

  18. class IntegerFactory implements FactoryI<Integer>  

  19. {  

  20.     public Integer create()   

  21.     {  

  22.         return new Integer(0);  

  23.     }  

  24.       

  25. }  

  26. ///////////////////////////////////////////////////////////////////  

  27. class Widget  

  28. {  

  29.   public static class Factory implements FactoryI<Widget>  

  30.   {  

  31.         public Widget create()  

  32.         {  

  33.             return new Widget();  

  34.         }  

  35.    }      

  36. }  

  37. ///////////////////////////////////////////////////////////////////  

  38. public class FactoryConstraint {  

  39.     public static void main(String[] args)   

  40.     {  

  41.         new Foo2<Integer>(new IntegerFactory());  

  42.         new Foo2<Widget>(new Widget.Factory());  

  43.     }  

  44. }  


[java] view plain copy

  1. package org.rui.generics.erasure;  

  2.   

  3. import java.util.ArrayList;  

  4. import java.util.Arrays;  

  5. import java.util.HashMap;  

  6. import java.util.List;  

  7. import java.util.Map;  

  8.   

  9. class Frob{}  

  10. class Fnorkle{}  

  11. class Quark<Q>{}  

  12. class Particle<POSITION,MOMENTUM>{};  

  13. /** 

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

  15.  * 在泛型代码内部,无法获得任何有关泛型 参数类型信息 

  16.  * @author lenovo 

  17.  * 

  18.  */  

  19.   

  20. public class LostInformation {  

  21.      public static void main(String[] args)  

  22.      {  

  23.          List<Frob> list=new ArrayList<Frob>();  

  24.          Map<Frob,Fnorkle> map=new HashMap<Frob,Fnorkle>();  

  25.          Quark<Fnorkle> quark=new Quark<Fnorkle>();  

  26.          Particle<Long,Double> p=new Particle<Long,Double>();  

  27.            

  28.          System.out.println(Arrays.toString(  

  29.                  list.getClass().getTypeParameters()));  

  30.            

  31.          System.out.println(Arrays.toString(  

  32.                  map.getClass().getTypeParameters()));  

  33.            

  34.          System.out.println(Arrays.toString(  

  35.                  quark.getClass().getTypeParameters()));  

  36.            

  37.          System.out.println(Arrays.toString(  

  38.                  p.getClass().getTypeParameters()));  

  39.      }  

  40. }  

  41. /*output: 

  42. [E] 

  43. [K, V] 

  44. [Q] 

  45. [POSITION, MOMENTUM] 

  46. */  

打赏

未经允许不得转载:同乐学堂 » java泛型擦除的补偿

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

特别的技术,给特别的你!

联系QQ:1071235258QQ群:226134712
error: Sorry,暂时内容不可复制!