一、泛型的理解

1.泛型的概念

所謂泛型，就是允許在定義類、介面時通過一個標識表示類中某個屬性的型別或者是某個方法的返

回值及引數型別，這個型別引數將在使用時（例如，繼承或實作這個介面，用這個型別宣告變數、

創建物件時確定（即傳入實際的型別引數，也稱為型別實參），

2.泛型的引入背景

集合容器類在設計階段/宣告階段不能確定這個容器到底實際存的是什么型別的物件，所以在JDK1.5之前只能把元素型別設計為Object，JDK1.5之后使用泛型來解決，因為這個時候除了元素的型別不確定，其他的部分是確定的，例如關于這個元素如何保存，如何管理等是確定的，因此此時把元素的型別設計成一個引數，這個型別引數叫做泛型，Collection，List，ArrayList 這個就是型別引數，即泛型，

二、泛型在集合中的使用

1. 在集合中使用泛型之前的例子

@Test
public void test1(){
    ArrayList list = new ArrayList();
    //需求：存放學生的成績
    list.add(78);
    list.add(76);
    list.add(89);
    list.add(88);
    //問題一：型別不安全
    //    list.add("Tom");

    for(Object score : list){
        //問題二：強轉時，可能出現ClassCastException
        int stuScore = (Integer) score;

        System.out.println(stuScore);

    }

}

圖示：

2. 在集合中使用泛型例子1

@Test
public void test2(){
    ArrayList<Integer> list = new ArrayList<Integer>();

    list.add(78);
    list.add(87);
    list.add(99);
    list.add(65);
    //編譯時，就會進行型別檢查，保證資料的安全
    //    list.add("Tom");

    //方式一：
    //    for(Integer score : list){
    //      //避免了強轉操作
    //      int stuScore = score;
    //
    //      System.out.println(stuScore);
    //
    //    }
    //方式二：
    Iterator<Integer> iterator = list.iterator();
    while(iterator.hasNext()){
        int stuScore = iterator.next();
        System.out.println(stuScore);
    }

}

圖示：

3. 在集合中使用泛型例子2

//在集合中使用泛型的情況：以HashMap為例
@Test
public void test3(){
    //    Map<String,Integer> map = new HashMap<String,Integer>();
    //jdk7新特性：型別推斷
    Map<String,Integer> map = new HashMap<>();

    map.put("Tom",87);
    map.put("Jerry",87);
    map.put("Jack",67);

    //    map.put(123,"ABC");
    //泛型的嵌套
    Set<Map.Entry<String,Integer>> entry = map.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

    while(iterator.hasNext()){
        Map.Entry<String, Integer> e = iterator.next();
        String key = e.getKey();
        Integer value = https://www.cnblogs.com/java-blogs/p/e.getValue();
        System.out.println(key +"----" + value);
    }

}

4. 集合中使用泛型總結

① 集合介面或集合類在jdk5.0時都修改為帶泛型的結構，

② 在實體化集合類時，可以指明具體的泛型型別

③ 指明完以后，在集合類或介面中凡是定義類或介面時，內部結構（比如：方法、構造器、屬性等）使用到類的泛型的位置，都指定為實體化的泛型型別，比如：add(E e) --->實體化以后：add(Integer e)

④ 注意點：泛型的型別必須是類，不能是基本資料型別，需要用到基本資料型別的位置，拿包裝類替換

⑤ 如果實體化時，沒指明泛型的型別，默認型別為java.lang.Object型別，

三、泛型在繼承上的體現

泛型在繼承上的體現

/*
1. 泛型在繼承方面的體現

雖然類A是類B的父類，但是G<A> 和G<B>二者不具備子父類關系，二者是并列關系，

補充：類A是類B的父類，A<G> 是 B<G> 的父類

*/
@Test
public void test1(){

    Object obj = null;
    String str = null;
    obj = str;

    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
    //編譯不通過
    //    Date date = new Date();
    //    str = date;
    List<Object> list1 = null;
    List<String> list2 = new ArrayList<String>();
    //此時的list1和list2的型別不具子父類關系
    //編譯不通過
    //    list1 = list2;
    /*
反證法：
假設list1 = list2;
list1.add(123);導致混入非String的資料，出錯，

*/

    show(list1);
    show1(list2);

}

public void show1(List<String> list){

}

public void show(List<Object> list){

}

@Test
public void test2(){

    AbstractList<String> list1 = null;
    List<String> list2 = null;
    ArrayList<String> list3 = null;

    list1 = list3;
    list2 = list3;

    List<String> list4 = new ArrayList<>();

}

四、通配符

1.通配符的使用

涉及通配符的集合的資料的寫入和讀取：

/*
通配符的使用
通配符：?
類A是類B的父類，G<A>和G<B>是沒關系的，二者共同的父類是：G<?>
*/

@Test
public void test3(){
    List<Object> list1 = null;
    List<String> list2 = null;

    List<?> list = null;

    list = list1;
    list = list2;
    //編譯通過
    //    print(list1);
    //    print(list2);


    //
    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list3.add("CC");
    list = list3;
    //添加(寫入)：對于List<?>就不能向其內部添加資料，
    //除了添加null之外，
    //    list.add("DD");
    //    list.add('?');

    list.add(null);

    //獲取(讀取)：允許讀取資料，讀取的資料型別為Object，
    Object o = list.get(0);
    System.out.println(o);


}

public void print(List<?> list){
    Iterator<?> iterator = list.iterator();
    while(iterator.hasNext()){
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

2.有限制條件的通配符的使用

/*
限制條件的通配符的使用，
? extends A：此通配符泛型值接受A類，及A類的子類

G<? extends A> 可以作為G<A>和G<B>的父類，其中B是A的子類
相當于數學的(-∞,A)

? super A：此通配符泛型值接受A類，及A類的父類
G<? super A> 可以作為G<A>和G<B>的父類，其中B是A的父類
相當于數學的(A,+∞)
*/
@Test
public void test4(){

    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;

    List<Student> list3 = new ArrayList<Student>();
    List<Person> list4 = new ArrayList<Person>();
    List<Object> list5 = new ArrayList<Object>();

    list1 = list3;
    list1 = list4;
    //    list1 = list5;

    //    list2 = list3;
    list2 = list4;
    list2 = list5;

    //讀取資料：
    list1 = list3;
    Person p = list1.get(0);
    //編譯不通過
    //Student s = list1.get(0);

    list2 = list4;
    Object obj = list2.get(0);
    ////編譯不通過
    //    Person obj = list2.get(0);

    //寫入資料：
    //編譯不通過
    //    list1.add(new Student());

    //編譯通過
    list2.add(new Person());
    list2.add(new Student());

}

五、自定義泛型類、泛型介面、泛型方法

1.舉例

【Order.java】

public class Order<T> {

    String orderName;
    int orderId;

    //類的內部結構就可以使用類的泛型

    T orderT;

    public Order(){
        //編譯不通過
        //    T[] arr = new T[10];
        //編譯通過
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //如下的個方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
            "orderName='" + orderName + '\'' +
            ", orderId=" + orderId +
            ", orderT=" + orderT +
            '}';
    }
    //靜態方法中不能使用類的泛型，
    //  public static void show(T orderT){
    //    System.out.println(orderT);
    //  }

    public void show(){
        //編譯不通過
        //    try{
        //
        //
        //    }catch(T t){
        //
        //    }

    }

    //泛型方法：在方法中出現了泛型的結構，泛型引數與類的泛型引數沒任何關系，
    //換句話說，泛型方法所屬的類是不是泛型類都沒關系，
    //泛型方法，可以宣告為靜態的，原因：泛型引數是在呼叫方法時確定的，并非在實體化類時確定，
    public static <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

【SubOrder.java】

public class SubOrder extends Order<Integer> {//SubOrder:不是泛型類

    public static <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

//實體化時，如下的代碼是錯誤的
SubOrder<Integer> o = new SubOrder<>();

【SubOrder1.java】

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型類
 
}

【測驗】

@Test
public void test1(){
    //如果定義了泛型類，實體化沒指明類的泛型，則認為此泛型型別為Object型別
    //要求：如果大家定義了類是帶泛型的，建議在實體化時要指明類的泛型，
    Order order = new Order();
    order.setOrderT(123);
    order.setOrderT("ABC");

    //建議：實體化時指明類的泛型
    Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");

    order1.setOrderT("AA:hello");

}

@Test
public void test2(){
    SubOrder sub1 = new SubOrder();
    //由于子類在繼承帶泛型的父類時，指明了泛型型別，則實體化子類物件時，不再需要指明泛型，
    sub1.setOrderT(1122);

    SubOrder1<String> sub2 = new SubOrder1<>();
    sub2.setOrderT("order2...");
}

@Test
public void test3(){

    ArrayList<String> list1 = null;
    ArrayList<Integer> list2 = new ArrayList<Integer>();
    //泛型不同的參考不能相互賦值，
    //    list1 = list2;

    Person p1 = null;
    Person p2 = null;
    p1 = p2;

}

//測驗泛型方法
@Test
public void test4(){
    Order<String> order = new Order<>();
    Integer[] arr = new Integer[]{1,2,3,4};
    //泛型方法在呼叫時，指明泛型引數的型別，
    List<Integer> list = order.copyFromArrayToList(arr);

    System.out.println(list);
}

2.注意點

泛型類可能有多個引數，此時應將多個引數一起放在尖括號內，比如： <E1,E2,E3>
泛型類的構造器如下：public GenericClass(){} 而下面是錯誤的：public GenericClass<E>(){}
實體化后，操作原來泛型位置的結構必須與指定的泛型型別一致，
泛型不同的參考不能相互賦值，盡管在編譯時ArrayList<String>和ArrayList<Integer>是兩種型別，但是，在運行時只有一個ArrayList被加載到 JVM中，
泛型如果不指定，將被擦除，泛型對應的型別均按照Object處理，但不等價于Object，經驗：泛型要使用一路都用，要不用，一路都不要用，
如果泛型結構是一個介面或抽象類，則不可創建泛型類的物件，
jdk1.7，泛型的簡化操作：ArrayList<Fruit> flist=new ArrayList<>();
泛型的指定中不能使用基本資料型別，可以使用包裝類替換，
在類/介面上宣告的泛型，在本類或本介面中即代表某種型別，可以作為非靜態屬性的型別、非靜態方法的引數型別、非靜態方法的回傳值型別，但在靜態方法中不能使用類的泛型，
例外類不能是泛型的
不能使用new E[]，但是可以：E[] elements=(E[])new Object[capacity]; 參考：ArrayLlst原始碼中宣告：Object[] elementData，而非泛型引數型別陣列，
父類有泛型，子類可以選擇保留泛型也可以選擇指定泛型型別：
- 子類不保留父類的泛型：按需實作
  
  ? 沒有型別擦除
  
  ? 具體型別
- 子類保留父類的泛型：泛型子類
  
  ? 全部保留
  
  ? 部分保留

結論：子類必須是“富二代”，子類除了指定或保留父類的泛型，還可以增加自己的泛型，

3.應用場景舉例

【DAO.java】：定義了操作資料庫中的表的通用操作， ORM思想(資料庫中的表和Java中的類對應)

public class DAO<T> {//表的共性操作的DAO

    //添加一條記錄
    public void add(T t){

    }

    //洗掉一條記錄
    public boolean remove(int index){

        return false;
    }

    //修改一條記錄
    public void update(int index,T t){

    }

    //查詢一條記錄
    public T getIndex(int index){

        return null;
    }

    //查詢多條記錄
    public List<T> getForList(int index){

        return null;

    }

    //泛型方法
    //舉例：獲取表中一共有多少條記錄？獲取最大的員工入職時間？
    public <E> E getValue(){

        return null;
    }

}

【CustomerDAO.java】

public class CustomerDAO extends DAO<Customer>{//只能操作某一個表的DAO
}

【StudentDAO.java】

public class StudentDAO extends DAO<Student> {//只能操作某一個表的DAO
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/436311.html

標籤：Java

上一篇：SpringBoot入門教程，帶你快速學會使用springboot

下一篇：Spring Boot+RabbitMQ 通過fanout模式實作訊息接收（支持消費者多實體部署）

9-Java泛型