Java學習筆記十六（泛型）

泛型的理解：

1、泛型的引入背景：
集合容器類在聲明階段不能確定這個集合容器實際存的是什麼類型的對象，所以在JDK5之前，只能把元素類型設計成Object；JDK5之後使用泛型來解決。因爲這個時候除了元素的類型不確定，其他部分是確定的；例如：關於這個元素如何保存，如何管理等都是確定的。因此，此時把元素的類型設計成一個參數，這個類型參數叫做泛型Collection<E.> 這個E就是；類型參數，即泛型。
2、泛型的理解：
所謂泛型，就是允許在定義類和接口時通過一個標識來表示某個屬性的類型或者是某個方法的返回值類型和形參類型。這個類型參數將在使用時（例如繼承或實現這個接口，或者用這個類型聲明變量創建對象時）確定。（即傳入實際的類型參數）

泛型在集合中的使用：**

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、在集合中使用泛型的例子：

@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);
        }

    }

//在集合中使用泛型的情況：以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 = e.getValue();
            System.out.println(key + "----" + value);
        }

    }

3、集合中使用泛型總結：

① 集合接口或集合類在jdk5.0時都修改爲帶泛型的結構。
② 在實例化集合類時，可以指明具體的泛型類型
③ 指明完以後，在集合類或接口中凡是定義類或接口時，內部結構（比如：方法、構造器、屬性等）使用到類的泛型的位置，都指定爲實例化的泛型類型。
- 比如：add(E e) —>實例化以後：add(Integer e)
④ 注意點：泛型的類型必須是類，不能是基本數據類型。需要用到基本數據類型的位置，拿包裝類替換
⑤ 如果實例化時，沒指明泛型的類型。默認類型java.lang.Object類型。

自定義泛型類、泛型接口、泛型方法：

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 o = new SubOrder<>();

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;
    }
}

如下依然是泛型類：

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

總結：
1、如果定義了泛型類，而實例化時沒有指明類的類型，則認爲此泛型類型爲Object類型；
2、如果定義了泛型類，建議在實例化時要指明泛型的類型。
3、若子類在繼承帶泛型的父類時，指明瞭泛型類型，則實例化子類對象時不再需要指明泛型；
4、泛型不同的引用不能相互賦值；
5、泛型方法是在調用時指明其類型。

@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);
    }

注意點：

應用場景舉例：

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
}

泛型在繼承上的體現：

1、泛型在繼承方面的體現
雖然類A是類B的父類，但是G<A.> 和G<B.>二者不具備子父類關係，二者是並列關係。
補充： 類A是類B的父類，A 是 B 的父類。


@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<?>
2.涉及通配符的集合的數據的寫入和讀取:

@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);
        }
    }

3、有限制條件的通配符的使用：
限制條件的通配符的使用。
** ? extends A：**
G<? extends A> 可以作爲G<A.>和G<B.>的父類，其中B是A的子類
? super A：
G<? super A> 可以作爲G<A.>和G<B.>的父類，其中B是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());

    }

Java學習筆記十六（泛型）

泛型的理解：

泛型在集合中的使用：**

自定義泛型類、泛型接口、泛型方法：

注意點：

應用場景舉例：

泛型在繼承上的體現：

通配符的使用:

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

GPT-4o 引領人機交互新風向，向量數據庫賽道沸騰了

企業大模型如何成爲自己數據的“百科全書”？

本地SSL證書過期輸入命令在IIS自動生成

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（二）使用kube-vip實現集羣VIP訪問

.NET週刊【5月第2期 2024-05-12】

Java學習筆記十三（JDK8之後的日期時間、比較器和其他常用類）

Java學習筆記七（面向對象特徵之多態）

Java學習筆記十六（泛型）

Java學習筆記十九（Java的反射機制）

Java學習筆記二十（數據庫基礎）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結