泛型的使用

1.jdk 5.0新增的特性
2.在集合中使用泛型：
总结：
①集合接口或集合类在jdk 5.0时都修改为带泛型的结构
②在实例化集合类时，可以指明具体的泛型类型
③指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型
④注意：泛型的类型必须是类，不能是基本数据类型，需要用到基本数据类型的位置，拿包装类替换
⑤如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型
3.常见字母泛型含义

  • E - Element (在集合中使用，因为集合中存放的是元素)
  • T - Type（Java 类）
  • K - Key（键）
  • V - Value（值）
  • N - Number（数值类型）

  • ？ - 表示不确定的 java 类型 ```java public class GenericTest {

    //在集合中使用泛型之前的情况 @Test public void test1(){

    1.   ArrayList list = new ArrayList();
    3.   list.add(78);
    4.   list.add(76);
    5.   list.add(89);
    6.   list.add(88);
    7.   //问题一：类型不安全
    8.   //list.add("Tom");
    10.   for (Object score : list){
    11.       //问题二：强转时，可能出现ClassCastException
    13.       int stuScore = (Integer) score;
    15.       System.out.println(stuScore);
    17.   }

    }

    //在集合中使用泛型的情况:Arraylist @Test public void test2(){

    1.   ArrayList<Integer> list = new ArrayList<Integer>();
    3.   list.add(78);
    4.   list.add(87);
    5.   list.add(99);
    6.   list.add(65);
    7.   //编译时进行类型检查，保证数据安全
    8.   //list.add("Tom");
    10.   //方式一：
    11.   for (Integer score : list){
    12.       //避免了强转操作
    13.       int stuScore = score;
    15.       System.out.println(stuScore);
    16.   }
    17.   //方式二：
    18.   Iterator<Integer> iterator = list.iterator();
    19.   while (iterator.hasNext()){
    20.       int stuScore = iterator.next();
    21.       System.out.println(stuScore);
    22.   }

    }

    //在集合中使用泛型的情况：HashMap @Test public void test3(){

    1.   Map<String,Integer> map = new HashMap<String,Integer>();
    3.   map.put("Tom",87);
    4.   map.put("Jerry",67);
    5.   map.put("June",78);
    6.   map.put("Gary",66);
    8.   //map.put(112,"ACC");
    10.   //泛型的嵌套
    11.   Set<Map.Entry<String,Integer>> entry = map.entrySet();
    12.   Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    14.   while (iterator.hasNext()){
    15.       Map.Entry<String, Integer> entry1 = iterator.next();
    16.       String key = entry1.getKey();
    17.       Integer value = entry1.getValue();
    18.       System.out.println(key + "----" + value);
    19.   }

    } }

  1. <a name="eeuLY"></a>
  2. ### 自定义泛型类
  3. ```java
  4. public class Order<T> {
  6.     String orderName;
  7.     int orderId;
  9.     //类的内部结构就可以使用类的泛型
  11.     T orderT;
  13.     public Order(){}
  15.         public Order(String orderName,int orderId,T orderT){
  16.            this.orderName =orderName;
  17.            this.orderId = orderId;
  18.            this.orderT = orderT;
  19.         }
  21.         public T getOrderT(){
  22.             return orderT;
  23.         }
  25.         public void setOrderT(){
  26.             this.orderT = orderT;
  27.         }
  29.     @Override
  30.     public String toString() {
  31.         return "Order{" +
  32.                 "orderName='" + orderName + '\'' +
  33.                 ", orderId=" + orderId +
  34.                 ", orderT=" + orderT +
  35.                 '}';
  36.     }
  38.     public void setOrderT(T s) {
  39.     }
  40. }
  1. public class subOrder extends Order<Integer>{
  3. }
  1. public class GenericTest1 {
  3.     @Test
  4.     public void test1(){
  6.         //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
  7.         //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型
  8.         Order order = new Order();
  9.         order.setOrderT(123);
  10.         order.setOrderT("AA");
  12.         //建议：实例化时指明类的泛型
  13.         Order<String> order1 = new Order<String>("orderAA",1001,"orderAA");
  15.         order1.setOrderT("AA:hello");
  17.     }
  19.     @Test
  20.     public void test2(){
  21.         subOrder sub1 = new subOrder();
  22.         //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型
  23.         sub1.setOrderT(1122);
  25.     }
  26. }

注意点

1.泛型不同的引用不能相互赋值

  1. public void test3(){
  3.         ArrayList<String> list1 = null;
  4.         ArrayList<Integer> list2 = new ArrayList<Integer>();
  6.         //泛型不同的引用不能相互赋值
  7.         //list1 = list2;
  9.         People p1 = null;
  10.         People p2 = null;
  11.         p1 = p2;
  12.     }

2.静态方法中不能使用类的泛型

  1. public static void show(T orderT){
  2.         System.out.println(orderT);
  3.     }

3.异常类不能声明为泛型类

  1. public class MyException<T> extends Exception{
  2. }
  5. public void show(){
  6.     //编译不通过
  7.      try{
  9.      }catch(T t){
  11.      }
  12. }

泛型方法

1.在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，换句话说，泛型方法所属的类是不是泛型类都没有关系
2.泛型方法可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非实例化时确定的

  1. public <E> List<E> copyFromArrayToList(E[] arr){
  2.         ArrayList<E> list = new ArrayList<E>();
  4.         for (E e : arr){
  5.             list.add(e);
  6.         }
  7.         return list;
  8.     }
  1. public void test4(){
  2.         Order<String> order = new Order<>();
  3.         Integer[] arr = new Integer[]{1,2,3,4};
  4.         //泛型方法在调用时，指明泛型参数类型
  5.         List<Integer> list = order.copyFromArrayToList(arr);
  7.         System.out.println(list);
  8.     }

泛型在继承方面的体现

  1. public class GenericTest3 {
  3.     @Test
  4.     public void test1(){
  6.         //虽然类A是类B的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列关系
  8.         Object obj = null;
  9.         String str = null;
  10.         obj = str;
  12.         Object[] arr1 = null;
  13.         String[] arr2 = null;
  14.         arr1 = arr2;
  16.         //编译不通过
  17.         /*Date date = new Date();
  18.         str = date;*/
  20.         //此时的list1和list2的类型不具有子父类关系
  21.         //编译不通过
  22.         List<Object> list1 = null;
  23.         List<String> list2 = null;
  24.         //list1 = list2;
  26.         show(list1);
  27.         show1(list2);
  28.     }
  30.     private void show1(List<String> list2) {
  31.     }
  33.     private void show(List<Object> list1) {
  34.     }
  36.     @Test
  37.     public void test2(){
  39.         //类A是类B的父类，A<G>是B<G>的父类
  40.         AbstractList<String> list1 = null;
  41.         List<String> list2 = null;
  42.         ArrayList<String> list3 = null;
  44.         list1 = list3;
  45.         list2 = list3;
  46.     }
  47. }

通配符的使用

通配符：?
类A是类B的父类，G和G是没有关系的，二者共同的父类是：G<?>

  1. public void test3(){
  2.         List<Object> list1 = null;
  3.         List<String> list2 = null;
  5.         List<?> list = null;
  7.         list = list1;
  8.         list = list2;
  10.         print(list1);
  11.         print(list2);
  12.     }
  14.     public void print(List<?> list){
  15.         Iterator<?> iterator = list.iterator();
  16.         while(iterator.hasNext()){
  17.             Object obj = iterator.next();
  18.             System.out.println(obj);
  19.         }
  20.     }

通配符写入与读取的要求

  1. List<String> list3 = new ArrayList<>();
  2.         list3.add("AA");
  3.         list3.add("BB");
  4.         list3.add("CC");
  5.         list = list3;
  6.         //添加(写入)：对于List<?>就不能向其内部添加数据
  7.         //除了添加null之外
  8.         //list.add("DD");
  9.         //list.add('?');
  10.         list.add(null);
  12.         //获取(读取)：允许读取数据，读取的数据类型为Object
  13.         Object o = list.get(0);
  14.         System.out.println(o);

有限制条件的通配符的使用

? extends A: G<? extends A> 可以作为G和G的父类，其中B是A的子类
? super A: G<? super A> 可以作为G和G的父类，其中B是A的父类

  1. public void test1(){
  2.         List<? extends Person> list1 = null;
  3.         List<? super Person> list2 = null;
  5.         List<Student> list3 = new ArrayList<Student>();
  6.         List<Person> list4 = new ArrayList<Person>();
  7.         List<Object> list5 = new ArrayList<Object>();
  9.         list1 = list3;
  10.         list1 = list4;
  11.         //list1 = list5;
  13.         //list2 = list3;
  14.         list2 = list4;
  15.         list2 = list5;
  16.     }