泛型

泛型

1、入门泛型的基本应用

泛型的概念
   没有使用泛型时，不管什么类型的对象都可以存储进同一个集合中。使用泛型时，我们可以把集合中的元素限定为一个特定类型，这样

的话，该集合中只能放同一种类型的元素，会更安全，并且当从该集合中获取一个元素时，编译器知道元素的类型，就不需要进行强制类型转换，也会更方便。
泛型使用形式及举例：
ArrayList<Integer> arrInt = new ArrayList<Integer>();
表示集合中只能放Integer类型
Collection<String> collection = new ArrayList<String>();
表示里面只能放String类型的元素

 

2、泛型的内部原理及更深应用

a.ArrayList<E>类定义和ArrayList<Integer>类引用中涉及的术语：
ArrayList<E>整个称为泛型类型
ArrayList<E>中的E称为类型变量或类型参数
整个ArrayList<Integer>称为参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
ArrayList<Integer>中的<>念typeof
ArrayList称为原始类型
b.参数化类型与原始类型的兼容性
参数化类型可以引用一个原始类型的对象，编译器报告警告，例如：
Collection<String> c = new Vector();
原始类型可以引用一个参数化类型的对象，编译器报告警告，例如：
Collection c = new Vector<String>();
c.参数化类型不考虑类型参数的继承关系：
Vector<String> v = new Vector<Object>();//错误
Vectora<Object> v = new Vector<String>();//错误
d.在创建数组实例时不能使用泛型，因为一个数组在声明时必须指定其元素类型，也就是说，数组本来就是用来装同一种类型的元素的，所以数组不必也不能使用泛型。
e.下面的代码不会报错
Vector v1 = new Vector<String>();
Vector<Object> v = v1;
注意：泛型是写给编译器看的
ArrayList<String> a1 = new ArrayList<String>();
ArrayList<Integer> a2 = new ArrayList<Integer>();
这里a1.getClass = a2.getClass

3、泛型通配符？的扩展应用

问题：
定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义？
错误的方式：
public static void printCollection(Collection<Object> cols) {
for(Object obj: cols) {
System.out.println(obj);
}
cols.add("string");//没错
cols = new HashSet<Date>();//会报告错误!
}
正确的方式：
public static void printCollection(Collection<?> cols) {
for(Object obj: cols) {
System.out.println(obj);
}
cols.add("string");//错误，因为它不知道自己未来匹配的一 //定是String
cols.size();//没错，此方法与类型参数没有关系
}
注意：cols调用的方法是针对以后的实例对象的，而通配符？表示传入的实例参数可以是任何类型，对于形参cols来说它不知道以后传入的是什么类型的对象，所以cols不能调用与类型参数有关的任何方法。
className<?>
这里表示类型参数可以是任意类型
className<? extends U>
表示限定通配符的上边界，参数类型必须是U的子类包括U本身，举例：
正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();
className<? super U>
限定通配符的下边界，参数类型必须是U的父类包括U本身，举例：
正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();
提示：限定通配符总是包括自己

4、泛型集合的综合应用案例

HashMap<String,Integer> maps = new HashMap<String, Integer>();
maps.put("zxx", 28);
maps.put("lhm", 35);
maps.put("flx", 33);

Set<Map.Entry<String,Integer>> entrySet = maps.entrySet();
for(Map.Entry<String, Integer> entry : entrySet){
System.out.println(entry.getKey() + ":" + entry.getValue());
}

5、自定义泛型方法及其应用

举例：
private static <T> void swap(T[] a,int i,int j){
T tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
swap(new String[]{"abc","xyz","itcast"},1,2);
swap(new int[]{1,3,5,4,5},3,4);//会出错，里面不能传入基本类型数组
注意：
a.用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。
b.只有引用类型才能作为泛型方法的实际参数，swap(new int[3]{1,2,4},0,1);语句编译时会报告错误。
c.除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如Class.getAnnotation()方法的定义。
public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
并且可以用&来指定多个边界，如<V extends Serializable & cloneable> void method(){}
d.普通方法、构造方法和静态方法中都可以使用泛型。编译器不允许创建类型变量的数组。
e.可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。
f.在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分开，例如：
public static <K,V> V getValue(K key){return map.get(key);}

6、自定义泛型方法的练习与类型推断总结

类型推断
编译器判断泛型方法的实际类型参数的过程称为类型推断。
根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
a.当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，如：
swap(new String[3],3,4)-->static <E> void swap(E[] a, int i, int j)
b.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型，那么这相同的类型就为实际类型参数，如：
add(3,5)-->static <T> T add(T a, T b)
c.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：
fill(new Integer[3],3.5f)-->static <T> void fill(T[] a, T v)
d.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比Eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
int x = add(3,3.5f)-->static <T> T add(T a, T b)
e.参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为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);

7、自定义泛型类的应用

知识点：
dao = data access object
crud = 增删改查
a.如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义类，也就是类级别的泛型，语法形式如下：
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getById(int id){}
}
b.类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：
GenericDao<String> dao = null;
new genericDao<String>();
注意：
a.在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型；
b.当一个变量被声明为泛型时，只能被实例变量和方法调用（还有内嵌类型），而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数，如：
public static void update(E obj){}//报错
若静态方法要用泛型必须单独定义为泛型方法，这与其所在类的类型参数各自为政，不冲突，例如：
public static <E> void update(E obj){}

8、通过反射获得泛型的实际类型参数

通过实例对象本身是无法获取泛型的实际参数类型的，只有当对象作为方法的参数时才可以通过反射来
获取泛型的实际参数类型，举例：
public class GenericTest {
    public static void main(String[] args) {
        Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
        Type[] types = applyMethod.getGenericParameterTypes();
        ParameterizedType pType = (ParameterizedType)types[0];
        System.out.println(pType.getRawType());
        System.out.println(pType.getActualTypeArguments()[0]);
    }
    public static void applyVector(Vector<Date> v1){}

}