JavaSE学习笔记--泛型

泛型：

泛型是java jdk1.5出现的新特性之一。

泛型是给编译看的，当传入的实参类型不符时，会在编译期报错。而反射可以绕过编译器。

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个ArrayList<E>称为泛型类型

ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

ArrayList<Integer>中的<>念做typeof

ArrayList称为原始类型

参数化类型与原始类型的兼容性：

如下面的两个都是可以的，但是编译时会出现一个警告。

Collection<String> c = new Vector();

Collection c = new Vctor<String>();

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

Collection<String> c = new Vector<Object>(); -->（错）

Collection<Object> c = new Vector<String>(); -->（错）

在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

Vector<Integer> vectorList[] = new Vector<Integer>[10];

思考一下：下面的代码会报错吗？

Vector v1 = new Vector<String>();

Vector<Object> v = v1;

上面的不会报错。

泛型中的通配符: ？

在使用通配符泛型类型作为一个方法的参数列表时，此方法体中就不能再使用和类型有关的方法。只能使用与参数类型不管的方法，否侧的话会报错。

如下：

public static void printCollection(Collection<?> collection){

//collection.add(1); (错的，不可以。因为1使用了指定的类型)

collection.size(); //可以

for(Object obj : collection){

System.out.println(obj);

} //可以

collection = new HashSet<Date>(); //可以

}（较有效）

但是此时可以使用“通配符的方法”来克服这个弊端：<T>

如下：

public static void printCollection(Collection<T> collection， T obj){

collection.add(obj); //这时，是可以的

collection.size(); //可以

for(Object obj : collection){

System.out.println(obj);

} //可以

collection = new HashSet<Date>(); //可以

｝

通配符的扩展

限制通配符的上边界：

正确： Vector<? extends Number> x = new Vector<Integer>();

错误： Vector<? extends Number> x = new Vector<String>();

限制通配符的下边界：

正确： Vector<? super Integer> x = new Vector<Number>();

错误： Vector<? super Integer> x = new Vector<Byte>();

Float x1 = add(3.5,3); ( 错 )。

此时的编译器提示信息“Type nismatch: cannot convert from Number&Comparable<?> to Float”。

所以需要实现Comparble的Number，所以只能是Number类。所以只能改成下边这样。

Number x1 = add(3.5,3);

但是问题出现了，你会发现Number类并没有实现Comparable接口，而是只实现了Serializable接口。不知道这个是怎么解释的呢？

类型推断具有传播性，通过下边的例子就可以看出来了:

copy1(new Vector<String>(), new String[10]);

copy2(new Date[10],new String[10]); //都取他们的交集类，即Object类

copy1(new Vector<Date>(),new String[10]); //此时会报错，因为此时Date被泛型修饰无法再提升到父类Object

public static <T> void copy1(Collection<T> dest, T[] src){

for(int x=0; x<src.length; x++){

dest.add(src[x]);

}

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！
----------------------

}

public static <T> void copy2(T[] dest, T src){

for(T t : dest){

t = src;

}

}

自定义泛型类（类级别的泛型）：

其目的就是当我的类中有多个方法用到的泛型都是同一个类型，

而我们有想让这两个类型相同，就可以给这个类定义上这个泛型。这也是泛型类的由来。

注意静态方法中不能使用泛型。

class Person<E>

{

public static void update(E obj){}

} (报错)

这是需要把他独立出来，单独使用“方法级别的泛型”

class Person<E>

{

public static <E> void update(E obj){}

} (对)

对于泛型，java在编译之后就会去类型化。下边的两个方法不是重载。

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

}

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

}

通过反射获取泛型的实际类型参数：（高级）

其思路是这样的，我们无法通过一个变量的数据是无法知道自己是什么类型的。

只能通过把这个变量作为一个参数传递给方法，通过泛型方法来知道参数列表中的泛型类型的。

代码如下：

//Vector<Date> v1 = new Vector<Date>();

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]);