泛型的使用
1. 在集合中使用泛型
2.在定义泛型类，泛型接口，泛型方法
3.泛型于继承的关系
4.通配符
注意：1.不可以在static方法中使用泛型的声明，因为静态方法的加载随着类的加载而加载，
泛型是在创建实例的时候加载的(晚)。
2.不能在try-catch中使用类的泛型的声明
try{
}catch（T e）{
}
TestGeneric
package com.aff.Gen; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.junit.Test; /* 泛型的使用 1. 在集合中使用泛型 2.在定义泛型类，泛型接口，泛型方法 3.泛型于继承的关系 4.通配符 */ public class TestGeneric { // 集合中没有使用泛型的情况下 @Test public void test1() { List list = new ArrayList(); list.add(23); list.add(35); list.add(56); list.add(new String("aa")); for (int i = 0; i < list.size(); i++) { int score = (Integer) list.get(i); System.out.println(score); } } // 1在集合中使用泛型 @Test public void test2() { List<Integer> list = new ArrayList<Integer>(); list.add(23); list.add(35); // list.add(new String("aa"));//添加不进去会报错的 // for (int i = 0; i < list.size(); i++) { // System.out.println(list.get(i)); // } Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } // 泛型的使用 @Test public void test3() { Map<String, Integer> map = new HashMap<String, Integer>(); map.put("aa", 23); map.put("bb", 33); map.put("cc", 6543); map.put("dd", 276); Set<Map.Entry<String, Integer>> set = map.entrySet(); for (Map.Entry<String, Integer> o : set) { System.out.println(o.getKey() + "----->" + o.getValue()); } } // 自定义泛型类的使用 @Test public void test4() { /* * 1.实例化泛型类的对象时，指明泛型的类型 指明以后，对应的类中所有使用泛型的位置，
都变为实例化中指定的泛型的类型 * 2.如果我们自定义了泛型类，但是实例化时没有使用，那么默认类型是Object类的 */ Order<Boolean> order = new Order<Boolean>(); // order.getT(); order.setT(true); System.out.println(order.getT()); order.add(); List<Boolean> list = order.list; System.out.println(list); SubOrder o = new SubOrder(); List<Integer> list1 = o.list; System.out.println(list1); // 通过对象调用泛型方法时，指明泛型方法的类型 Integer i = order.getE(23); double d = order.getE(3.8); Integer[] in = new Integer[] { 1, 12, 3, 3 }; List<Integer> list2 = new ArrayList<Integer>(); List<Integer> list3 = order.fromArrayToList(in, list2); System.out.println(list3); } // 泛型于继承的关系 //若类A是类B的子类，那么List<A> 就不是List<B>的子接口 /* 通配符 ? List<A> ,List<B>... 都是List<?>的子类 ？ extends A 可以存放A及其A的子类 ？ super A 可以存放A及其A的父类 */ @Test public void test5() { //泛型于继承的关系 Object obj = null; String str = "AA"; obj = str; Object[] obj1 = null; String[] str1 = new String[]{"AA","CV","SV"}; obj1 = str1; List<Object> list10 = null; List<String> list11 = new ArrayList<String>(); //list10 = list11; //执行不通过，list11不是list10的子接口 // 通配符 ? List<?> list = null; List<Object> list1 = new ArrayList<Object>(); List<Object> list2 = new ArrayList<Object>(); list = list1; list= list2; show(list1); show1(list1); show1(list2);
List<?> list20 = list1;
//读取声明为通配符的集合类的对象
Iterator<?> iterator = list20.iterator();
while(iterator.hasNext()){
system.out.println(iterator.next());
}
//不允许向声明为通配符的集合类中写入对象，唯一列外的是null
list20.add();
List<? extends Number> list3 = null; List<Integer> list4 = null; list3 = list4; List<? super Number> list5 = null;//super Number 为Object 所以和list1一致了 list5 = list1;
} public void show(List<Object> list){ } public void show1(List<?> list){ } }
Order<T>
package com.aff.Gen; import java.util.ArrayList; import java.util.List; public class Order<T> { private String orderName; private int orderId; private T t; List<T> list = new ArrayList<T>(); public void add() { list.add(t); } // 实现数组到集合的复制 public <E> List<E> fromArrayToList(E[] e, List<E> list) { for (E e1 : e) {// 数组 list.add(e1);// 数组到集合 } return list; } // 声明泛型方法 public <E> E getE(E e) { return e; } public String getOrderName() { return orderName; } public void setOrderName(String orderName) { this.orderName = orderName; } public int getOrderId() { return orderId; } public void setOrderId(int orderId) { this.orderId = orderId; } public T getT() { return t; } public void setT(T t) { this.t = t; } @Override public String toString() { return "Order [orderName=" + orderName + ", orderId=" + orderId + ", t=" + t + ", list=" + list + "]"; } } // 在继承泛型类或者泛型接口时，可以指明泛型的类型 class SubOrder extends Order<Integer> { }