Java泛型--从基础到高级(少部分)

1.泛型的概念

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

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

泛型是提供给javac 编译器使用的,可以限定集合的输入类型,让编译器挡住源代码程序中的非法输入,编译器编译带类型说明的集合时会擦除"类型"信息,使程序运行效率不受影响,对于参数化的泛型类型,getClass()方法的返回值和原始类型完全一样, 由于编译器生成的字节码会去掉泛型的类型信息,只要能跳过编译器,就可以往某个泛型集合加入其它类型的数据,例如,用反射得到集合,在调用其add方法就可.

2.为何JDK1.5引入泛型

JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。例如：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

package  com.itcast.generic; import  java.util.ArrayList; import  java.util.List; import  java.util.Random;   public  class  GenericTest1 {      public  static  void  main(String[] args) {          List list =  new  ArrayList();          list.add( new  Random());          list.add( "abc" );          //运行时会出错，但编码时发现不了---throw java.lang.ClassCastException           Integer num = (Integer) list.get( 0 );        } }

而使用泛型之后：

?

1	编译器会在编译时报错,集合内只能存储java.lang.String类型的实例.

3.泛型的简单应用和了解泛型

?

1	JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。

注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。例如:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package  com.itcast.generic;   import  java.util.ArrayList; import  java.util.List;   public  class  GenericTest2 {      public  static  void  main(String[] args)  throws  Exception {          //List集合中放入java.lang.Integer类型变量          List<Integer> list =  new  ArrayList<Integer>();          list.add( 50 );          //通过字节码文件反射调用add方法加入java.lang.String类型变量          list.getClass().getMethod( "add" , Object. class ).invoke(list,  "itcast" );          System.out.println(list);      } }

?

1

测试结果:

?

1	泛形的基本术语:以ArrayList<E>为例：<>念着typeof

?

1 2 3 4 5

•ArrayList<E>中的E称为类型参数变量.  •ArrayList<Integer>中的Integer称为实际类型参数 . •整个称为ArrayList<E>泛型类型 . •整个ArrayList<Integer>称为参数化的类型ParameterizedType. •ArrayList称为原始类型.

使用泛型时需要注意的问题：

    1.参数化类型与原始类型的兼容性:

       a.参数化类型可以引用一个原始类型的对象,编译器报告警告,例如:

          Collection<String> c = new Vector();

       b.原始类型可以引用一个参数化类型的对象,编译器报告警告,例如:

         Collection c = new Vector<String>();

    2.参数化类型不考虑类型参数继承关系:

       List<String> list = new ArrayList<Object>();   //error

       List<Object> list = new ArrayList<String>();  //error

    3.使用泛形时，泛形类型须为引用类型，不能是基本数据类型

    4.在创建数组实例时,数组元素不能是参数化类型.

4.泛型的通配符扩展应用

 4.1 通配符

?

1	问题:l定义一个方法，接收一个任意集合，并打印出集合中的所有元素，如下所示：

错误方式:

?

1 2 3 4 5

void  print (Collection<Object> c) {              for  (Object e : c) {                  System.out.println(e);            } }

正确方式:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package  com.itcast.generic; import  java.util.ArrayList; import  java.util.Collection;   public  class  GenericTest3 {      public  static  void  main(String[] args) {          Collection<String> c =  new  ArrayList<String>();          Collection<Integer> c1 =  new  ArrayList<Integer>();          printCollection(c);          printCollection(c1);      }      public  static  void  printCollection(Collection<?> c){          //c.add(1);     在方法体内不能调用与类型相关的方法，例如add()方法          c.size();       //查看API,size方法与类型不相关.          for (Object obj:c){              System.out.println(obj);          }      } }

?

1 2	l.此种形式下需要注意的是：由于print方法c参数的类型为Collection<?>，即表示一种不确定的类型，因此在方法体内不  能调用与类型相关的方法，例如add()方法。 2 .总结：使用?通配符主要用于引用对象，使用了?通配符，就只能调对象与类型无关的方法，不能调用对象与类型有关的方法

 4.2 有限制的通配符

     a.限定通配符的上边界：（?必须是Number的子类）

      b.限定通配符的下边界 : （？必须是Integer的父类）

        C.限定范围总是包括自己

5.泛型的通配符扩展应用案例

?

1	遍历一个Map集合:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package  com.itcast.generic; import  java.util.HashMap; import  java.util.Map; /**   * 遍历Map集合   * @author Say   *   */ public  class  IteratorMap {      public  static  void  main(String[] args) {          Map<String,Integer> map =  new  HashMap<String, Integer>();          map.put( "itcast" ,  1 );          map.put( "flx" ,  50 );          map.put( "黑马" ,  41 );          for (Map.Entry<String, Integer> entry:map.entrySet()){              System.out.println(entry.getKey()+ "-->" +entry.getValue());          }      } }

6.自定义泛型方法

?

1	Java中的泛型没有C++中模版强大的原因： Java中泛型在编译器中实现的,生成字节码的过程当中会擦除泛型。

泛型方法定义规则:

Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前，必须对泛形进行声明，语法：<T>，T可以是任意字母，但通常必须要大写。<T>通常需放在方法的返回值声明之前。

例如：

  public static <T> void doxx(T t);

泛型方法定义注意问题:

    •只有对象类型才能作为泛型方法的实际参数。

    •在泛型中可以同时有多个类型.

  例如:

    public static <K,V> V getValue(K key) { return map.get(key);}

    public static <K extends Annotation> void getXX(){}

    public static <K extends Annotation & Cloneable> void getXX(){}

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

package  com.itcast.generic; /**   *  编写一个泛形方法，实现数组元素的交换。   */ public  class  SwapArray {      public  static  void  main(String[] args) {          //对于数组中的int类型不会自动装箱和拆箱          swap( new  String[]{ "a" , "bncd" , "fdsafdsa" },  2 ,  0 );          swap( new  Integer[]{ 15 , 25 , 30 , 25 , 47 },  2 ,  4 );      }      public  static  <T>  void  swap(T[] arr, int  x, int  y){          T temp = arr[x];          arr[x] = arr[y];          arr[y] = temp;      } }

7.自定义泛型类

  如果一个类多处都要用到同一个泛型，这时可以把泛形定义在类上（即类级别的泛型）

  语法格式如下：

  public class GenericDao<T> {

      private T field1;

      public void save(T obj){}

      public T getId(int id){}

  }

   注意: 静态方法不能使用类定义的泛形，而应单独定义泛形。先使用类级别的泛型.

    泛形的典型应用：BaseDao

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package  com.itcast.generic; import  java.util.Set;   public  class  GenericDao<T> {      public  void  add(T t){                }      public  T findById( int  id){          return  null ;      }      public  void  delete(T t){      }      public  void  update(T t){      }      public  Set<T> findByConditions(String where){          return  null ;      } }

8.通过反射获取泛型的实际类型参数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

package  com.itcast.generic;   import  java.lang.reflect.Method; import  java.lang.reflect.ParameterizedType; import  java.lang.reflect.Type; import  java.util.Date; import  java.util.List; /**   * 以泛型方法获取参数类型   */ public  class  TypeArgumentsTest {      public  static  void  main(String[] args)  throws  Exception{          //获取applyList方法对象          Method method = TypeArgumentsTest. class .getMethod( "applyList" , List. class );          //获取方法上泛型参数          Type[] types=method.getGenericParameterTypes();          ParameterizedType pType = (ParameterizedType) types[ 0 ];          //获取原始类型          System.out.println(pType.getRawType());          //获取实际类型参数          System.out.println(pType.getActualTypeArguments()[ 0 ]);      }      public  static  void  applyList(List<Date> list){      } }