JavaSE泛型

泛型出現的背景
在集合中使用泛型
自定義泛型結構
- 泛型類，泛型接口的使用
- 泛型類、泛型接口的注意點
- 泛型方法的使用
泛型在繼承上的展現
通配符
- 通配符的使用
- 有限制條件的通配符的使用
泛型應用舉例
練習
參考資料

泛型出現的背景

泛型：标簽 jdk 5.0 新增

所謂泛型，就是允許在定義類、接口時通過一個辨別表示類中某個屬性的類型或者是某個方法的傳回值及參數類型。這個類型參數将在使用時（例如，繼承或實作這個接口，用這個類型聲明變量、建立對象時）确定（即傳入實際的類型參數，也稱為類型實參）。

JDK1.5改寫了集合架構中的全部接口和類，為這些接口、類增加了泛型支援，進而可以在聲明集合變量、建立集合對象時傳入類型實參。

package com.atguigu.java;

import org.junit.Test;

import java.util.ArrayList;

public class GenericTest {
    //在集合中使用泛型之前的情況
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放學生的成績
        list.add(78);
        list.add(87);
        list.add(90);
        list.add(83);

        //問題一:類型不安全
        list.add("Tom");
        
        for(Object score : list){
            //問題二：強轉時,可能出現異常
            int stuScore = (Integer)score;
            System.out.println(stuScore);
        }
    }
}

在集合中使用泛型

總結：

集合接口或集合類在 jdk 5.0 時都修改為帶泛型的結構
在執行個體化集合類時，可以指明具體的泛型類型
指明完以後，在集合類或接口中凡是定義類或接口時，内部結構 (比如：方法，構造器，屬性等) 使用到類的泛型的位置。都指定為執行個體化的泛型類型

比如： add(E , e) ---- 執行個體化以後：add(Integer , e)
注意點：泛型的類型必須是類，不能是基本資料類型，需要用到基本資料類型的地方，拿包裝類代替
如果執行個體化時，沒有指明泛型的類型。預設類型為 java.long.Object 類型

package com.atguigu.java;

import org.junit.Test;

import java.util.*;

public class GenericTest {

    //在集合中使用泛型的情況
    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(99);
        list.add(80);
        list.add(75);
        list.add(84);
        //編譯時就會進行類型檢查,保證資料的安全
        //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>();

        map.put("Tom",86);
        map.put("Mack",90);
        map.put("Jerry",78);

        //泛型的嵌套
        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);
        }

    }
}

自定義泛型結構

泛型類，泛型接口的使用

package com.atguigu.java;

import org.junit.Test;

public class GenericTest1 {

    @Test
    public void test1(){
        //如果定義了泛型類,執行個體化沒有指明類的泛型,則認為此泛型類型為 Object類型
        //要求：如果大家定義的類是帶泛型的,建議在執行個體化時要指明類的泛型

        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建議：執行個體化時要指明類的泛型
        Order<String> order1 = new Order<String>("Tom",1008,"alter");
        order1.setOrderT("AA:hello");
    }

    @Test
    public void test2(){
        SubOrder sub = new SubOrder();
        //由于子類繼承帶泛型的父類時,指明了泛型類型.則執行個體化子類對象時,
        //不再需要指明泛型
        sub.setOrderT(1122);

        SubOrder1<String> sub1 = new SubOrder1<String>();
        sub1.setOrderT("jack");
    }
}

package com.atguigu.java;

public class Order<T> {

    String orderName;
    int orderID;

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

    T orderT;


    public Order() {

    }

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

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

    public T getOrderT(){
        return this.orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderID=" + orderID +
                ", orderT=" + orderT +
                '}';
    }
}

package com.atguigu.java;

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

package com.atguigu.java;

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

泛型類、泛型接口的注意點

泛型類可能有多個參數，此時應将多個參數一起放在尖括号内。比如：<E1,E2,E3>

泛型類的構造器如下：public GenericClass(){}。而下面是錯誤的：public GenericClass(){}

執行個體化後，操作原來泛型位置的結構必須與指定的泛型類型一緻

泛型不同的引用不能互相指派。

盡管在編譯時ArrayList和ArrayList是兩種類型，但是，在運作時隻有一個ArrayList被加載到JVM中。

泛型如果不指定，将被擦除，泛型對應的類型均按照Object處理，但不等價于Object。經驗：泛型要使用一路都用。要不用，一路都不要用

jdk1.7，泛型的簡化操作：ArrayList flist = new ArrayList<>();

泛型的指定中不能使用基本資料類型，可以使用包裝類替換。

在類/接口上聲明的泛型，在本類或本接口中即代表某種類型，可以作為非靜态屬性的類型、非靜态方法的參數類型、非靜态方法的傳回值類型。但在靜态方法中不能使用類的泛型

異常類不能是泛型的

父類有泛型，子類可以選擇保留泛型也可以選擇指定泛型類型：

子類不保留父類的泛型：按需實作
- 沒有類型擦除
- 具體類型
子類保留父類的泛型：泛型子類
- 全部保留
- 部分保留

class Father<T1, T2> {
}
// 子類不保留父類的泛型
// 1)沒有類型 擦除
class Son1 extends Father {// 等價于class Son extends Father<Object,Object>{
}
// 2)具體類型
class Son2 extends Father<Integer, String> {
}
// 子類保留父類的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

泛型方法的使用

package com.atguigu.java;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader;

import java.util.ArrayList;
import java.util.List;

//
public class Order<T> {

    String orderName;
    int orderID;

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

    T orderT;


    public Order() {

    }

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

    //如下的三個方法都不是泛型方法
    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    public T getOrderT(){
        return this.orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderID=" + orderID +
                ", orderT=" + orderT +
                '}';
    }

    //泛型方法：在方法中出現了泛型的結構,泛型參數與類的泛型參數沒有任何關系
    //換句話說：泛型方法所屬的類 與 泛型類 之間沒有關系
    //泛型方法,可以聲明為靜态的.原因：泛型參數是在調用方法時确定的,并非是在執行個體化類是确定
    public <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<E>();
        for(E e:list){
            list.add(e);
        }
        return list;
    }
}

package com.atguigu.java;

import org.junit.Test;

import java.util.List;

public class GenericTest1 {

    //測試泛型方法
    @Test
    public void test3(){
        Order<String> o1 = new Order<String>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在調用時,指明泛型參數的類型
        List<Integer> integers = o1.copyFromArrayToList(arr);

        System.out.println(integers);
    }
}

泛型在繼承上的展現

雖然類A 是類B 的父類，但是 G 和 G

二者不具備子父類關系，二者是并列關系

補充：類A 是類B 的父類，A 是 B 的父類

package com.atguigu.java;

import org.junit.Test;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;

public class GenericTest2 {
    //泛型在繼承方面的展現
    @Test
    public void test1(){
        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;

        List<Object> list1 = null;
        List<String> list2 = null;
        //此時的 list1 和 list2 的類型不具有子父類關系
        //編譯不通過
        //list1 = list2;
    }

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

通配符

通配符的使用

通配符：?

類A 是類B 的父類，G 和 G

二者是沒有關系的，二者共同的父類是：G<?>

package com.atguigu.java;

import org.junit.Test;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericTest2 {

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

        List<?> list = null;

        list = list1;
        list = list2;

        print(list1);
        print(list2);
    }

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

    @Test
    public void test4(){
        List<?> list = null;

        List<String> list1 = new ArrayList<>();
        list1.add("AA");
        list1.add("BB");
        list1.add("CC");
        list = list1;

        //添加(寫入)：對于 List<?> 就不能向其内部添加資料
        //null 除外
        //編譯錯誤  list.add("DD");

        list.add(null);

        //擷取(讀取)：允許正常讀取資料,讀取的資料類型為 Object
        Object o = list.get(0);
        System.out.println(o);

    }
}

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

package com.atguigu.java;

import org.junit.Test;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericTest2 {
    
    /*
    有限制條件的通配符的使用、
    ? extends Person:可以接受 [ 負無窮 -- Person) 之間的對象
    ? super Person: 可以接受 [ Person -- 正無窮 ) 之間對象
     */
    @Test
    public void test5(){
        // 前提 Student entends Person
        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 類 接受

        list2 = list4;
        Object obj = list2.get(0);
        //不能采用 Person 類 接受

        //寫入資料:隻能寫入 較小類的 資料
        //list1 的範圍無法寫入資料

        //list2 隻能接受  [ 負無窮 -- Person) 的資料
        list2.add(new Person());
        list2.add(new Student());
        
    }
}

泛型應用舉例

定義個泛型類 DAO，在其中定義一個 Map 成員變量，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 中 key 為 id 的内容,改為 entity 對象

public List list()：傳回 map 中存放的所有 T 對象

public void delete(String id)：删除指定 id 對象

定義一個 User 類：

該類包含：private 成員變量（int 類型） id，age；（String 類型）name。

定義一個測試類：

建立 DAO 類的對象，分别調用其 save、get、update、list、delete 方法來操作 User 對象，

使用 Junit 單元測試類進行測試。

package com.atguigu.exer;

import java.util.*;

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

    //儲存 T 類型的對象到 Map 成員變量中
    public void save(String id,T entity){
        map.put(id,entity);
    }

    //從 map 中擷取 id 對應的對象
    public T get(String id){
        T obj = map.get(id);
        return obj;
    }

    //替換 map 中 key 為 id 的内容,改為 entity 對象
    public void update(String id,T entity){
        if(map.containsKey(id)){
            map.put(id,entity);
        }
    }

    //傳回 map 中存放的所有 T 對象
    public List<T> list(){
        //錯誤的
        //Collection<T> values = map.values();
        //return (List<T>) values;

        //正确的
        List<T> list = new ArrayList<T>();
        Collection<T> values = map.values();

        for(T t : values){
            list.add(t);
        }
        return list;
    }

    //删除指定 id 對象
    public void delete(String id){
        map.remove(id);
    }
}

package com.atguigu.exer;

public class User {

    private int id;
    private int age;
    private String name;

    public User() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

package com.atguigu.exer;

import org.junit.Test;

import java.util.List;

public class DAOTest {
    @Test
    public void test1(){
        DAO<User> dao = new DAO<User>();

        dao.save("1001",new User(1001,24,"周傑倫"));
        dao.save("1002",new User(1002,34,"昆淩"));
        dao.save("1003",new User(1002,29,"蔡依林"));

        dao.update("1003",new User(1003,30,"範文山"));

        dao.delete("1002");

        List<User> list = dao.list();
        System.out.println(list);
    }

}

練習

開發一個泛型Apple類，要求有一個重量屬性weight在測試類中執行個體化不同的泛型對象，要求對象a1的這一屬性是String類型，對象a2的這一屬性是Integer型，a3的這一屬性是Double型。分别為a1，a2，a3的重量屬性指派為：”500克”，500,500.0，在測試類中通過對象調用通路器得到屬性值并輸出。另外思考，為什麼a2和a3的屬性需要是Integer和Double而不是int和double？

package com.atguigu.com;
public class AppleTest{
    public static void main(String[] args) {
        Apple<String> a1 = new Apple<String>("500克");
        System.out.println(a1.weight);

        Apple<Integer> a2 = new Apple<Integer>(500);
        System.out.println(a2.weight);

        Apple<Double> a3 = new Apple<Double>(500.0);
        System.out.println(a3.weight);
    }
}

class Apple<T> {
    T weight;

    public Apple(T weight){
        this.weight = weight;
    }
}

500克
500
500.0

泛型的類型必須是類，不能是基本資料類型，需要用到基本資料類型的地方，拿包裝類代替

參考資料

尚矽谷-Java零基礎教程

JavaSE泛型泛型出現的背景在集合中使用泛型自定義泛型結構泛型在繼承上的展現通配符泛型應用舉例練習參考資料

JavaSE泛型

泛型出現的背景

在集合中使用泛型

自定義泛型結構

泛型類，泛型接口的使用

泛型類、泛型接口的注意點

泛型方法的使用

泛型在繼承上的展現

通配符

通配符的使用

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

泛型應用舉例

練習

參考資料

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method