第18章--泛型

1.泛型

混进错误数据出错，出现类型转换异常

  1 import java.util.ArrayList;
  2 import java.util.Comparator;
  3 import java.util.HashMap;
  4 import java.util.Iterator;
  5 import java.util.List;
  6 import java.util.Map;
  7 import java.util.Map.Entry;
  8 import java.util.Set;
  9 import java.util.TreeSet;
 10 
 11 import org.junit.Test;
 12 
 13 /*
 14  * 泛型在集合中的使用
 15  * 
 16  * 1.泛型，是jdk5.0新增的
 17  * 
 18  * 2.泛型的核心思想：就是将集中添加的数据限定为具体的类型。
 19  */
 20 public class GenericTest {
 21     
 22     //在集合中使用泛型之前
 23     @Test
 24     public void test1(){
 25         ArrayList list = new ArrayList();
 26         list.add(67);
 27         list.add(87);
 28         list.add(99);
 29         list.add(78);
 30         //1.添加数据时：类型不安全
 31         list.add("AA");
 32         
 33         
 34         Iterator iterator = list.iterator();
 35         while(iterator.hasNext()){
 36             Object obj = iterator.next();
 37             //2.可能出现类型转换异常
 38             int score = (int) obj;
 39             
 40             System.out.println(score);
 41         }
 42         
 43     }
 44     /*
 45      * 集合中使用泛型的例子1
 46      * 
 47      * 在集合中使用泛型
 48      * 1.之所以能在集合接口或类中使用泛型，就是因为集合接口或类在声明时，使用了泛型。
 49      *     比如：public class ArrayList<E>{}，public interface List<E>
 50      *  
 51      * 2.实例化集合类时，就可以指明类的泛型。一旦指明以后，通过集合类的对象调用内部的结构时，凡是使用了
 52      * 类的泛型的地方，都变化为指定的类的泛型的类型。
 53      *  比如：List<Integer> list = new ArrayList<Integer>();导致add(Integer e)、
 54      *  Integer<E> iterator();
 55      *  
 56      * 3.实例化集合类时，如果没有指明类的泛型，则认为此泛型的类型是Object类型。
 57      * 
 58      * 4.泛型参数在具体指明时，只能使用引用数据类型，不能使用基本数据类型
 59      */
 60     @Test
 61     public void test2(){
 62         List<Integer> list = new ArrayList<Integer>();
 63         
 64         list.add(67);
 65         list.add(87);
 66         list.add(88);
 67 //        list.add("BB");
 68         
 69         Iterator<Integer> iterator = list.iterator();
 70         while(iterator.hasNext()){
 71             int score = iterator.next();
 72             
 73             System.out.println(score);
 74         }
 75     }
 76     
 77     //集合中使用泛型的例子2
 78     @Test
 79     public void test3(){
 80         
 81         Map<String,Integer> map = new HashMap<String,Integer>();
 82 //        Map<String,Integer> map = new HashMap<>();//jdk7.新增类型推断。 比如：int[] arr = {1,2,3};
 83         
 84         map.put("MM", 78);
 85         map.put("JJ", 89);
 86         map.put("GG", 66);
 87         map.put("DD", 54);
 88 //        map.put(12, "AA");
 89         
 90         Set<Entry<String, Integer>> entrySet = map.entrySet();
 91         Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
 92         while(iterator.hasNext()){
 93             Entry<String, Integer> entry = iterator.next();
 94             String key = entry.getKey();
 95             Integer value = entry.getValue();
 96             System.out.println(key + "--->" + value);
 97         }
 98     }
 99     
100     //使用上泛型以后的自然排序
101     @Test
102     public void test4(){
103         
104         TreeSet<Goods> set = new TreeSet<>();
105         
106         Goods g1 = new Goods("eggs", 10.5);
107         Goods g2 = new Goods("banana", 7.5);
108         Goods g3 = new Goods("apple", 2.5);
109         Goods g4 = new Goods("orange", 4.3);
110         
111         
112         set.add(g1);
113         set.add(g2);
114         set.add(g3);
115         set.add(g4);
116         
117         for(Goods g : set){
118             System.out.println(g);
119         }
120         
121         
122     }
123     
124     //使用上泛型以后的定制排序
125     @Test
126     public void test5(){
127         
128         Comparator<Goods> com = new Comparator<Goods>(){
129 
130             @Override
131             public int compare(Goods o1, Goods o2) {
132                 
133                 return o1.getGoodsName().compareTo(o2.getGoodsName());
134                 
135             }
136             
137         };
138         
139         
140         TreeSet<Goods> set = new TreeSet<>(com);
141         
142         Goods g1 = new Goods("eggs", 10.5);
143         Goods g2 = new Goods("banana", 7.5);
144         Goods g3 = new Goods("apple", 2.5);
145         Goods g4 = new Goods("orange", 4.3);
146         
147         
148         set.add(g1);
149         set.add(g2);
150         set.add(g3);
151         set.add(g4);
152         
153         for(Goods g : set){
154             System.out.println(g);
155         }
156         
157         
158     }
159 }

2.自定义泛型类

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 /*
 5  * 自定义泛型类
 6  * 
 7  */
 8 public class Order<T> {
 9 
10     //在类的内部的属性、方法、构造器等中，就可以使用类的泛型
11     
12     String orderName;
13     int orderId;
14     T orderT;
15     T[] arr;
16     
17     public Order(){
18 //        arr = new T[10];//错误的
19         arr = (T[]) new Object[10];
20     }
21     
22     public Order(T orderT){
23         this.orderT = orderT;
24     }
25     
26     //如下的两个方法不是泛型方法！
27     public String toString(){
28         return "Order[orderName:" + orderName + ",orderId:" + orderId + ",orderT:" + orderT + "]"; 
29     }
30     
31     
32     public T getOrderT(){
33         return orderT;
34     }
35     
36     //静态方法中不能使用类的泛型
37 //    public static T show(){
38 //        System.out.println(orderT);
39 //        return orderT;
40 //    }
41     
42     //泛型方法
43     //泛型方法所在的类，不一定是泛型类。换句话说，泛型方法与泛型类没有直接关系
44     //泛型方法，根据需要可以声明为static的
45     public static <E>  List<E> copyArrToList(E[] arr){
46         
47         List<E> list = new ArrayList<>();
48         for(E e : arr){
49             list.add(e);
50         }
51         
52         return list;
53         
54     }
55     
56 }

 1 import java.util.List;
 2 
 3 import org.junit.Test;
 4 
 5 public class GenericTest1 {
 6     
 7     @Test
 8     public void test1(){
 9 //        Goods<Integer> goods1 = new Goods<>();
10         
11         //实例化泛型类时，没有指明类的泛型。则此时认为泛型的类型为Object
12         Order order = new Order();
13         order.orderT = "AA";
14         
15         //实例化泛型类时，指明了类的泛型，进而类中凡是使用类的泛型的位置，都变化为具体的类的泛型。
16         Order<Integer> order1 = new Order<Integer>();
17         order1.orderT = 123;
18         Integer t = order1.getOrderT();
19         
20     }
21     
22     /*
23      * 除了在实例化泛型类时，指明类的泛型之外。还可以提供泛型类的子类时，指明泛型的类型。比如：SubOrder1
24      * 
25      * 
26      */
27     @Test
28     public void test2(){
29         SubOrder1 sub1 = new SubOrder1();
30         sub1.orderT = "AA";
31         
32         SubOrder2<Integer> sub2 = new SubOrder2<>();
33         Integer orderT = sub2.getOrderT();
34     }
35     
36     @Test
37     public void test3(){
38         Order<String> order = new Order<>();
39         
40         Integer[] arr = new Integer[]{1,2,3};
41         
42         List<Integer> list = order.copyArrToList(arr);
43         
44     }
45 }

//SubOrder1不是泛型类
public class SubOrder1 extends Order<String>{

}

1 //SubOrder2仍然是一个泛型类
2 public class SubOrder2<T> extends Order<T>{
3 
4 }

3.自定义泛型类的补充说明

4.泛型方法

5.泛型在继承上的体现

6.通配符的使用

7.有限制条件的通配符