淺談Java泛型<最通俗易懂的講解>

時間  2019-11-08
標籤 淺談 java 通俗易懂 講解 欄目 Java 简体版
原文   原文鏈接

1、概述java

泛型在Java中有很重要的地位，在面相對象編程及各類設計模式中有很是普遍的應用。編程

什麼是泛型？爲何要使用泛型？設計模式

泛型，即「參數化類型」。一提到參數，定義方法時有形參，調用方法時傳遞實參。數組

泛型的本質是爲了參數化類型（在不建立新的類型的狀況下，經過泛型指定的不一樣類型來控制形參具體限制的類型）。app

2、具體實例dom

package OSChina.Genericity;

import java.util.Random;

public class FruitGenerator<T> implements  Generator<T>{
    String[] fruits = new String[]{"apple","banana","Pear"};
    @Override
    public String next(T t) {
        Random random = new Random();
        System.out.println(fruits[random.nextInt((int)t)]);
        return fruits[random.nextInt((int)t)];
    }

    public static void main(String[] args) {
        FruitGenerator ff = new FruitGenerator();
        ff.next(3);
    }
}

崩潰了。ide

然而爲何呢？測試

ArrayList能夠存聽任意類型，例子中添加了一個String類型，添加了一個Integer類型，再使用時都以String的方式使用，所以程序崩潰了。爲了解決相似這樣的問題（在編譯階段就能夠解決），泛型應運而生。ui

咱們將第一行聲明初始化list的代碼更改一下，編譯器會在編譯階段就可以幫咱們發現相似這樣的問題。this

定義泛型以後，編譯都通不過了，要的就是這個效果！

3、特性

泛型只在編譯階段有效。看下面的代碼：

package OSChina.Genericity;

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

public class Test2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        List<Integer> list2 = new ArrayList<Integer>();
        System.out.println(list.getClass());
        System.out.println(list.getClass()==list2.getClass());
    }
}

4、泛型的使用

泛型有三種使用方式，分別爲：泛型類、泛型接口、泛型方法

（一）泛型類

package OSChina.Genericity;

//此處T能夠隨便寫爲任意標識，常見的如T、E、K、V等形式的參數經常使用於表示泛型
//在實例化泛型類時，必須指定T的具體類型
public class Generic<T> {
    //key這個成員變量的類型爲T,T的類型由外部指定
    private T key;
    //泛型構造方法形參key的類型也爲T，T的類型由外部指定
    public Generic(T key){
        this.key = key;
    }
    //泛型方法getKey的返回值類型爲T，T的類型由外部指定
    public T getKey(){
        return key;
    }

    public static void main(String[] args) {
        //泛型的類型參數只能是類類型（包括自定義類），不能是簡單類型
        //傳入的實參類型需與泛型的類型參數類型相同，即爲Integer.
        Generic<Integer> genericInteger = new Generic<Integer>(123456);
        //傳入的實參類型需與泛型的類型參數類型相同，即爲String.
        Generic<String> genericString = new Generic<String>("江疏影");
        System.out.println("泛型測試，key is "+genericInteger.getKey());
        System.out.println("泛型測試，key is "+genericString.getKey());
    }
}

泛型參數就是隨便傳的意思！

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

instanceof不容許存在泛型參數

如下代碼不能經過編譯，緣由同樣，泛型類型被擦除了

（二）泛型接口

泛型接口與泛型類的定義及使用基本相同。泛型接口常被用在各類類的生產器中，能夠看一個例子：

//定義一個泛型接口
public interface Generator<T> {
    public T next();
}

當實現泛型接口的類，未傳入泛型實參時：

/**
 * 未傳入泛型實參時，與泛型類的定義相同，在聲明類的時候，需將泛型的聲明也一塊兒加到類中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 若是不聲明泛型，如：class FruitGenerator implements Generator<T>，編譯器會報錯："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

當實現泛型接口的類，傳入泛型實參時：

package OSChina.Genericity;

import java.util.Random;

public class FruitGenerator implements  Generator<String>{
    String[] fruits = new String[]{"apple","banana","Pear"};
    @Override
    public String next() {
        Random random = new Random();
        System.out.println(fruits[random.nextInt(3)]);
        return fruits[random.nextInt(3)];
    }

    public static void main(String[] args) {
        FruitGenerator ff = new FruitGenerator();
        ff.next();
    }
}

（三）泛型通配符

咱們知道integer是number的一個子類，同時Generic<Integer>和Generic<Number>其實是相同的一種基本類型。那麼問題來了，在使用Generic<Number>做爲形參的方法中，可否使用Generic<Integer>的實例傳入呢？在邏輯上相似於Generic<Number>和Generic<Integer>是否能夠當作具備父子關係的泛型類型呢？

爲了弄清楚這個問題，咱們使用Generator<T>這個泛型類繼續看下面的例子：

public void showKeyValue(Generic<Number> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gNumber);

// showKeyValue這個方法編譯器會爲咱們報錯：Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);

經過提示信息咱們能夠看到Generic<Integer>不能被看做爲Generic<Number>的子類。由此能夠看出:同一種泛型能夠對應多個版本（由於參數類型是不肯定的），不一樣版本的泛型類實例是不兼容的。

回到上面的例子，如何解決上面的問題？總不能爲了定義一個新的方法來處理Generic<Integer>類型的類，這顯然與java中的多臺理念相違背。所以咱們須要一個在邏輯上能夠表示同時是Generic<Integer>和Generic<Number>父類的引用類型。由此類型通配符應運而生。

咱們能夠將上面的方法改一下：

public void showKeyValue(Generic<?> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

類型通配符通常是使用？代替具體的類型參數，注意了，此處？是類型實參，而不是類型形參。此處的？和Number、String、Integer同樣都是一種實際的類型，能夠把？當作全部類型的父類。是一種真實的類型。

能夠解決當具體類型不肯定的時候，這個通配符就是 ?  ；當操做類型時，不須要使用類型的具體功能時，只使用Object類中的功能。那麼能夠用 ? 通配符來表未知類型。

（四）泛型方法

泛型類，是在實例化類的時候指明泛型的具體類型；

泛型方法，是在調用方法的時候指明泛型的具體類型。

/**
 * 泛型方法的基本介紹
 * @param tClass 傳入的泛型實參
 * @return T 返回值爲T類型
 * 說明：
 *     1）public 與 返回值中間<T>很是重要，能夠理解爲聲明此方法爲泛型方法。
 *     2）只有聲明瞭<T>的方法纔是泛型方法，泛型類中的使用了泛型的成員方法並非泛型方法。
 *     3）<T>代表該方法將使用泛型類型T，此時才能夠在方法中使用泛型類型T。
 *     4）與泛型類的定義同樣，此處T能夠隨便寫爲任意標識，常見的如T、E、K、V等形式的參數經常使用於表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}
Object obj = genericMethod(Class.forName("com.test.test"));

一、泛型方法的基本用法

public class GenericTest {
   //這個類是個泛型類，在上面已經介紹過
   public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想說的實際上是這個，雖然在方法中使用了泛型，可是這並非一個泛型方法。
        //這只是類中一個普通的成員方法，只不過他的返回值是在聲明泛型類已經聲明過的泛型。
        //因此在這個方法中才能夠繼續使用 T 這個泛型。
        public T getKey(){
            return key;
        }

        /**
         * 這個方法顯然是有問題的，在編譯器會給咱們提示這樣的錯誤信息"cannot reslove symbol E"
         * 由於在類的聲明中並未聲明泛型E，因此在使用E作形參和返回值類型時，編譯器會沒法識別。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 這纔是一個真正的泛型方法。
     * 首先在public與返回值之間的<T>必不可少，這代表這是一個泛型方法，而且聲明瞭一個泛型T
     * 這個T能夠出如今這個泛型方法的任意位置.
     * 泛型的數量也能夠爲任意多個 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //固然這個例子舉的不太合適，只是爲了說明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //這也不是一個泛型方法，這就是一個普通的方法，只是使用了Generic<Number>這個泛型類作形參而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型測試","key value is " + obj.getKey());
    }

    //這也不是一個泛型方法，這也是一個普通的方法，只不過使用了泛型通配符?
    //同時這也印證了泛型通配符章節所描述的，?是一種類型實參，能夠看作爲Number等全部類的父類
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型測試","key value is " + obj.getKey());
    }

     /**
     * 這個方法是有問題的，編譯器會爲咱們提示錯誤信息："UnKnown class 'E' "
     * 雖然咱們聲明瞭<T>,也代表了這是一個能夠處理泛型的類型的泛型方法。
     * 可是隻聲明瞭泛型類型T，並未聲明泛型類型E，所以編譯器並不知道該如何處理E這個類型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

    /**
     * 這個方法也是有問題的，編譯器會爲咱們提示錯誤信息："UnKnown class 'T' "
     * 對於編譯器來講T這個類型並未項目中聲明過，所以編譯也不知道該如何編譯這個類。
     * 因此這也不是一個正確的泛型方法聲明。
    public void showkey(T genericObj){

    }
    */

    public static void main(String[] args) {


    }
}

二、類中的泛型方法

固然這並非泛型方法的所有，泛型方法能夠出現雜任何地方和任何場景中使用。可是有一種狀況是很是特殊的，當泛型方法出如今泛型類中時，咱們再經過一個例子看一下

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型類中聲明瞭一個泛型方法，使用泛型E，這種泛型E能夠爲任意類型。能夠類型與T相同，也能夠不一樣。
        //因爲泛型方法在聲明的時候會聲明泛型<E>，所以即便在泛型類中並未聲明泛型，編譯器也可以正確識別泛型方法中識別的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型類中聲明瞭一個泛型方法，使用泛型T，注意這個T是一種全新的類型，能夠與泛型類中聲明的T不是同一種類型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子類，因此這裏能夠
        generateTest.show_1(apple);
        //編譯器會報錯，由於泛型類型實參指定的是Fruit，而傳入的實參類是Person
        //generateTest.show_1(person);

        //使用這兩個方法均可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用這兩個方法也均可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

三、泛型方法與可變參數

若是靜態方法要使用泛型的話，必須將靜態方法也定義成泛型方法 。

package OSChina.Genericity;

public class GenericFruit {
    //靜態方法中使用泛型，必需要將泛型定義在方法上。
    public static <T> void printMsg(T...args){
        for(T t:args){
            System.out.println("泛型測試，it is "+t);
        }
    }

    public static void main(String[] args) {
        printMsg("1111",2222,"江疏影","0.00",55.55);
    }
}

五、泛型方法總結

儘可能使用泛型方法！

（五）泛型上下邊界

爲泛型添加上邊界，即傳入的類型實參必須是指定類型的子類型。

static？

報錯啦！String類型不是Number類型的子類

泛型的上下邊界添加，必須與泛型的聲明在一塊兒 。

（六）關於泛型數組要提一下

看到了不少文章中都會提起泛型數組，通過查看sun的說明文檔，在java中是」不能建立一個確切的泛型類型的數組」的。

也就是說下面的這個例子是不能夠的：

使用通配符建立泛型數組是能夠的

List<?>[] ls = new ArrayList<?>[10];

下面採用通配符的方式是被容許的:數組的類型不能夠是類型變量，除非是採用通配符的方式，由於對於通配符的方式，最後取出數據是要作顯式的類型轉換的。

 

素小暖講Java@目錄

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程