第 13 章泛型

13.1 泛型的理解和好處

13.1.1 看一個需求

請編寫程序，在ArrayList 中，添加3個Dog對象
Dog對象含有name 和 age, 并輸出name 和 age (要求使用getXxx())

先使用傳統的方法來解決 -> 引出泛型

class Dog {
    public String name;
    public int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }
}

public class Generic01 {
    public static void main(String[] args) {

        //使用傳統的方法來解決
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺財", 10));
        arrayList.add(new Dog("發財", 1));
        arrayList.add(new Dog("小黃", 5));

        //假如我們的程序員，不小心，添加了一只貓
        arrayList.add(new Cat("招財貓", 8));

        //遍歷
        for (Object o : arrayList) {
            //向下轉型Object ->Dog
            Dog dog = (Dog) o;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }

    }
}
/*
請編寫程序，在ArrayList 中，添加3個Dog對象
Dog對象含有name 和 age, 并輸出name 和 age (要求使用getXxx())
 */
class Dog {
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Cat { //Cat類
    private String name;
    private int age;
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

13.1.2 使用傳統方法的問題分析

不能對加入到集合 ArrayList 中的數據類型進行約束（不安全）
遍歷的時候，需要進行類型轉換，如果集合中的數據量較大，對效率有影響

13.1.3 泛型快速體驗-用泛型來解決前面的問題

public class Generic02 {
    public static void main(String[] args) {

        //使用傳統的方法來解決===> 使用泛型
        //解讀
        //1. 當我們 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog類型 (細節后面說...)
        //2. 如果編譯器發現添加的類型，不滿足要求，就會報錯
        //3. 在遍歷的時候，可以直接取出 Dog 類型而不是 Object
        //4. public class ArrayList<E> {} E稱為泛型,那么 Dog->E
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺財", 10));
        arrayList.add(new Dog("發財", 1));
        arrayList.add(new Dog("小黃", 5));
        //假如我們的程序員，不小心，添加了一只貓
        //arrayList.add(new Cat("招財貓", 8));
        System.out.println("===使用泛型====");
        for (Dog dog : arrayList) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }


    }
}

/*
1.請編寫程序，在ArrayList 中，添加3個Dog對象
2.Dog對象含有name 和 age, 并輸出name 和 age (要求使用getXxx())
3.老師使用泛型來完成代碼
 */
class Dog {
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Cat { //Cat類
    private String name;
    private int age;
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

13.2 泛型的理解和好處

13.2.1 泛型的好處

編譯時，檢查添加元素的類型，提高了安全性
減少了類型轉換的次數，提高效率
- 不使用泛型：Dog -> Object（放入 ArrayList 轉成 Object ）→ 取出時轉成 Dog
- 使用泛型：Dog -> Dog（放入、取出無需類型轉換）
不再提示編譯警告

13.3 泛型介紹

主講人：韓順平老師
韓順平循序漸進 Java 零基礎

int a = 10;

老韓理解：泛（廣泛）型（類型）→ Integer、String、Dog

泛型又稱參數化類型，是 JDK5.0 出現的新特性，解決數據類型的安全性問題
在類聲明或實例化時只需指定好需要的具體類型即可
Java 泛型可以保證：編譯時沒警告，運行時就不會產生 ClassCastException 異常。同時，代碼更加簡潔、健壯
泛型的作用：類聲明時，通過標識表示類中屬性、方法返回值、參數的類型

public class Generic03 {
    public static void main(String[] args) {

        //注意，特別強調： E具體的數據類型在定義Person對象的時候指定,即在編譯期間，就確定E是什么類型
        Person<String> person = new Person<String>("韓順平教育");
        person.show(); //String

        /*
            你可以這樣理解，上面的Person類
            class Person {
                String s ;//E表示 s的數據類型, 該數據類型在定義Person對象的時候指定,即在編譯期間，就確定E是什么類型

                public Person(String s) {//E也可以是參數類型
                    this.s = s;
                }

                public String f() {//返回類型使用E
                    return s;
                }
            }
         */

        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer

        /*
            class Person {
                Integer s ;//E表示 s的數據類型, 該數據類型在定義Person對象的時候指定,即在編譯期間，就確定E是什么類型

                public Person(Integer s) {//E也可以是參數類型
                    this.s = s;
                }

                public Integer f() {//返回類型使用E
                    return s;
                }
            }
         */
    }
}

//泛型的作用是：可以在類聲明時通過一個標識表示類中某個屬性的類型，
// 或者是某個方法的返回值的類型，或者是參數類型

class Person<E> {
    E s ;//E表示 s的數據類型, 該數據類型在定義Person對象的時候指定,即在編譯期間，就確定E是什么類型

    public Person(E s) {//E也可以是參數類型
        this.s = s;
    }

    public E f() {//返回類型使用E
        return s;
    }

    public void show() {
        System.out.println(s.getClass());//顯示s的運行類型
    }
}

13.4 泛型的語法

13.4.1 泛型的聲明

interface 接口<T>{}  
class 類<K,V>{}  
// 比如: List，ArrayList

說明：

其中，T、K、V 不代表值，而是表示類型
任意字母都可以。常用 T 表示，是 Type 的縮寫

13.4.2 泛型的實例化

要在類名后面指定類型參數的值（類型）。如：

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

13.4.3 泛型使用舉例

舉例說明，泛型在 HashSet、HashMap 的使用情況，演示 GenericExercise.java

練習：

創建 3 個學生對象
放入到 HashSet 中學生對象，使用
放入到 HashMap 中，要求 Key 是 String name，Value 是學生對象
使用兩種方式遍歷

public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式給HashSet 放入3個學生對象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));

        //遍歷
        for (Student student : students) {
            System.out.println(student);
        }

        //使用泛型方式給HashMap 放入3個學生對象
        //K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
            public class HashMap<K,V>  {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("hsp", new Student("hsp", 28));

        //迭代器 EntrySet
        /*
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
         */
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("==============================");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
            
        }

    }
}
/**
 * 創建  3個學生對象
 * 放入到HashSet中學生對象, 使用.
 * 放入到  HashMap中，要求 Key 是 String name, Value 就是 學生對象
 * 使用兩種方式遍歷
 */
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

13.4.4 泛型使用的注意事項和細節

GenericDetail.java

接口/類泛型限制（如 interface List<T>{}、public class HashSet<E>{} ）
- 說明：T、E 只能是引用類型
- 示例：
```
List<Integer> list = new ArrayList<Integer>(); // OK  
List<int> list2 = new ArrayList<int>(); // 錯誤  
```
給泛型指定具體類型后，可傳入該類型或其子類類型

泛型使用形式

List<Integer> list1 = new ArrayList<Integer>();  
List<Integer> list2 = new ArrayList<>(); // 菱形語法（JDK7+）

若直接寫 List list3 = new ArrayList();
- 默認泛型是 <E> E = Object

public class GenericDetail {
    public static void main(String[] args) {
        //1.給泛型指向數據類型是，要求是引用類型，不能是基本數據類型
        List<Integer> list = new ArrayList<Integer>(); //OK
        //List<int> list2 = new ArrayList<int>();//錯誤

        //2. 說明
        //因為 E 指定了 A 類型, 構造器傳入了 new A()
        //在給泛型指定具體類型后，可以傳入該類型或者其子類類型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();

        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在實際開發中，我們往往簡寫
        //編譯器會進行類型推斷, 老師推薦使用下面寫法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //4. 如果是這樣寫 泛型默認是 Object
        ArrayList arrayList = new ArrayList();//等價 ArrayList<Object> arrayList = new ArrayList<Object>();

        /*
            public boolean add(Object e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        Tiger tiger = new Tiger();
        /*

            class Tiger {//類
                Object e;

                public Tiger() {}

                public Tiger(Object e) {
                    this.e = e;
                }
            }

         */

    }
}
class Tiger<E> {//類
    E e;

    public Tiger() {}

    public Tiger(E e) {
        this.e = e;
    }
}

class A {}
class B extends A {}

class Pig<E> {//
    E e;

    public Pig(E e) {
        this.e = e;
    }

    public void f() {
        System.out.println(e.getClass()); //運行類型
    }
}

13.5 泛型課堂類型

13.5.1 泛型課堂練習題

定義 Employee 類

包含：private 成員變量 name、sal、birthday（birthday 為 MyDate 類的對象）
為每個屬性定義 getter、setter 方法
重寫 toString 方法，輸出 name、sal、birthday

MyDate 類要求：

包含：private 成員變量 month、day、year
為每個屬性定義 getter、setter 方法

步驟：

創建 3 個 Employee 對象，放入泛型定義的 ArrayList 集合中
對集合元素排序并遍歷輸出

排序方式：
調用 ArrayList 的 sort 方法，傳入 Comparator 對象（使用泛型），規則：

先按 name 排序
name 相同時，按生日日期先后排序

public class GenericExercise02 {
    public static void main(String[] args) {

        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom", 20000, new MyDate(1980,12,11)));
        employees.add(new Employee("jack", 12000, new MyDate(2001,12,12)));
        employees.add(new Employee("tom", 50000, new MyDate(1980,12,10)));

        System.out.println("employees=" + employees);


        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                //先按照name排序，如果name相同，則按生日日期的先后排序。【即：定制排序】
                //先對傳入的參數進行驗證
                if(!(emp1 instanceof  Employee && emp2 instanceof Employee)) {
                    System.out.println("類型不正確..");
                    return 0;
                }
                //比較name
                int i = emp1.getName().compareTo(emp2.getName());
                if(i != 0) {
                    return i;
                }

                //下面是對birthday的比較，因此，我們最好把這個比較，放在MyDate類完成
                //封裝后，將來可維護性和復用性，就大大增強.
                return emp1.getBirthday().compareTo(emp2.getBirthday());
            }
        });

        System.out.println("==對雇員進行排序==");
        System.out.println(employees);

    }
}
/**
 * 定義Employee類
 * 1) 該類包含：private成員變量name,sal,birthday，其中 birthday 為 MyDate 類的對象；
 * 2) 為每一個屬性定義 getter, setter 方法；
 * 3) 重寫 toString 方法輸出 name, sal, birthday
 * 4) MyDate類包含: private成員變量month,day,year；并為每一個屬性定義 getter, setter 方法；
 * 5) 創建該類的 3 個對象，并把這些對象放入 ArrayList 集合中（ArrayList 需使用泛型來定義），對集合中的元素進行排序，并遍歷輸出：
 *
 * 排序方式： 調用ArrayList 的 sort 方法 ,
 * 傳入 Comparator對象[使用泛型]，先按照name排序，如果name相同，則按生日日期的先后排序。【即：定制排序】
 * 有一定難度 15min , 比較經典 泛型使用案例 GenericExercise02.java
 */

public class MyDate implements Comparable<MyDate>{
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public int compareTo(MyDate o) { //把對year-month-day比較放在這里

        int yearMinus = year - o.getYear();
        if(yearMinus != 0) {
            return  yearMinus;
        }
        //如果year相同，就比較month
        int monthMinus = month - o.getMonth();
        if(monthMinus != 0) {
            return monthMinus;
        }
        //如果year 和 month
        return day - o.getDay();
    }
}

13.6 自定義泛型

13.6.1 自定義泛型類（難度）

基本語法

class 類名<T, R...> { //...表示可以有多個泛型  
    成員  
}

注意細節

普通成員（屬性、方法）可以使用泛型
使用泛型的數組，不能初始化
靜態方法中不能使用類的泛型（泛型類的泛型在創建對象時確定，靜態方法加載早于對象創建）
泛型類的類型，在創建對象時確定（需指定具體類型）
創建對象時未指定類型，默認按 Object 處理

應用案例 `CustomeGeneric.java`

class Tiger<T, R, M> {  
    String name;  
    R r;  
    M m;  
    T t;  
}

public class CustomGeneric_ {
    public static void main(String[] args) {

        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //錯誤，類型不對
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因為 T=Object "yy"=String 是Object子類
        System.out.println("g2=" + g2);

    }
}

//解讀
//1. Tiger 后面泛型，所以我們把 Tiger 就稱為自定義泛型類
//2, T, R, M 泛型的標識符, 一般是單個大寫字母
//3. 泛型標識符可以有多個.
//4. 普通成員可以使用泛型 (屬性、方法)
//5. 使用泛型的數組，不能初始化
//6. 靜態方法中不能使用類的泛型
class Tiger<T, R, M> {
    String name;
    R r; //屬性使用到泛型
    M m;
    T t;
    //因為數組在new 不能確定T的類型，就無法在內存開空間
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) {//構造器使用泛型

        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) {//構造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因為靜態是和類相關的，在類加載時，對象還沒有創建
    //所以，如果靜態方法和靜態屬性使用了泛型，JVM就無法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    //方法使用泛型

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回類型可以使用泛型.
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

13.6.2 自定義泛型接口

基本語法

interface 接口名<T, R...> {  
    //...  
}

注意細節

接口中靜態成員不能使用泛型（同泛型類規則）
泛型接口的類型，在繼承/實現接口時確定
未指定類型時，默認按 Object 處理

應用實例 `CustomInterfaceGeneric.java`

interface IUsb<U, R> {  
    R get(U u);  
    void hi(R r1, R r2, U u1, U u2);  
    default R method(U u) {  
        return null;  
    }  
}  

class C implements IUsb {}  
class A implements IUsb<String, Integer> {}  
interface MyInterface extends IUsb<String, Integer> {}  
class D implements MyInterface {}

public class CustomInterfaceGeneric {
    public static void main(String[] args) {

    }
}

/**
 *  泛型接口使用的說明
 *  1. 接口中，靜態成員也不能使用泛型
 *  2. 泛型接口的類型, 在繼承接口或者實現接口時確定
 *  3. 沒有指定類型，默認為Object
 */

//在繼承接口 指定泛型接口的類型
interface IA extends IUsb<String, Double> {

}
//當我們去實現IA接口時，因為IA在繼承IUsu 接口時，指定了U 為String R為Double
//，在實現IUsu接口的方法時，使用String替換U, 是Double替換R
class AA implements IA {

    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {

    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//實現接口時，直接指定泛型接口的類型
//給U 指定Integer 給 R 指定了 Float
//所以，當我們實現IUsb方法時，會使用Integer替換U, 使用Float替換R
class BB implements IUsb<Integer, Float> {

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}
//沒有指定類型，默認為Object
//建議直接寫成 IUsb<Object,Object>
class CC implements IUsb { //等價 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }

}

interface IUsb<U, R> {

    int n = 10;
    //U name; 不能這樣使用

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    //在jdk8 中，可以在接口中，使用默認方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

13.6.3 自定義泛型方法

基本語法

修飾符 <T, R...> 返回類型 方法名(參數列表) {  
    //...  
}

注意細節

泛型方法可定義在普通類、泛型類中
泛型方法被調用時，類型由傳入參數確定
如 public void eat(E e)（無 <T, R...> 修飾符），不是泛型方法，只是使用了泛型

應用案例 `CustomMethodGeneric.java`

class Bird<T, R, M> {  
    public <E> void fly(E e) {  
        System.out.println(e);  
    }  
}  

class Fish {  
    public <A> A show(A a) {  
        System.out.println("a的值: " + a);  
        System.out.println("a的類型: " + a.getClass().getSimpleName());  
        return a;  
    }  
}

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("寶馬", 100);//當調用方法時，傳入參數，編譯器，就會確定類型
        System.out.println("=======");
        car.fly(300, 100.1);//當調用方法時，傳入參數，編譯器，就會確定類型

        //測試
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

//泛型方法，可以定義在普通類中, 也可以定義在泛型類中
class Car {//普通類

    public void run() {//普通方法
    }
    //說明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供給 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

class Fish<T, R> {//泛型類
    public void run() {//普通方法
    }
    public<U,M> void eat(U u, M m) {//泛型方法

    }
    //說明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了類聲明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用類聲明的泛型，也可以使用自己聲明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }

}

13.6.4 自定義泛型方法（課堂練習）

題目：`CustomMethodGenericExercise.java`（2min）

class Apple<T, R, M> { // 自定義泛型類  
    public <E> void fly(E e) { // 泛型方法  
        System.out.println(e.getClass().getSimpleName());  
    }  

    public void eat(U u) {} // 錯誤：U 未聲明  
    public void run(M m) {} // ok  
}  

class Dog {}  

// 輸出什么？  
Apple<String, Integer, Double> apple = new Apple<>();  
apple.fly(10);  
apple.fly(new Dog());

分析

eat(U u) 錯誤：方法未聲明泛型 <U>，需改為 public <U> void eat(U u)
調用 fly(10) → 輸出 Integer（10 是 Integer 類型）
調用 fly(new Dog()) → 輸出 Dog

public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        //T->String, R->Integer, M->Double
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10);//10 會被自動裝箱 Integer10, 輸出Integer
        apple.fly(new Dog());//Dog

    }
}

class Apple<T, R, M> {//自定義泛型類

    public <E> void fly(E e) {  //泛型方法
        System.out.println(e.getClass().getSimpleName());
    }

    //public void eat(U u) {}//錯誤，因為U沒有聲明
    public void run(M m) {
    } //ok
}

class Dog {
}

13.7 泛型的繼承和通配符

13.7.1 泛型的繼承和通配符說明 `GenericExtends.java`

泛型不具備繼承性
- 示例：List<Object> list = new ArrayList<String>(); → 錯誤（編譯不通過）
<?>：支持任意泛型類型
<? extends A>：支持 A 類及其子類（泛型上限）
<? super A>：支持 A 類及其父類（不限于直接父類，泛型下限）

13.7.2 應用案例

public class GenericExtends {
    public static void main(String[] args) {

        Object o = new String("xx");

        //泛型沒有繼承性
        //List<Object> list = new ArrayList<String>();

        //舉例說明下面三個方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型類型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子類
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA類以及AA類的父類，不限于直接父類
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×


        //冒泡排序

        //插入排序

        //....


    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子類
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //說明: List<?> 表示 任意的泛型類型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出時，就是Object
            System.out.println(object);
        }
    }



    // ? super 子類類名AA:支持AA類以及AA類的父類，不限于直接父類，
    //規定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}

13.8 本章作業

1. 編程題 `Homework01.java`（10min）

需求：
定義泛型類 DAO<T>，包含 Map 成員（鍵 String，值 T 類型）。實現以下方法：

public void save(String id, T entity)：保存 T 對象到 Map
public T get(String id)：從 Map 獲取 id 對應對象
public void update(String id, T entity)：替換 Map 中 id 對應內容
public List<T> list()：返回 Map 中所有 T 對象
public void delete(String id)：刪除指定 id 對象

定義 User 類：

包含 private 成員：id（int ）、age（int ）、name（String ）
實現 getter、setter、toString

步驟：

創建 DAO 對象操作 User，調用 save、get、update、list、delete 方法
使用 JUnit 單元測試驗證功能

public class Homework01 {
    public static void main(String[] args) {

    }

    @Test
    public void testList() {
        //說明
        //這里我們給T 指定類型是User
        DAO<User> dao = new DAO<>();
        dao.save("001", new User(1,10,"jack"));
        dao.save("002", new User(2,18,"king"));
        dao.save("003", new User(3,38,"smith"));

        List<User> list = dao.list();

        System.out.println("list=" + list);

        dao.update("003", new User(3, 58, "milan"));
        dao.delete("001");//刪除
        System.out.println("===修改后====");
        list = dao.list();
        System.out.println("list=" + list);

        System.out.println("id=003 " + dao.get("003"));//milan

    }
}
/**
 * 定義個泛型類 DAO<T>，在其中定義一個Map 成員變量，Map 的鍵為 String 類型，值為 T 類型。
 *
 * 分別創建以下方法：
 * (1) public void save(String id,T entity)： 保存 T 類型的對象到 Map 成員變量中
 * (2) public T get(String id)：從 map 中獲取 id 對應的對象
 * (3) public void update(String id,T entity)：替換 map 中key為id的內容,改為 entity 對象
 * (4) public List<T> list()：返回 map 中存放的所有 T 對象
 * (5) public void delete(String id)：刪除指定 id 對象
 *
 * 定義一個 User 類：
 * 該類包含：private成員變量（int類型） id，age；（String 類型）name。
 *
 * 創建 DAO 類的對象， 分別調用其 save、get、update、list、delete 方法來操作 User 對象，
 * 使用 Junit 單元測試類進行測試。
 *
 * 思路分析
 * 1. 定義User類
 * 2. 定義Dao<T>泛型類
 */

public class DAO<T> {//泛型類
    private Map<String, T> map = new HashMap<>();

    public T get(String id) {
        return map.get(id);
    }
    public void update(String id,T entity) {
        map.put(id, entity);
    }
    //返回 map 中存放的所有 T 對象
    //遍歷map [k-v],將map的 所有value(T entity),封裝到ArrayList返回即可
    public List<T> list() {
        //創建 Arraylist
        List<T> list = new ArrayList<>();

        //遍歷map
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            //map.get(key) 返回就是 User對象->ArrayList
            list.add(map.get(key));//也可以直接使用本類的 get(String id)
        }

        return list;
    }
    public void delete(String id) {
        map.remove(id);
    }
    public void save(String id,T entity) {//把entity保存到map
        map.put(id, entity);

    }

}

public class User {
    private int id;
    private int age;
    private String name;

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

13.9 JUnit

13.9.1 為什么需要 JUnit

測試代碼需寫 main 方法，多測試用例時需反復注釋/取消注釋，效率低
JUnit 可簡化測試流程，直接運行單個方法，自動輸出結果

13.9.2 基本介紹

JUnit 是 Java 單元測試框架
多數 Java 開發環境（如 IDEA ）已集成 JUnit

13.9.3 使用步驟

JUnit.java，核心流程：

引入 JUnit 依賴（Maven 或手動添加）
測試類方法上標記 @Test（需導入 org.junit.Test ）
直接運行標記 @Test 的方法，自動執行測試

public class JUnit_ {
    public static void main(String[] args) {
        //傳統方式
        //new JUnit_().m1();
        //new JUnit_().m2();

    }


    @Test
    public void m1() {
        System.out.println("m1方法被調用");
    }

    @Test
    public void m2() {
        System.out.println("m2方法被調用");
    }

    @Test
    public void m3() {
        System.out.println("m3方法被調用");
    }
}

posted @ 2025-08-24 16:20 *珍惜當下* 閱讀(16) 評論(0) 收藏舉報

刷新頁面返回頂部

ming-Infinite-progress

第 13 章泛型

第 13 章泛型

13.1 泛型的理解和好處

13.1.1 看一個需求

13.1.2 使用傳統方法的問題分析

13.1.3 泛型快速體驗-用泛型來解決前面的問題

13.2 泛型的理解和好處

13.2.1 泛型的好處

13.3 泛型介紹

13.4 泛型的語法

13.4.1 泛型的聲明

13.4.2 泛型的實例化

13.4.3 泛型使用舉例

13.4.4 泛型使用的注意事項和細節

13.5 泛型課堂類型

13.5.1 泛型課堂練習題

13.6 自定義泛型

13.6.1 自定義泛型類（難度）

基本語法

注意細節

應用案例 CustomeGeneric.java

13.6.2 自定義泛型接口

基本語法

注意細節

應用實例 CustomInterfaceGeneric.java

13.6.3 自定義泛型方法

基本語法

注意細節

應用案例 CustomMethodGeneric.java

13.6.4 自定義泛型方法（課堂練習）

題目：CustomMethodGenericExercise.java（2min）

分析

13.7 泛型的繼承和通配符

13.7.1 泛型的繼承和通配符說明 GenericExtends.java

13.7.2 應用案例

13.8 本章作業

1. 編程題 Homework01.java（10min）

13.9 JUnit

13.9.1 為什么需要 JUnit

13.9.2 基本介紹

13.9.3 使用步驟

公告

應用案例 `CustomeGeneric.java`

應用實例 `CustomInterfaceGeneric.java`

應用案例 `CustomMethodGeneric.java`

題目：`CustomMethodGenericExercise.java`（2min）

13.7.1 泛型的繼承和通配符說明 `GenericExtends.java`

1. 編程題 `Homework01.java`（10min）