泛型

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

 1 定义一个数组只能存放字符串：ArrayList<String> collection = new ArrayList<String>(); //给编译器说明此数组只能存储字符串

//     collection.add(1); 错

//     collection.add(2L);错

       collection.add("abc");

       String element = collection.get(0);

       System.out.println(element);

 

2  ArrayList<Integer> collection1 = new ArrayList();

       System.out.println(collection1.getClass()==collection.getClass());// 返回true 说明泛型经编译成class为文件后无保留，在运行时无泛型，说明泛型只给编译器看

3  用光反射的方式给之能存数整形的数组泛型 存储Object字符，这样可以透过编译器

collection1.getClass().getMethod("add",Object.class).invoke(collection1,"abcd");

       System.out.println(collection1.get(0));

4                 参数化类型不考虑类型参数的继承关系：

    Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错，写了就是明知故犯

Vector<Object> v = new Vector<String>(); //也错误!

 

Vector v1 = new Vector<String>();

Vector<Object> v = v1;  这种可以，编译器是严格按照语法检查的，一行一行的检查

5                 定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据

   

6                 泛型集合的综合应用

     HashMap<String,Integer> hashmap = new HashMap();

       hashmap.put("xiaoming", 22);

       hashmap.put("xiaohong", 20);

       Set<Map.Entry<String,Integer>> entryset  =hashmap.entrySet();

       for(Map.Entry<String,Integer> Entry : entryset){

           System.out.println(Entry.getKey() + ":" + Entry.getValue());

       } 

7                 自定义泛型的方法和应用

定义任何类型的两个数相加的操作，只是理解一下泛型的一定方法

 public static <T> T add( T x,T y){

       return null; //不能实现加法功能

    }

  运用此方法：int x1 = add(3,5);//取他们的交集作为返回类型

             Number x2 = add(3,3.5);

                    Object x3 = add(3,"abc");

   再定义一个数组，实现任意连个数的交换

        public static <T>void swap(T[] a, int i,int j){

       T temp = a[i];

       a[i] = a[j];

       a[j] = temp;

       for(int i1=0;i1<a.length;i1++)

       System.out.println(a[i1]);

              }

  运用此方法时： swap(new String[]{"abc","xyz","123"},1,2);//只有引用类型才能作为泛型方法的实际参数

// swap(new int[]{3,5,7},1,2); int不是引用类型 ，编译器会报错

也可以用泛型表示异常，成为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。

例如：private static <T extends Exception> sayHello() throws T

{

try{

 

}catch(Exception e){

   throw (T)e;

}

}

8           类型参数的类型推断：

l         根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

Ø       当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

   swap(new String[3],3,4)   à    static <E> void swap(E[] a, int i, int j)

Ø       当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

   add(3,5)   à static <T> T add(T a, T b)

Ø       当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

   fill(new Integer[3],3.5f)   à static <T> void fill(T[] a, T v)

Ø       当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型， 并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

   int x =(3,3.5f)   à static <T> T add(T a, T b)

Ø       参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

  copy(new Integer[5],new String[5]) à static <T> void copy(T[] a,T[]  b);

  copy(new Vector<String>(), new Integer[5]) à static <T> void copy(Collection<T> a , T[] b);

9           定义类级别的泛型

   public class GenericDao <E>{

     

    public void add(E obj){

      

    }

    public E findByid(int id){

       return null;

    }

    public E findByid(E obj){

       return null;

    }

    public void delete(E obj){

      

    }

    public  void update(E obj){

      

    }

}

  使用时要规定创建该类名时需要存放什么类型的数据，从而运用了类级别的泛型，使返回值保持同一个类型           最后是要注意的几点： 1 在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

2 当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数

10  通过反射获得泛型的参数化类型

     因为泛型是给编译器看，转换成Clas文件之后就不存在了，所以通过实例变量.getClass不能获取泛型的类型，则要通过方法，获取方法中的参数类型，从而获取泛型的参数化类型

 package com.itcast.day2;

 

import java.lang.reflect.Method;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.Date;

import java.util.Vector;

          public class GenericTest1 {

     public static void main(String[] args) throws Exception{

Method applymethod = GenericTest1.class.getMethod("applyVector",Vector.class);//通过反射获得参数化类型

      Type []types = applymethod.getGenericParameterTypes();

      System.out.println(types[0]);

      ParameterizedType PType = (ParameterizedType) types[0];

System.out.println(PType.getRawType());//返回 Type 对象，表示声明此类型的类或接口

System.out.println(PType.getActualTypeArguments()[0]);//返回表示此类型实际类型参数的 Type 对象的数组。

  }

     public static void applyVector(Vector<Date> v1){

       }

｝

｝