JAVA学习--泛型的使用

 1 //1.在集合中没有使用泛型的情况下
 2     @Test
 3     public void test1(){
 4         List list = new ArrayList();
 5         list.add(89);
 6         list.add(87);
 7         list.add(67);
 8         //1.没有使用泛型，任何Object及其子类的对象都可以添加进来
 9         list.add(new String("AA"));
10         
11         for(int i = 0;i < list.size();i++){
12             //2.强转为int型时，可能报ClassCastException的异常
13             int score = (Integer)list.get(i);
14             System.out.println(score);
15         }
16     }

 1  //2.在集合中使用泛型
 2     @Test
 3     public void test2(){
 4         List list = new ArrayList();
 5         list.add(78);
 6         list.add(87);
 7 //        list.add("AA");
 8        
 9 //        for(int i = 0;i < list.size();i++){
10 //            int score = list.get(i);
11 //            System.out.println(score);
12 //        }
13         Iterator it = list.iterator();
14         while(it.hasNext()){
15             System.out.println(it.next());
16         }
17     }

 1 //泛型遍历
 2 
 3     @Test
 4     public void test3(){
 5         Map map = new HashMap<>();
 6         map.put("AA", 78);
 7         map.put("BB", 87);
 8         map.put("DD", 98);
 9        
10         Set> set = map.entrySet();
11         for(Map.Entry o : set){
12             System.out.println(o.getKey() + "--->" + o.getValue());
13         }
14     }

 1 //自定义泛型类的使用
 2     @Test
 3     public void test4(){
 4         //1.当实例化泛型类的对象时，指明泛型的类型。
 5         //指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
 6         //2.如果我们自定义了泛型类，但是在实例化时没有使用，那么默认类型是Object类的
 7         Order order = new Order();
 8 //        order.getT();
 9         order.setT(true);
10         System.out.println(order.getT());
11         order.add();
12         List list = order.list;
13         System.out.println(list);
14        
15         SubOrder o = new SubOrder();
16         List list1 = o.list;
17         System.out.println(list1);
18         //当通过对象调泛型方法时，指明泛型方法的类型。
19         Integer i = order.getE(34);
20         Double d = order.getE(2.3);
21        
22         Integer[] in = new Integer[]{1,2,3};
23         List list2 = new ArrayList<>();
24         List list3 = order.fromArrayToList(in, list2);
25         System.out.println(list3);
26     }

 1 //自定义泛型类的使用
 2     @Test
 3     public void test4(){
 4         //1.当实例化泛型类的对象时，指明泛型的类型。
 5         //指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
 6         //2.如果我们自定义了泛型类，但是在实例化时没有使用，那么默认类型是Object类的
 7         Order order = new Order();
 8 //        order.getT();
 9         order.setT(true);
10         System.out.println(order.getT());
11         order.add();
12         List list = order.list;
13         System.out.println(list);
14        
15         SubOrder o = new SubOrder();
16         List list1 = o.list;
17         System.out.println(list1);
18         //当通过对象调泛型方法时，指明泛型方法的类型。
19         Integer i = order.getE(34);
20         Double d = order.getE(2.3);
21        
22         Integer[] in = new Integer[]{1,2,3};
23         List list2 = new ArrayList<>();
24         List list3 = order.fromArrayToList(in, list2);
25         System.out.println(list3);
26     }
27 
28 class Order {
29     private String orderName;
30     private int orderId;
31     private  T t;
32     List list = new ArrayList<>();
33    
34     public void add(){
35         list.add(t);
36     }
37     public  T getT(){
38         return t;
39     }
40     public void setT(T t){
41         this.t = t;
42     }
43     //不可以在static方法中使用泛型的声明
44 //    public static void show(){
45 //        System.out.println(t);
46 //    }
47     public void info(){
48         //不可以在try-catch中使用类的泛型的声明
49 //        try{
50 //           
51 //        }catch(T e){
52 //           
53 //        }
54     }
55     //声明泛型方法
56     public static E getE(E e){
57         return e;
58     }
59     //实现数组到集合的复制
60     public List fromArrayToList(E[] e,List list){
61         for(E e1 : e){
62             list.add(e1);
63         }
64         return list;
65     }
66    
67     public String getOrderName() {
68         return orderName;
69     }
70     public void setOrderName(String orderName) {
71         this.orderName = orderName;
72     }
73     public int getOrderId() {
74         return orderId;
75     }
76     public void setOrderId(int orderId) {
77         this.orderId = orderId;
78     }
79     @Override
80     public String toString() {
81         return "Order [orderName=" + orderName + ", orderId=" + orderId
82                 + ", t=" + t + "]";
83     }
84 }
85 //继承泛型类或泛型接口时，可以指明泛型的类型
86 class SubOrder extends Order{
87    
88 }

 1 * 泛型与继承的关系:
 2      * 若类A是类B的子类，那么List就不是List的子接口
 3 
 4     @Test
 5     public void test5(){
 6         Object obj = null;
 7         String str = "AA";
 8         obj = str;
 9        
10         Object[] obj1 = null;
11         String[] str1 = new String[]{"AA","BB","CC"};
12         obj1 = str1;
13        
14         List list = null;
15         List list1 = new ArrayList();
16 //        list = list1;
17         //假设list = list1满足
18         //list.add(123);
19         //String str = list1.get(0);//出现问题，所以假设不满足
20     }