------- android培训、java培训、期待与您交流！ ----------
泛型(Generic)
在JDK1.5版本中Java提供了泛型的概念，泛型实质上就是使程序员定义安全的类型。在没有出现泛型之前，Java也提供了对Object的引用“任意化”操作，这种任意化操作就是对Object引用进行“向下转型”及“向上转型”操作，但某些强制类型转换的错误也许不会被编译器捕捉，而在运行后出现异常，可见强制类型转换存在安全隐患，所以由此提供了泛型机制。
泛型的好处 :
1. 把运行时的异常转到了编译时期。
2. 避免了程序员强制类型的转换。
没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可
以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集
合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换。如果存储的
元素不是指定的类型，那么编译将会报错，把运行时的问题转换到了编译时期。
代码示例：
<span style="color:#000000;">package com.itheima.test; import java.lang.reflect.Constructor; public class GenericTest { public static void main(String[] args) throws Exception{ Constructor<String> constructor = String.class.getConstructor(StringBuffer.class); String str = constructor.newInstance( new StringBuffer("黑马程序员")); System.out.println(str); }</span><span style="color:#000000;">}</span>
什么时候定义泛型？
当我们定义方法的时候，由于不知道调用者会传入什么样的参数，这时候我们就可以定义泛型，
但是当调用者在使用方法的时候，肯定知道自己需要传入什么样类型的参数，所以当调用者调用的时候，就要传入
具体的引用数据类型。
（不传入泛型的时候，那默认的类型就是Object）
泛型的内部原理及更深应用
泛型是提供给Javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入。
但是，编译器编译带类型说明的集合时会去除掉“类型”信息，目的就是使程序运行效率不受影响。
因此，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。（也称泛型的擦除）。
代码示例：<span style="font-size:14px;"><span style="color:#000000;">package com.itheima.test; import java.util.ArrayList; public class GenericTest { public static void main(String[] args) throws Exception { ArrayList<String> collection1 =new ArrayList<String>(); ArrayList<Integer> collection2 =new ArrayList<Integer>(); System.out.println(collection1.getClass()==collection2.getClass()); } } </span> </span>由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数
据，例如，用反射得到集合，再调用其add方法即可。 代码示例：
<span style="font-size:14px;"><span style="color:#000000;">package com.itheima.test; import java.util.ArrayList; public class GenericTest { public static void main(String[] args) throws Exception{ ArrayList<Integer> collection1 =new ArrayList<Integer>(); collection1.add(null); collection1.getClass().getMethod("add",Object.class) .invoke(collection1,"黑马程序员"); System.out.println(collection1); } </span><span style="color:#000000;">} </span></span>
泛型的通配符：
当我们定义类，方法（参数）不确定的时候，可以用？来表示。
例如：
public void getId（<?> e）{}
由于在方法中，传入的数据类型不确定，所以用到了泛型，但是在调用的时候，调用者肯定知道。
如：
int i = 98;
getId(i);
String s ="98";
getId(s);
这个方法可以接受任意类型的参数但是在说泛型定义，自己有没有觉得不合适呢？
有，因为泛型就是要限制传递参数类型的，但是又可以接收任意的类型。
但是呢，有时候我们需要的是把一个体系全部的纳入到泛型之中，这时候该怎么做呢？
通配符，我们可以通过继承来实现。（所以就有了泛型的限定）
代码示例：
<span style="font-size:14px;"><span style="color:#000000;">package com.itheima.test; import java.util.ArrayList; import java.util.Collection;</span></span><span style="font-size:14px;"><span style="color:#000000;">public class GenericTest { public static void main(String[] args) throws Exception { ArrayList<String> list =new ArrayList<String>(); list.add(null); printCollection(list); } public static void printCollection(Collection<?> collection) { for (Object obj : collection) { System.out.println(obj); } collection.add(null); /* * 当然了集合存储的是对象，每个对象都有一个值 就是null， * 所以，调用add方法没有报错。 */ //System.out.println(collection.add(1)); /* * 如果添加明确的类型，那么将会报错。 */ System.out.println(collection.size()); } </span><span style="color:#000000;">} </span></span><span style="color:#000000;"> </span>Java 5.0中使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用。
此时，printCollection方法中可以调用与参数化无关的方法，不能调用与参数化有关的方法。
例如：Collection类中的add(E e)方法就与参数化有关，不能调用。size()方法与参数化无关就可以调用。
泛型的限定
限定通配符的上边界：
正确：Vector<? extends Number> v = new Vector<Integer>();
错误：Vector<? extends Number>v = new Vector<String>();
限定通配符的下边界：
正确：Vector<? super Integer>v =new Vector<Number>();
错误：Vector<? super Integer>v =new Vector<Byte>();
注意：限定通配符总是包括自己。
泛型上限
<? extends Collection>这被我们称之为上限，因为只能作用到其最顶层（父类），
通过这样的定义，可以把其子类当做参数来传递，这主要使用在添加的。
因为在取出的时候方便，不用再进行类型的判断。
泛型下限既然有了上限：那么自然的就会有下限。
<? super Comparable > 这就是下限，通常用来进行比较。比较的时候既可以使用自己的比较器，也可以使用父类的比较器。
泛型集合类的综合案例
1.使用迭代器迭代泛型集合中的元素。
2.使用增强for循环迭代泛型集合中的元素。
3.获取泛型集合中的元素进行操作。
<span style="font-size:14px;"><span style="color:#000000;">package com.itheima.test; import java.util.HashMap; import java.util.Map; import java.util.Set; public class GenericTest { public static void main(String[] args) { HashMap<String, Integer> map = hashMap(); forEach_KeySet(map); forEach_Map_Entry(map); } private static HashMap<String,Integer> hashMap() { HashMap<String,Integer> map = new HashMap<String,Integer>(); map.put("黑马程序员——小李", 21); map.put("黑马程序员——小王", 19); map.put("黑马程序员——小张", 22); return map; } private static void forEach_KeySet(HashMap<String, Integer> map) { Set<String> keySet = map.keySet(); for (String key : keySet) { System.out.println(key+":"+map.get(key)); } } private static void forEach_Map_Entry(HashMap<String, Integer> map) { Set<Map.Entry<String,Integer>> entrySet = map.entrySet(); for(Map.Entry<String,Integer> entry : entrySet){ System.out.println(entry.getKey()+":"+entry.getValue()); } } <span style="color:#000000;"> </span></span><span style="color:#000000;">} </span></span>
自定义泛型方法与类型推断
编写一个泛型方法，自动将Object类型的对象转换成其他类型。
@SuppressWarnings("unchecked")
public static <T> T autoConvert(Object obj) {
return (T) obj;
}
定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。
public static <T> void fillArray(T[] arr, T obj) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
arr[i] = obj;
}
}
采用自定泛型方法的方式打印出任意参数化类型的集合中的所有内容。
public static <T> void printCollection(Collection<T> collection){
for(T t:collection){
System.out.println(t);
}
定义一个方法，把任意参数类型的数组中的数据安全地复制到相应类型的集合中。}public static <T> void copy(Collection<T> dest, T[] src) {
for (T t : src) {
dest.add(t);
}
}
定义一个方法，把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。
public static <T> void copy(T[] dest,T[] src){
for(int x=0;x<src.length;x++){
dest[x]=src[x];
}
}
注意：当在main方法执行copy(new Vector<Date>(),new String[10]);的时候就会报错，这也就涉及到了类型参数的类型推断。
编译器判断泛型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常
复杂的过程。
根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这
很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：
swap(new String[3],3,4) ---> static <E> void swap(E[] a, int x, int y)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类
型来确定，这很容易凭着感觉推断出来，例如：
add(3,5) ---> static <T> T add(T x, T y)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的
类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只
是运行时出问题：
fill(new Integer[3],3.5f) ---> static <T>void fill(T[] arr, T t)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的
类型， 并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量
x的类型改为Float，对比MyEclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
Number x =(3,3.5f) ---> static <T> T add(T x, T y)
参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的
Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(new Integer[5],new String[5]) ---> static <T>void copy(T[] x,T[] y);
copy(new Vector<String>(), new Integer[5]) ---> static <T>void copy(Collection<T> x , T[] y);
2817
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
