Java泛型-Java参数化类型.doc

Java泛型资料一：泛型是JAVA SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。JAVA语言引入泛型的好处是安全简单。在JAVA SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。泛型在使用中还有一些规则和限制： 1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。 2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。 3、泛型的类型参数可以有多个。 4、泛型的参数类型可以使用extends语句，例如。习惯上成为“有界类型”。 5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName(java.lang.String); 例一：使用了泛型： 查看复制到剪切板打印1. publicclassGen 2. privateTob;/定义泛型成员变量 3. 4. publicGen(Tob) 5. this.ob=ob; 6. 7. 8. publicTgetOb() 9. returnob; 10. 11. 12. publicvoidsetOb(Tob) 13. this.ob=ob; 14. 15. 16. publicvoidshowTyep() 17. System.out.println(T的实际类型是:+ob.getClass().getName(); 18. 19. 20. 21. publicclassGenDemo 22. publicstaticvoidmain(Stringargs) 23. /定义泛型类Gen的一个Integer版本 24. GenintOb=newGen(88); 25. intOb.showTyep(); 26. inti=intOb.getOb(); 27. System.out.println(value=+i); 28. 29. System.out.println(-); 30. 31. /定义泛型类Gen的一个String版本 32. GenstrOb=newGen(HelloGen!); 33. strOb.showTyep(); 34. Strings=strOb.getOb(); 35. System.out.println(value=+s); 36. 37. public class Gen private T ob; /定义泛型成员变量 public Gen(T ob) this.ob = ob; public T getOb() return ob; public void setOb(T ob) this.ob = ob; public void showTyep() System.out.println(T的实际类型是: + ob.getClass().getName(); public class GenDemo public static void main(String args) /定义泛型类Gen的一个Integer版本 Gen intOb=new Gen(88); intOb.showTyep(); int i= intOb.getOb(); System.out.println(value= + i); System.out.println(-); /定义泛型类Gen的一个String版本 Gen strOb=new Gen(Hello Gen!); strOb.showTyep(); String s=strOb.getOb(); System.out.println(value= + s); 例二：没有使用泛型时：查看复制到剪切板打印1. publicclassGen2 2. privateObjectob;/定义一个通用类型成员 3. 4. publicGen2(Objectob) 5. this.ob=ob; 6. 7. 8. publicObjectgetOb() 9. returnob; 10. 11. 12. publicvoidsetOb(Objectob) 13. this.ob=ob; 14. 15. 16. publicvoidshowTyep() 17. System.out.println(T的实际类型是:+ob.getClass().getName(); 18. 19. 20. 21. 22. publicclassGenDemo2 23. publicstaticvoidmain(Stringargs) 24. /定义类Gen2的一个Integer版本 25. Gen2intOb=newGen2(newInteger(88); 26. intOb.showTyep(); 27. inti=(Integer)intOb.getOb(); 28. System.out.println(value=+i); 29. 30. System.out.println(-); 31. 32. /定义类Gen2的一个String版本 33. Gen2strOb=newGen2(HelloGen!); 34. strOb.showTyep(); 35. Strings=(String)strOb.getOb(); 36. System.out.println(value=+s); 37. 38. public class Gen2 private Object ob; /定义一个通用类型成员 public Gen2(Object ob) this.ob = ob; public Object getOb() return ob; public void setOb(Object ob) this.ob = ob; public void showTyep() System.out.println(T的实际类型是: + ob.getClass().getName(); public class GenDemo2 public static void main(String args) /定义类Gen2的一个Integer版本 Gen2 intOb = new Gen2(new Integer(88); intOb.showTyep(); int i = (Integer) intOb.getOb(); System.out.println(value= + i); System.out.println(-); /定义类Gen2的一个String版本 Gen2 strOb = new Gen2(Hello Gen!); strOb.showTyep(); String s = (String) strOb.getOb(); System.out.println(value= + s); 运行结果：两个例子运行Demo结果是相同的,控制台输出结果如下： T的实际类型是: java.lang.Integer value= 88-T的实际类型是: java.lang.String value= Hello Gen! Process finished with exit code 0 补充：实际上泛型可以用得很复杂，复杂到编写代码的人员自己也难以看懂。这往往是对泛型的滥用或者类或接口本身设计不合理导致的。看来用好泛型还真不容易，为此必须从根源说起。一、逐渐深入泛型1、没有任何重构的原始代码：有两个类如下，要构造两个类的对象，并打印出各自的成员x。 查看复制到剪切板打印1. publicclassStringFoo 2. privateStringx; 3. 4. publicStringFoo(Stringx) 5. this.x=x; 6. 7. 8. publicStringgetX() 9. returnx; 10. 11. 12. publicvoidsetX(Stringx) 13. this.x=x; 14. 15. 16. 17. publicclassDoubleFoo 18. privateDoublex; 19. 20. publicDoubleFoo(Doublex) 21. this.x=x; 22. 23. 24. publicDoublegetX() 25. returnx; 26. 27. 28. publicvoidsetX(Doublex) 29. this.x=x; 30. 31. public class StringFoo private String x; public StringFoo(String x) this.x = x; public String getX() return x; public void setX(String x) this.x = x; public class DoubleFoo private Double x; public DoubleFoo(Double x) this.x = x; public Double getX() return x; public void setX(Double x) this.x = x; 2、对上面的两个类进行重构，写成一个类：因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了，实际上就是“Object泛型”，暂时这么称呼。 查看复制到剪切板打印1. publicclassObjectFoo 2. privateObjectx; 3. 4. publicObjectFoo(Objectx) 5. this.x=x; 6. 7. 8. publicObjectgetX() 9. returnx; 10. 11. 12. publicvoidsetX(Objectx) 13. this.x=x; 14. 15. public class ObjectFoo private Object x; public ObjectFoo(Object x) this.x = x; public Object getX() return x; public void setX(Object x) this.x = x; 写出Demo方法如下： 查看复制到剪切板打印1. publicclassObjectFooDemo 2. publicstaticvoidmain(Stringargs) 3. ObjectFoostrFoo=newObjectFoo(HelloGenerics!); 4. ObjectFoodouFoo=newObjectFoo(newDouble(33); 5. ObjectFooobjFoo=newObjectFoo(newObject(); 6. 7. System.out.println(strFoo.getX=+(String)strFoo.getX(); 8. System.out.println(douFoo.getX=+(Double)douFoo.getX(); 9. System.out.println(objFoo.getX=+(Object)objFoo.getX(); 10. 11. public class ObjectFooDemo public static void main(String args) ObjectFoo strFoo = new ObjectFoo(Hello Generics!); ObjectFoo douFoo = new ObjectFoo(new Double(33); ObjectFoo objFoo = new ObjectFoo(new Object(); System.out.println(strFoo.getX=+(String)strFoo.getX(); System.out.println(douFoo.getX=+(Double)douFoo.getX(); System.out.println(objFoo.getX=+(Object)objFoo.getX(); 运行结果如下： strFoo.getX=Hello Generics!douFoo.getX=33.0 objFoo.getX=java.lang.Object19821f 解说：在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法。 3、Java5泛型来实现 强制类型转换很麻烦，我还要事先知道各个Object具体类型是什么，才能做出正确转换。否则，要是转换的类型不对，比如将“Hello Generics!”字符串强制转换为Double,那么编译的时候不会报错，可是运行的时候就挂了。那有没有不强制转换的办法-有，改用 Java5泛型来实现。 查看复制到剪切板打印1. publicclassGenericsFoo 2. privateTx; 3. 4. publicGenericsFoo(Tx) 5. this.x=x; 6. 7. 8. publicTgetX() 9. returnx; 10. 11. 12. publicvoidsetX(Tx) 13. this.x=x; 14. 15. 16. 17. publicclassGenericsFooDemo 18. publicstaticvoidmain(Stringargs) 19. GenericsFoostrFoo=newGenericsFoo(HelloGenerics!); 20. GenericsFoodouFoo=newGenericsFoo(newDouble(33); 21. GenericsFooobjFoo=newGenericsFoo(newObject(); 22. 23. System.out.println(strFoo.getX=+strFoo.getX(); 24. System.out.println(douFoo.getX=+douFoo.getX(); 25. System.out.println(objFoo.getX=+objFoo.getX(); 26. 27. public class GenericsFoo private T x; public GenericsFoo(T x) this.x = x; public T getX() return x; public void setX(T x) this.x = x; public class GenericsFooDemo public static void main(String args) GenericsFoo strFoo=new GenericsFoo(Hello Generics!); GenericsFoo douFoo=new GenericsFoo(new Double(33); GenericsFoo objFoo=new GenericsFoo(new Object(); System.out.println(strFoo.getX=+strFoo.getX(); System.out.println(douFoo.getX=+douFoo.getX(); System.out.println(objFoo.getX=+objFoo.getX(); 运行结果： strFoo.getX=Hello Generics! douFoo.getX=33.0 objFoo.getX=java.lang.Object19821f 和使用“Object泛型”方式实现结果的完全一样，但是这个Demo简单多了，里面没有强制类型转换信息。 下面解释一下上面泛型类的语法： 使用来声明一个类型持有者名称，然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。当然T仅仅是个名字，这个名字可以自行定义。class GenericsFoo 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsFoo。与Object泛型类相比，使用泛型所定义的类在声明和构造实例的时候，可以使用“”来一并指定泛型类型持有者的真实类型。类如 GenericsFoo douFoo=new GenericsFoo(new Double(33);当然，也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型，但是你在使用该对象的时候，就需要强制转换了。比如：GenericsFoo douFoo=new GenericsFoo(new Double(33);实际上，当构造对象时不指定类型信息的时候，默认会使用Object类型，这也是要强制转换的原因。二、泛型的高级应用1、限制泛型的可用类型在上面的例子中，由于没有限制class GenericsFoo类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做： class GenericsFoo，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。 注意：这里的限定使用关键字 extends，后面可以是类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。 下面继续对上面的例子改进，我只要实现了集合接口的类型： 查看复制到剪切板打印1. publicclassCollectionGenFoo 2. privateTx; 3. 4. publicCollectionGenFoo(Tx) 5. this.x=x; 6. 7. 8. publicTgetX() 9. returnx; 10. 11. 12. publicvoidsetX(Tx) 13. this.x=x; 14. 15. public class CollectionGenFoo private T x; public CollectionGenFoo(T x) this.x = x; public T getX() return x; public void setX(T x) this.x = x; 实例化的时候可以这么写： 查看复制到剪切板打印1. publicclassCollectionGenFooDemo 2. publicstaticvoidmain(Stringargs) 3. CollectionGenFoolistFoo=null; 4. listFoo=newCollectionGenFoo(newArrayList(); 5. 6. /出错了,不让这么干。 7. /CollectionGenFoolistFoo=null; 8. /listFoo=newCollectionGenFoo(newArrayList(); 9. 10. System.out.println(实例化成功!); 11. 12. public class CollectionGenFooDemo public static void main(String args) CollectionGenFoo listFoo = null; listFoo = new CollectionGenFoo(new ArrayList(); /出错了,不让这么干。/ CollectionGenFoo listFoo = null;/ listFoo=new CollectionGenFoo(new ArrayList(); System.out.println(实例化成功!); 当前看到的这个写法是可以编译通过，并运行成功。可是注释掉的两行加上就出错了，因为这么定义类型的时候，就限定了构造此类实例的时候T是确定的一个类型，这个类型实现了Collection接口，但是实现 Collection接口的类很多很多，如果针对每一种都要写出具体的子类类型，那也太麻烦了，我干脆还不如用Object通用一下。别急，泛型针对这种情况还有更好的解决方案，那就是“通配符泛型”。 2、通配符泛型 为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，针对上面的例子，使用通配泛型格式为，“？”代表未知类型，这个类型是实现Collection接口。那么上面实现的方式可以写为： 查看复制到剪切板打印1. publicclassCollectionGenFooDemo 2. publicstaticvoidmain(Stringargs) 3. CollectionGenFoolistFoo=null; 4. listFoo=newCollectionGenFoo(newArrayList(); 5. 6. /现在不会出错了 7. CollectionGenFoolistFoo1=null; 8. listFoo=newCollectionGenFoo(newArrayList(); 9. 10. System.out.println(实例化成功!); 11. 12. public class CollectionGenFooDemo public static void main(String args) CollectionGenFoo listFoo = null; listFoo = new CollectionGenFoo(new ArrayList(); /现在不会出错了 CollectionGenFoo listFoo1 = null; listFoo=new CollectionGenFoo(new ArrayList(); System.out.println(实例化成功!); 注意： 1、如果只指定了，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。 2、通配符泛型不单可以向下限制，如，还可以向上限制，如，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。 3、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都泛型类中泛型的使用规则类似。 三、泛型的综合运用实例（代码参考java参考大全，有改动） 查看复制到剪切板打印1. publicclassAvgGen 2. publicAvgGen() 3. 4. 5. publicdoublegetAvg(Tarr) 6. doublesum=0.0; 7. for(inti=0;iarr.length;i+) 8. sum=sum+arri.doubleValue(); 9. 10. returnsum/arr.length; 11. 12. 13. publicstaticvoidmain(Stringargs) 14. /整形数组求均值 15. System.out.println(整形数组1,3求均值:); 16. IntegerintArr=1,3; 17. AvgGenintObj=newAvgGen(); 18. doubleintavg=intObj.getAvg(intArr); 19. System.out.println(intavg); 20. System.out.println(); 21. /浮点型数组求均值 22. System.out.println(浮点型数组1.1f,2.9f求均值:); 23. FloatfArr=1.1f,2.9f; 24. AvgGenfObj=newAvgGen(); 25. doublefavg=fObj.getAvg(fArr); 26. System.out.println(favg); 27. 28. 29. 30. /* 31. *CreatedbyIntelliJIDEA.User:leizhiminDate:2007-9-18Time:11:08:14使用通配符泛型参数：泛型参数是可变的，可在运行时来确定。 32. */33. publicclassAvgCompGen 34. privateTarr; 35. 36. /* 37. *构造函数 38. * 39. *paramarr 40. */41. publicAvgCompGen(Tarr) 42. this.arr=arr; 43. 44. 45. /* 46. *求数组均值 47. * 48. *return数组均值 49. */50. publicdoublegetAvg() 51. doublesum=0.0; 52. for(inti=0;iarr.length;i+) 53. sum+=arri.doubleValue(); 54. 55. returnsum/arr.length; 56. 57. 58. /* 59. *比较数组均值是否相等(使用通配符泛型参数)AvgCompGen表示可以匹配任意的AvgCompGen对象，有点类似Object 60. * 61. *paramx目标对象 62. *return均值是否相等 63. */64. publicbooleansameAvg(AvgCompGenx) 65. if(getAvg()=x.getAvg() 66. returntrue; 67. returnfalse; 68. 69. 70. /* 71. *主函数：用来测试 72. * 73. *paramargs 74. */75. publicstaticvoidmain(Stringargs) 76. /创建参数为Integer类型泛型对象 77. IntegerintArr=1,3; 78. AvgCompGenintObj=newAvgCompGen(intArr); 79. System.out.println(intObj的平均值=+intObj.getAvg(); 80. /创建参数为Double类型泛型对象 81. DoubledouArr=1.0,3.0; 82. AvgCompGendouObj=newAvgCompGen(douArr); 83. System.out.println(douObj的平均值=+douObj.getAvg(); 84. /创建参数为Float类型泛型对象 85. FloatfltArr=0.8f,3.2f; 86. AvgCompGenfltObj=newAvgCompGen(fltArr); 87. System.out.println(fltObj的平均值=+fltObj.getAvg(); 88. /两两比较对象的均值是否相等 89. if(intObj.sameAvg(douObj) 90. System.out.println(intArr与douArr的值相等,结果为:+intObj的均值=+intObj.getAvg() 91. +douObj的均值=+douObj.getAvg(); 92. else93. System.out.println(intArr与douArr的值不相等,结果为:+intObj的均值=+intObj.getAvg() 94. +douObj的均值=+douObj.getAvg(); 95. if(intObj.sameAvg(fltObj) 96. System.out.println(intArr与fltObj的值相等,结果为:+intObj的均值=+intObj.getAvg() 97. +fltObj的均值=+fltObj.getAvg(); 98. else99. System.out.println(intArr与fltObj的值不相等,结果为:+intObj的均值=+intObj.getAvg() 100. +fltObj的均值=+fltObj.getAvg(); 101. if(douObj.sameAvg(fltObj) 102. System.out.println(douObj与fltObj的值相等,结果为:+douObj的均值=+intObj.getAvg() 103. +fltObj的均值=+fltObj.getAvg(); 104. else105. System.out.println(douObj与fltObj的值不相等,结果为:+douObj