2. 程式人生 > >JAVA快速入門-泛型

JAVA快速入門-泛型

阿新 • • 發佈：2019-02-19

Tips:

泛型是程式設計語言的一種特性。允許程式設計師在強型別程式設計語言中編寫程式碼時定義一些可變部分，那些部分在使用前必須作出指明。各種程式設計語言和其編譯器、執行環境對泛型的支援均不一樣。將型別引數化以達到程式碼複用提高軟體開發工作效率的一種資料型別。泛型類是引用型別，是堆物件，主要是引入了型別引數這個概念。
泛型的定義主要有以下兩種：
1.在程式編碼中一些包含型別引數的型別，也就是說泛型的引數只可以代表類，不能代表個別物件。（這是當今較常見的定義）
2.在程式編碼中一些包含引數的類。其引數可以代表類或物件等等。（人們大多把這稱作模板）不論使用哪個定義，泛型的引數在真正使用泛型時都必須作出指明。
一些強型別程式語言支援泛型，其主要目的是加強型別安全及減少類轉換的次數，但一些支援泛型的程式語言只能達到部分目的。

上面Tips如果是不瞭解泛型的還是比較難理解，本章使用程式碼的形式，可以簡潔明瞭的看出泛型究竟是什麼，下面先寫一個沒有使用到泛型的JAVA程式碼，如下：

class Person {
    private int age;

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

    public int getAge() {
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        Person p = new
 
 Person();
        p.setAge(3);
        System.out.println(p.getAge());
    }
}

上面的程式碼，假設我們 setAge 這個函式要傳遞的引數不是整型變量了，要傳遞個 “3 years old” 這個字串，那麼我們需要把 Person 類裡面的定義的 int 型變數全都一個一個的改成 String，這顯然就很不方便也很浪費時間，那麼這時候就可以引入泛型了，泛型就是把類裡面的屬性型別使用名字來代替，當我們需要把 int 改為 String 的時候，直接修改定義一處即可實現所有型別的替換，還是以程式碼的形式比較直觀，經過修改上面的程式碼使用泛型後，如下：

/* 這個 T 就是泛型(可以用其它名字,不一定是T)，它可以替代類裡面使用到的變數型別 */
class Person <T>{
    private T age;

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

    public T getAge() {
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        /* 當我們需要把int改為String，直接往<>裡面寫入型別即可 */
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        System.out.println(p.getAge());

        /* 這裡不能用int，因為泛型是類型別,也需要使用Integer類 */
        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        System.out.println(p2.getAge());
    }
}

當然，上面的 < T > 如果想宣告成使用兩個泛型的話也是可以的，比如 < T,N > 來代替兩個型別，在定義時也需要定義兩個型別，比如< String,int >。上面的列印過程如果使用函式來實現，那函式形參的定義能不能也使用泛型呢，上面傳遞的類他們的泛型都不一樣，一個是< String >，一個是< Integer >，那我們在傳遞給形參的時候可以使用萬用字元< ? >來定義，也可以把其它已經例項化的物件賦值給萬用字元的物件，如下程式碼所示：

class Person <T>{
    private T age;

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

    public T getAge() {
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        //System.out.println(p.getAge());
        printInfo(p);

        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        //System.out.println(p2.getAge());
        printInfo(p2);

        /* 使用萬用字元來特定一個物件的時候,只能去獲取,無法設定，就是沒法setAge */
        Person<?> p3;
        p3 = p;
        p3.getAge();
    }

    /* <?> 使用這個萬用字元表示代替傳遞進來的型別 */    
    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }
}

那麼如果想讓形參也使用泛型不使用萬用字元< ? >行不行呢，可以的，看程式碼的實現：

public class Generics {
    public static void main(String args[]) {
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        //System.out.println(p.getAge());
        printInfo(p);

        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        //System.out.println(p2.getAge());
        printInfo(p2);


        Person<?> p3;
        p3 = p;
        p3.getAge();

        /* 形參為泛型的使用 */
        printInfo2(p);
        printInfo2(p2);
        printInfo2(p3);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }

    /* 前面的<T>用來表示形參中的引數是泛型 */
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

子類能否也使用父類裡面的泛型呢，具體實現看程式碼：

class Person <T>{
    private T age;

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

    public T getAge() {
        return this.age;
    }
}

/* 子類使用泛型 */
class Student<T> extends Person<T> {
}

/* 子類不想使用泛型了,就要指定使用哪一種泛型,如下 */
class Student2 extends Person<String> {
}

public class Generics {
    public static void main(String args[]) {
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        //System.out.println(p.getAge());
        printInfo(p);

        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        //System.out.println(p2.getAge());
        printInfo(p2);


        Person<?> p3;
        p3 = p;
        p3.getAge();

        /* 形參為泛型的使用 */
        printInfo2(p);
        printInfo2(p2);
        printInfo2(p3);

        Student<Integer> s = new Student<Integer>();
        s.setAge(10);
        printInfo(s);//傳入s子類會向上轉換為Person父類

        /* 子類不使用泛型,只有父類使用的話定義的時候這個子類就不用指定泛型了 */
        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }

    /* 前面的<T>用來表示形參中的引數是泛型 */
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

當然，介面可以看做是特殊的父類，當然也能使用泛型，如下：

interface Person <T>{
    public void setAge(T age);
    public T getAge();
}

class Student<T> implements Person<T> {
    T age;

    public void setAge(T age){
        this.age = age;
    }
    public T getAge(){
        return this.age;
    }
}


class Student2 implements Person<String> {
    String age;

    public void setAge(String age){
        this.age = age;
    }
    public String getAge(){
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        Student<Integer> s = new Student<Integer>();
        s.setAge(10);
        printInfo(s);//傳入s會向上轉換了Person

        /* 定義的時候這個子類就不用指定泛型了 */
        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }

    /* 前面的<T>用來表示形參中的引數是泛型 */
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

最後再看看“受限的泛型”，泛型可以定義上限和下限，先來看看泛型的上限，把 T 定義為只能是 Number 類或其子類,用 extemds 表示上限。

interface Person <T>{
    public void setAge(T age);
    public T getAge();
}

/* 指定只能是 Integer 或 float等 */
/* 這些類都來源於 Number 類 */
class Student<T extends Number> implements Person<T> {
    T age;

    public void setAge(T age){
        this.age = age;
    }
    public T getAge(){
        return this.age;
    }
}


class Student2 implements Person<String> {
    String age;

    public void setAge(String age){
        this.age = age;
    }
    public String getAge(){
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        /* 加了上限後如果這裡的泛型使用String就會出錯 */
        Student<Integer> s = new Student<Integer>();
        s.setAge(10);
        printInfo(s);

        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

再看看泛型的下限，把 T 定義為只能是 String 類或其父類,用 super 表示下限，而且super只能用於萬用字元，如下：

interface Person <T>{
    public void setAge(T age);
    public T getAge();
}

//不能直接這樣用，super只能用於萬用字元
//class Student<T super String> implements Person<T> {
class Student<T> implements Person<T> {
    T age;

    public void setAge(T age){
        this.age = age;
    }
    public T getAge(){
        return this.age;
    }
}

class Student2 implements Person<String> {
    String age;

    public void setAge(String age){
        this.age = age;
    }
    public String getAge(){
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        /* 這裡因為有下限所以要改成String才能編譯通過 */
        Student<String> s = new Student<String>();
        s.setAge("10 years old");
        printInfo(s);

        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    /* 只允許那些萬用字元是String或者String父類的例項化物件 */
    public static void printInfo(Person<? super String> p) {
        System.out.println(p.getAge());
    }

    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

相關推薦

JAVA快速入門-泛型

Tips: 泛型是程式設計語言的一種特性。允許程式設計師在強型別程式設計語言中編寫程式碼時定義一些可變部分，那些部分在使用前必須作出指明。各種程式設計語言和其編譯器、執行環境對泛型的支援均不一樣。將型別引數化以達到程式碼複用提高軟體開發工作效率的一種資料

Java學習筆記——泛型

ray dem 想想 string stub odt 好處 reac test 一、什麽是泛型？為什麽要使用泛型？ 且看代碼： 1 public class GenericsDemo { 2 3 public static void main(String

Java中的泛型

產生 range 好的 基於 arr div rdquo nbsp 打印 以下內容引用自http://wiki.jikexueyuan.com/project/java/generics.html： 如果寫一個單獨的能在一個整型數組，一個字符串數組或者一個任何類型支持排序

JAVA進階-泛型

span float ati 子類 rec content ace -s ava >泛型：泛型指代了參數的類型化類型，一般被用在接口。類。方法中 >作用：用來確定參數的範圍，在書寫代碼的時候提前檢查代碼的錯誤性 >泛型的聲明，下面給出類聲明，依此類推：

C#入門泛型集合List<T>

div nbsp 需要 強制轉換 初始 cnblogs lsi 轉換 blog 泛型集合 List<T> List<T>泛型集合特點： <T>表示泛型，T是Type簡寫，表示當前不確定具體類型； 可以根據用戶的實際需要，確定當前集合需要

泛型及java中的泛型

free 刪除 移除 環境 特性 net 什麽是 模板 class 當作筆記整理的~~~ 首先，引出堆對象這個概念。 什麽是堆對象，就是程序在運行過程中可以隨時建立或者刪除的對象，可以用new運算符(或malloc函數)或者delete運算符(或free函數)。泛型可以看作

Java中的泛型方法

pan sta 有一個 println 泛型方法 判斷 調用方法 user instant 這是一個轉載的博客 這是一個轉載的博客 這是一個轉載的博客 　　泛型是什麽意思在這就不多說了，而Java中泛型類的定義也比較簡單，例如：public class Test<T&

Java基礎：泛型

ret 原來 不能 使用 自定義泛型 編程 讀取數組 yum 實現 　　同樣是面試當中遇到的問題，在平常寫代碼的過程當中，經常有使用到泛型編程，比如用到的各種集合方式，如Arraylist、hashmap、List、等，都有使用到泛型。但是當面試官讓自己系統的介紹一下泛型編

Java基礎學習——泛型

() logs 調用 自定義 sta class string [] lis 一、泛型方法 1 /** 2 3 自定義泛型：自定義泛型可以理解為是一個數據類型的占位符，或者理解為是一個數據類型的變量。 4 5 泛型方法： 6 泛型方法的自定義格式：修飾符&

java集合，泛型簡單總結

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

Java面試題-泛型篇

發生 是你 hashmap 參數化 實例變量 圖片 使用 多態 來替 139. Java中的泛型是什麽 ? 使用泛型的好處是什麽? 泛型是Java SE 1.5的新特性，泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。 好處：

Java 集合和泛型

ron 接口 關系 ons 增加 pre pos 接口設計 操作 　　一、集合（Collections） 　　Java使用集合來組織和管理對象。 　　1、Java的集合類 　　集合類主要負責保存、盛裝和管理對象，因此集合類也被稱為容器類。 　　集合類分為Set、List、M

Java筆記：泛型

顯式 end 接口 運行時 get java代碼 我們 open tcl 一、簡單實例 class Solution<T> { private T obj; Solution(T obj) { this.obj = obj;

java自定義泛型 面試題：接收任意數組進行反轉

static class ava div 叠代器 類型 應用 system length 不用泛型只能操作某種類型進行反轉 代碼如下： package com.swift.fanxing; import org.junit.Test; public class Ren

Effective Java中的泛型部分

java 容易 捕獲異常 super AS 存儲 好的 泛型參數 extends 今天將Effective Java（第二版）中的泛型部分讀完，深感自己泛型掌握有多麽不熟練，還是需要多加練習。 廢話少說，上點重點： 1.不要使用原型 比如: List list = new

Java核心技術-泛型程序設計

anti get 6.4 checked throw bsp 但是 通配符 們的 使用泛型機制編寫的代碼要比那些雜亂地使用Object變量，然後再進行強制類型轉換的代碼具有更好的安全性和可讀性。 泛型對於集合類尤其有用 1 為什麽要使用反省程序設計 泛型程序設計意味著編寫的

長沙java開發培訓班，Java快速入門

線程 oci 輸入輸出流 思想 調用 長沙 處理 log4j java開發培訓 Javaweb是用Java技術來解決相關web互聯網領域的技術總和。說的簡單的就是寫網站的一種語言。一般分為前端和後端兩種方向，前端所做的東西就像幕前表演的演員，所做的就是讓網頁看起來順眼，用起

Java快速入門-01-基礎篇

浮點 鏈接 快速學習 頭部 常見 goto 受保護 cab 例如 Java快速入門-01-基礎篇 如果基礎不好或者想學的很細，請參看：菜鳥教程-JAVA 本筆記適合快速學習，文章後面也會包含一些常見面試問題，記住快捷鍵操作，一些內容我就不轉載了，直接附上鏈接，嘻嘻 開發

java高級-泛型<T>和註解封裝與使用

bat string 為什麽 cor this 模塊名 vat () parameter p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 } span.s1 {

14. Java基礎之泛型

remove 角度 分享 The 兩個 -a 類型形參 建議 set 引用自：https://www.cnblogs.com/lwbqqyumidi/p/3837629.html ， https://blog.csdn.net/s10461/article/details/