黑马程序员--泛型的基本应用

 

 

                                              反省的基本应用

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 Vector<String>();
参数化类型不考虑类型参数的继承关系：
                       Vector<String> v=new Vector<Object>();//错误
                       Vector<Object> v=new Vector<String>();//也错误

只要是对象，不管是什么类型的对象，都可以存储金童一个集合中。使用反型集合，可以将一个集合中德元素限定为一个特定类型，
集合中只能存储同一个类型的对象，这样更安全，并且当从接种获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

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

例题：往Integer的泛型集合中添加String类型元素
                     ArrayList<Integer> collection=new ArrayList<Integer>();
                     //用正常方式往集合中添加元素
                    collection.add(1);
                     System.out.println(collection.get(0));
                       //利用反射往集合众添加String类型元素
                     collection.getClass().getMethod("add", Object.class).invoke(collection, "abc");
                       System.out.println(collection.get(1));

 

泛型中的？通配符
 
错误方式：
 public static void printCollection(Collection<？> 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.pringln(obj);
  }
  //cols.add("String");错误，因为它不知自己未来匹配就一定是String
  cols.size();//没错，此方法与类型参数没有关系
  cols=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>();
提示：
 限定通配符总是包括自己。

 

泛型的综合案例：
HashMap集合用Map.Entry来迭代
  HashMap<String,Integer> arr=new HashMap<String,Integer>();
  arr.put("zxx", 1);
  arr.put("lhn", 2);
  arr.put("hhh", 3);
  
  Set<Map.Entry<String,Integer>> entset=arr.entrySet();
  Iterator<Map.Entry<String,Integer>> it=entset.iterator();
  while (it.hasNext()) {
   Map.Entry<String,Integer> mapentry=it.next();
   System.out.println(mapentry.getKey()+"-----"+mapentry.getValue());
  }