java基礎——泛型

泛型的引入

看下麵這段代碼：

private static int add(int a, int b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static float add(float a, float b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static double add(double a, double b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

如果沒有泛型，要實現不同類型的加法，每種類型都需要重載一個add方法；通過泛型，我們可以復用為一個方法：

private static <T extends Number> double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

泛型中的類型在使用時指定，不需要強制類型轉換（類型安全，編譯器會檢查類型）

下麵這段代碼：

List list = new ArrayList();
list.add("xxString");
list.add(100d);
list.add(new Person());

我們在使用上述list中，list中的元素都是Object類型（無法約束其中的類型），所以在取出集合元素時需要人為的強制類型轉化到具體的目標類型，且很容易出java.lang.ClassCastException`異常。

引入泛型，它將提供類型的約束，提供編譯前的檢查：

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

// list中只能放String, 不能放其它類型的元素

泛型的好處

1、編譯時，檢查添加元素的類型，提高了安全性

2、減少了類型轉換的次數，提高效率

3、不再提示編譯警告

介紹

1.泛型又稱參數化類型，是Jdk5.0出現的新特性，解決數據類型的安全性問題

2.在類聲明或實例化時只要指定好需要的具體的類型即可。

3.Java泛型可以保證如果程式在編譯時沒有發出警告，運行時就不會產生ClassCastException.異常。同時，代碼更加簡潔、健壯

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

代碼舉例：

public class Generic03 {
    public static void main(String[] args) {
        //註意，特別強調：E具體的數據類型在定義Person對象的時候指定，即在編譯期間，就確定E是什麼類型
        Person<String> person = new Person<>("dfdfs");
        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;
         *     }
         *     public void show(){
         *         System.out.println(s.getClass());//顯示s的運行類型
         *     }
         * }
         */

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

        /**
         * Person類相當於下麵這樣子
         * class Person{
         *     Integer s;//E表示s的數據類型，該數據類型在定義Person對象的時候指定，即在編譯期間，就確定E是什麼類型
         *
         *     public Person(Integer s) {//E也可以是參數類型
         *         this.s = s;
         *     }
         *
         *     public Integer f(){//返回類型使用E
         *         return s;
         *     }
         *     public void show(){
         *         System.out.println(s.getClass());//顯示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的運行類型
    }
}

語法

泛型的聲明

interface 介面名{}和class 類名<K,V>{}

說明：

1)其中，T,K,V不代表值，而是表示類型

2)任意字母都可以。常用T表示，是Type的縮寫

泛型的實例化

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

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

泛型使用舉例

需求：

​ 1.創建3個學生對象

​ 2.放入到HashSet中學生對象，使用.

​ 3.放入到HashMap中，要求Key 是String name,Value就是學生對象

​ 4.使用兩種方式遍歷

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

        //第一種遍歷方式，增強for迴圈
        for (Student student:students){
            System.out.println(student);
        }

        //使用泛型方式給HashMap放入3個學生對象
        HashMap<String, Student> hm = new HashMap<>();
        hm.put("milan",new Student("milan",34));
        hm.put("jack",new Student("jack",31));
        hm.put("tom",new Student("tom",30));

        //2.迭代器
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        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());

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

泛型使用註意事項

1.interface 介面名{}和class 類名<K,V>中T,K,V只能是引用類型。如下麵：

List<Integer> list = new ArrayList<Integer>();//這樣寫正確
List<int> list = new ArrayList<int>();//這樣寫錯誤

2.在給泛型指定具體類型後，可以傳入該類型或者其子類類型

3.泛型使用形式

//1.第一種方式
List<Integer> list1 = new ArrayList<Integer>();
//2.第二種方式
List<Integer> Iist2 = new ArrayList<>();

3.如果我們這樣寫List list3=new ArrayList();預設給它的泛型是 E就是Object.,等價於ArrayList