JAVA学习--泛型的使用

 * 泛型的使用
 * 1.在集合中使用泛型(掌握)
 * 2.自定义泛型类、泛型接口、泛型方法（理解 --->使用）
 * 3.泛型与继承的关系
 * 4.通配符
 *    

----------------------------------------------------------------------------------------------------------

 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     }

*  通配符  ?
     *  List< A > 、List< B > 、。。。。都是List< ? >的子类
     *
     *  ? extends A :可以存放A及其子类
     *  ? super A:可以存放A及其父类

 

 1 @Test

 2     public void test6(){

 3         List < ? > list = null;

 4         List< Object > list1 = new ArrayList< Object >();

 5         List< String > list2 = new ArrayList< String >();

 6         list = list1;

 7         list = list2;

 8        

 9         show(list1);

10 //        show(list2);

11         show1(list1);

12         show1(list2);

13        

14         List< ? extends Number > list3 = null;

15         List< Integer > list4 = null;

16         list3 = list4;

17 //        list3 = list1;

18         List< ? super Number > list5 = null;

19         list5 = list1;

20     }

21     

22     public void show(List< Object > list){

23         

24     }

25     public void show1(List< ? > list){

26         

27     }

 

* 通配符的使用

 1  @Test

 2     public void test7(){

 3         List list = new ArrayList();

 4         list.add("AA");

 5         list.add("BB");

 6         List< ? > list1 = list;

 7         //可以读取声明为通配符的集合类的对象

 8         Iterator< ? > iterator = list1.iterator();

 9         while(iterator.hasNext()){

10             System.out.println(iterator.next());

11         }

12         //不允许向声明为通配符的集合类中写入对象。唯一例外的是null

13 //        list1.add("CC");

14 //        list1.add(123);

15         list1.add(null);

16     }