2. 程式人生 > >Java泛型使用的簡單介紹

Java泛型使用的簡單介紹

阿新 • • 發佈：2019-08-10

目錄

  • 一. 泛型是什麼
  • 二. 使用泛型有什麼好處
  • 三. 泛型類
  • 四. 泛型介面
  • 五. 泛型方法
  • 六. 限定型別變數
  • 七. 泛型萬用字元
    • 7.1 上界萬用字元
    • 7.2 下界萬用字元
    • 7.3 無限定萬用字元
  • 八. 總結

一. 泛型是什麼

“泛型”，顧名思義，“泛指的型別”。我們提供了泛指的概念，但具體執行的時候卻可以有具體的規則來約束，比如我們用的非常多的ArrayList就是個泛型類，ArrayList作為集合可以存放各種元素，如Integer, String，自定義的各種型別等，但在我們使用的時候通過具體的規則來約束，如我們可以約束集合中只存放Integer型別的元素，如List<Integer> iniData = new ArrayList<>()

。

二. 使用泛型有什麼好處

以集合來舉例，使用泛型的好處是我們不必因為新增元素型別的不同而定義不同型別的集合，如整型集合類，浮點型集合類，字串集合類，我們可以定義一個集合來存放整型、浮點型，字串型資料，而這並不是最重要的，因為我們只要把底層儲存設定了Object即可，新增的資料全部都可向上轉型為Object。 更重要的是我們可以通過規則按照自己的想法控制儲存的資料型別。

我們以ArrayList為例，假如我們要將本月截至今天的日期放到ArrayList中，如果我們不使用泛型，此時我們定義一個ArrayList.

List monthDays = new ArrayList();

我們向其中加入1號到4號日期

public static List addMonthDays(){
    List monthDays = new ArrayList();
    monthDays.add(LocalDate.now().withDayOfMonth(1));
    monthDays.add(LocalDate.now().withDayOfMonth(2));
    monthDays.add(LocalDate.now().withDayOfMonth(3));
    monthDays.add(new Date());
    return monthDays;
}

這樣有沒有問題？大家也看出來了，當然有，雖然都可以表示日期，但卻用了Date，LocalDate，我們呼叫方法直接打印出來，就是這樣

public static void main(String[] args) {
    List monthDays = addMonthDays();
    for(Object day : monthDays){
        System.out.println(day);
    }
}
2019-08-01
2019-08-02
2019-08-03
Sun Aug 04 10:27:10 CST 2019

我們肯定不想要這樣的結果，我們想要的是

2019-08-01
2019-08-02
2019-08-03
2019-08-04

如果儲存的元素型別只是這兩種（假如我們知道），這個時候我們就手動判斷一下

public static void main(String[] args) {
    List monthDays = addMonthDays();
    for(Object day : monthDays){
        if (day instanceof Date){
            Date date = (Date) day;
            System.out.println(LocalDate.of(date.getYear(), date.getMonth(), date.getDay()));
        }else {
            System.out.println(day);
        }
    }
}

這個時候我們就可以達成上述目的了，但大家也知道，這種寫法問題問題很大

  1. 我們無法控制儲存的元素到底是否和日期相關，如我們儲存了“1”，65536等非日期，定義的方法也不會報錯，但在呼叫進行型別轉換的時候必然會報錯；
  2. 我們不知道集合中到底儲存了哪些型別的元素，比如還有“2019/08/04”這種日期字串、java.sql.Date這種型別呢，我們很難保證可以窮盡；
  3. 程式碼過於複雜，太難維護；

這時泛型就提供了很好的解決方案，從源頭上就制定好規則，只能新增LocalDate型別，那麼上述的問題就都得以解決了。

public static List<LocalDate> addFormatMonthDays(){
    List<LocalDate> monthDays = new ArrayList<>();
    monthDays.add(LocalDate.now().withDayOfMonth(1));
    monthDays.add(LocalDate.now().withDayOfMonth(2));
    monthDays.add(LocalDate.now().withDayOfMonth(3));
    monthDays.add(new Date());//這個程式碼在編譯期間就無法通過了
    return monthDays;
}

不僅提高了程式碼的可讀性，一眼即可看出我們儲存的是LocalDate型別。同時編譯器也可很好的利用該資訊，編譯期間就可進行型別檢查，保證了安全性，在get的時候，無需進行強制型別轉換。

三. 泛型類

為使類適應更多的情況，具備更好的擴充套件性，我們可以將其設定為泛型類，即具有一個或多個型別變數的類，寫法如下：

public class ClassName<泛型標識，可以是字母、中文字元等，不過一般用大寫英文字元> {
    private 泛型標識 property;
}

對於泛型識別符號，一般有一些約定俗稱的寫法，如果是表示集合的元素型別，一般用字母E，如我們常用的ArrayList，public class ArrayList<E>，我們自定義如下：

//車庫
public class Garage<E> {
    //向車庫中新增車
    public void add(E car){
        //...
    }
}

我們還可以用字元K和V表示關鍵字和值的型別，如我們常用的HashMap，public class HashMap<K,V>，我們也可以自定義如下：

//對映關係
//K,V: 蔬菜,是否有機; 水果,產地; 服裝,型別; 汽車,品牌
public class Mapping<K, V> {
    
    private K key;
    
    private V value;
}

我們還經常用一個字元T表示型別

public class Person<T> {
    private T t;
    public Person(T t){
        this.t = t;
    }
    public void run(){
        System.out.println(t);
    }
}

如何使用泛型類，型別如何例項化，我們只需要保證傳入的實參型別和泛型引數型別相同即可。

//正常用法
Person<String> s1 = new Person<String>("張三");
//jdk7.0後可以省略後面的引數型別
Person<String> s2 = new Person<>("張三");
s2.run();

//當然泛型的定義是可以幫助我們按照某種規則去做事，如果不做限制，也不會編譯錯誤，但泛型就毫無意義了
Person t = new Person(111);
t.run();

//泛型的型別不能是八大基本型別，下面會編譯出錯
Person<int> s = new Person<>(1);

四. 泛型介面

泛型介面和泛型類的定義基本一致，定義如下：

public interface Person<T> {
    public T parent();
    public String eat();
}

當我們定義了一個類要實現該介面時，那麼該類的泛型型別必須和介面類的泛型型別一致，未傳遞實參的情況下，繼續使用泛型型別T，傳遞了實參的情況下，泛型型別必須使用實參型別

public class Teacher<T> implements Person<T> {
    @Override
    public T parent() {
        return null;
    }

    @Override
    public String eat() {
        return null;
    }
}
//Teacher不必再定義型別了，因為泛型型別在Person處已經定義好了
public class Teacher implements Person<Integer> {
    //這裡的返回型別必須為Integer，否則必須出錯
    @Override
    public Integer parent() {
        return null;
    }

    @Override
    public String eat() {
        return null;
    }
}

五. 泛型方法

泛型方法可以定義在普通類和泛型類中，比如泛型類更為常用，一般能用泛型方法解決的問題優先使用泛型方法而不使用泛型類，型別變數放在修飾符的後面，如public static ,public final等的後面。

public class Teacher {
    public static <T> T println(T t){
        System.out.println(t);
        return t;
    }
}

呼叫很簡單，很一般方法呼叫是一樣的，更方便的是型別不像一般方法做了限定。

String s = Teancher.println("str");

另外需要說明的是，定義在泛型類中的泛型方法的泛型變數之間是沒有關係的，如這樣的程式碼

public class Teacher<T> {
    T teacher;
    public Teacher(T t){
        this.teacher = t;
    }
    public <T> T println(T t){
        System.out.println(t);
        return t;
    }
}
Teacher<String> teacher = new Teacher<>("張三");
Integer in = teacher.println(123456);

類泛型型別為String，方法的泛型型別為Integer，雖然都是用T來表示的。

同時關於泛型方法需要說明的是：

在修飾符public xx與方法名之間非常重要，有< T >這樣的才算是泛型方法；僅僅使用了泛型變數並不算是泛型方法。

六. 限定型別變數

不論是泛型類還是泛型方法，目前來說其實都是沒有做型別限定，無論我們傳遞什麼樣型別的變數進去都可以，因為我們在處理邏輯中並沒有使用到該型別特有的東西（成員變數、方法等）。假如我們想傳遞的引數型別僅僅是某個大類（父類）下面的一些小類（子類），那麼怎麼做呢？

public class ArrayFlag {
    public static <T> T getMax(T[] array){
        if(array == null || array.length == 0){
            return null;
        }
        T maxValue = array[0];
        for(int i = 0; i < array.length; i++){
            if(array[i].compareTo(maxValue) > 0){
                maxValue = array[i];
            }
        }
        return maxValue;
    }
}

大家也看到了我們在getMax方法中使用了compareTo方法進行比較，但如果我們傳入的型別T沒有compareTo方法呢，豈不是要報錯，因此我們需要做限定，只要限定了是Comparable介面的必然具備compareTo方法，那麼改造後就成了這樣

public class ArrayFlag {
    public static <T extends Comparable> T getMax(T[] array){
        if(array == null || array.length == 0){
            return null;
        }
        T maxValue = array[0];
        for(int i = 0; i < array.length; i++){
            if(array[i].compareTo(maxValue) > 0){
                maxValue = array[i];
            }
        }
        return maxValue;
    }
}

同時需要說明的是，此處用的是extends關鍵字，extends在這裡是表示的是綁定了Comparable介面及其子型別，是“繫結、限定”的意思，非“繼承”的意思，後面也可以是介面或者類，如果有多個限制，可以使用&分隔，如：

public static <T extends Comparable & Serializable> T getMax(T[] array)

七. 泛型萬用字元

舉個例子，定義了一個書籍類和一個小說類

//定義了一個書籍類
public class Book {}
//定義了一個小說書籍類繼承書籍類
public class Novel extends Book {}

我們再定義一個書櫃類用來裝書籍以及小說

//定義了一個書櫃類用來裝書
public class Bookcase<T> {
    T b; 
    public Bookcase(T t){
        this.b = t;
    }
    public void set(T t) {
        b=t;
    } 
    public T get() {
        System.out.println(b.getClass());
        return b;
    }
}

下面我們就用書櫃來裝小說

//以前的寫法，無法編譯通過，提示Incompatible types, Required Book Found Novel
Bookcase<Book> bc = new Bookcase<Novel>(new Novel());

但在jdk7.0後，new Bookcase的時候是可以不用給出泛型型別的，省略的型別可以從變數的型別推斷得出，因此如果下面這種寫法

Bookcase<Book> bc = new Bookcase<>(new Novel());
System.out.println(bc.getClass());
bc.get();

此時可以編譯通過，我們執行後得出的結果是：

class generic.Bookcase
class generic.Novel

當然我們還可以通過萬用字元來解決該問題，萬用字元包括以下幾種：

上界萬用字元、下界萬用字元、無限定萬用字元

7.1 上界萬用字元

上界萬用字元定義方式如下：用extends 關鍵字，含義是該書櫃只能放置小說類書籍（如什麼都市小說、愛情小說、玄幻小說都可以），但不能放置父類書籍、其他類如史書、職場類書籍、財經類書籍等，是在使用的時候進行限定，如：

Bookcase<? extends Book> bc = new Bookcase<Novel>(new Novel());

這種定義方式就不會編譯錯誤了。另外關於上界萬用字元的特點，對上有限制，根據java多型向上造型的原則，不適合頻繁插入資料，適合頻繁讀取資料的場景。

7.2 下界萬用字元

下界萬用字元定義方式如下：用super關鍵字，含義就是書櫃放置設定了下限，我們只能放置Book書籍以及Novel書籍，卻無法再將細分的都市小說、愛情小說類書籍放進去

Bookcase<? super Novel> bc = new Bookcase<Novel>(new Novel());

另外關於下界萬用字元的特點，和上界萬用字元正好相反，不適合頻繁讀取資料，適合頻繁插入資料的場景。

7.3 無限定萬用字元

無限定萬用字元意味著可以使用任何物件，因此使用它類似於使用原生型別。但它是有作用的，原生型別可以持有任何型別，而無限定萬用字元修飾的容器持有的是某種具體的型別。

舉個例子：

List<?> list = new ArrayList<>();
//無法編譯通過
list.add(new Object());

//下面這樣的卻可以新增任何型別
List<Object> list = new ArrayList<>();
list.add(new Object());

再說一下< T > 和< ? >之間的區別，初看好像他們都可以表示泛型變數，都可以extends，但它們確實有不同的使用場景

  • 型別引數< T >宣告一個泛型類或泛型方法
  • 無限定萬用字元< ? >使用泛型類或泛型方法

八. 總結

泛型在java中可以說很常用，我們前面提到的集合類，如ArrayList，HashSet，以及Map都使用到了泛型，泛型也是也是我們再進行一些元件封裝經常用到的，本文主要介紹了泛型基本概念，使用泛型的好處，泛型類、介面、方法、萬用字元的簡單介紹以及使用方法，最後泛型一般和反射集合使用，通過泛型可以進行型別的靈活傳遞，通過反射可獲取到實體以及類的資料資訊，從而實現一些框架、元件的封裝，若有不對之處，請批評指正，望共同進步，謝

相關推薦

java 泛型簡單使用

ava nbsp images 簡單使用 es2017 logs alt ima 泛型 java 泛型簡單使用

Java泛型使用的簡單介紹

目錄 一. 泛型是什麼 二. 使用泛型有什麼好處 三. 泛型類 四. 泛型介面 五. 泛型方法 六. 限定型別變數 七. 泛型萬用字元 7.1

Java 泛型 介紹

.class 為什麽 his 能夠 不同 rec args abstract pub 　　為什麽需要泛型？ 1 public class GenericTest { 2 3 public static void main(String[] args) {

java集合，泛型簡單總結

容易 對象 並且 集合 需要 api文檔 array object 類型轉換 1.set中裝的對象是沒順序不可以重復。重復的判斷：只要兩個對象equals相等就行了。（要理解的是，並非重復了就報錯，只是存儲時候只有一個，輸出的時候只會輸出一個。） 2.list中的數據對象有

java泛型的基本介紹和使用

java現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要好好的研究下。一、泛型的基本概念 泛型的定義：泛型是JDK 1.5的一項新特性，它的本質是參數化類型（Parameterized Type）的應用，也就是說

corajava--簡單總結java泛型的應用

原文以及參考部落格： 泛型的定義 按照百度百科的介紹，泛型是Java SE 1.5的新增特性，泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面、泛型方法。泛型是具有佔位符（型別引數）

java泛型（一）、泛型的基本介紹和使用

 轉載地址  http://m.blog.csdn.net/article/details?id=7864531 現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要好好的研究

Java泛型（一） 泛型的基本使用和介紹

轉載自：http://blog.csdn.net/lonelyroamer/article/details/7864531 現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要

java泛型程式設計——定義簡單泛型類+泛型方法

【0】README 0.1） 本文描述+原始碼均 轉自 core java volume 1， 旨在理解 java泛型程式設計 的 定義泛型類+泛型方法的知識； 【1】一個泛型類： 就是具有一個或多個型別變數的類； 1.1）看個荔枝： publi

Java泛型擦除

類型信息 png ive over tool 創建 edit sid 註意點 Java泛型擦除： 什麽是泛型擦除？ 首先了解一下什麽是泛型？我個人的理解：因為集合中能夠存儲隨意類型的對象。可是集合中最先存儲的對象類型一旦確定後，就不能在存儲其它類型的

Java 泛型

object java 信息 1、泛型的由來　　我們先看下面這段代碼：1234567891011121314 List list = new ArrayList();list.add(24); //向集合中添加一個 Integer 類型的數據list.add("Tom");

Java,泛型類型通配符和C#對照

size list ack ace arr 類型通配符 語法 ++ net c#的泛型沒有類型通配符,原因是.net的泛型是CLR支持的泛型,而Java的JVM並不支持泛型,僅僅是語法糖,在編譯器編譯的時候都轉換成object類型 類型通配符在java中表示的是泛型

Java泛型詳解

對象數組 整形 泛型方法 tty 接受 一個 div -m color 泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。 假定我們有這樣一個需求：寫一個排序方法，能夠對整形數組、字符串數組甚至其他任何類型的數組進行排序，該如何實現？ 答案是可以使用 Ja

JAVA泛型（轉）

強制 off 實例 emp 思想 void 成了 意義 依然 一. 泛型概念的提出（為什麽需要泛型）？ 首先，我們看下下面這段簡短的代碼: 1 public class GenericTest { 2 3 public static void

java泛型

car .net arm man blog rman html http archive http://www.cnblogs.com/lwbqqyumidi/p/3837629.html http://blog.csdn.net/sunxianghuang/article

Java泛型與集合筆記

第二章 情況 參數 編譯器 類型擦除 多個參數 一個 each ava 第一章 Java的泛型為了兼容性和防止代碼爆炸，在編譯成字節碼時會進行類型擦除，編譯器自動添加代碼做類型轉換（用到List<Integer>的地方用Integer來做轉換），自動做裝箱拆箱，

Java泛型 VS C#泛型 （偽泛型 VS 真泛型）

功能 方法表 語法 一個 class msil 虛方法 strong 反射 一、泛型的本質 泛型是參數化類型的應用，操作的數據類型不限定於特定類型，可以根據實際需要設置不同的數據類型，以實現代碼復用。 二、Java泛型 Java 泛型是Java1.5新增的特性，JVM並

java泛型中<?>和<T>區別

類型 父類 定義 ext 方法 oid tor 接收 通配符 public static void printColl(ArrayList<?> al){ Iterator<?> it = al.iterator();

第10篇-JAVA 集合框架-JAVA 泛型

java集合框架 java泛型 第10篇-JAVA 集合框架-JAVA 泛型每篇一句 ：所有的不甘，都是因為還心存夢想初學心得： 不是每件事都註定會成功，但是每件事都值得一試(筆者：JEEP/711)[JAVA筆記 | 時間:2017-04-15| JAVA 集合框架/JAVA 泛型 ]1.JAVA

泛型深入--java泛型的繼承和實現、泛型擦除

部分 end father 沒有 接口 子類 set int nal 泛型實現類： package generic; /** * 泛型父類：子類為“富二代”：子類的泛型要比父類多 * 1，保留父類的泛型-->子類為泛型類