一、引入
1、泛型是什麼
首先告訴大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢?先看看下面這段代碼:- ArrayList<String> strList = new ArrayList<String>();
- ArrayList<Integer> intList = new ArrayList<Integer>();
- ArrayList<Double> doubleList = new ArrayList<Double>();
大家對ArrayList很熟悉,這裏構造了三個List,分別盛裝String、Integer和Double;這就是ArrayList的過人之處:即各種類型的變量都可以組裝成對應的List,而不必針對每個類型分別實現一個構建ArrayList的類。這裏可能看不懂,開篇總是困難的,下面看看如果沒有泛型的話,我們要怎麼做;
2、沒有泛型會怎樣
先看下面這段代碼:
我們實現兩個能夠設置點座標的類,分別設置Integer類型的點座標和Float類型的點座標:
- //設置Integer類型的點座標
- class IntegerPoint{
- private Integer x ; // 表示X座標
- private Integer y ; // 表示Y座標
- public void setX(Integer x){
- this.x = x ;
- }
- public void setY(Integer y){
- this.y = y ;
- }
- public Integer getX(){
- return this.x ;
- }
- public Integer getY(){
- return this.y ;
- }
- }
- //設置Float類型的點座標
- class FloatPoint{
- private Float x ; // 表示X座標
- private Float y ; // 表示Y座標
- public void setX(Float x){
- this.x = x ;
- }
- public void setY(Float y){
- this.y = y ;
- }
- public Float getX(){
- return this.x ;
- }
- public Float getY(){
- return this.y ;
- }
- }
那現在有個問題:大家有沒有發現,他們除了變量類型不一樣,一個是Integer一個是Float以外,其它並沒有什麼區別!那我們能不能合併成一個呢?
答案是可以的,因爲Integer和Float都是派生自Object的,我們用下面這段代碼代替:
- class ObjectPoint{
- private Object x ;
- private Object y ;
- public void setX(Object x){
- this.x = x ;
- }
- public void setY(Object y){
- this.y = y ;
- }
- public Object getX(){
- return this.x ;
- }
- public Object getY(){
- return this.y ;
- }
- }
即全部都用Object來代替所有的子類;
在使用的時候是這樣的:
- ObjectPoint integerPoint = new ObjectPoint();
- integerPoint.setX(new Integer(100));
- Integer integerX=(Integer)integerPoint.getX();
在設置的時候,使用new Integer(100)來新建一個Integer
- integerPoint.setX(new Integer(100));
然後在取值的時候,進行強制轉換:
- Integer integerX=(Integer)integerPoint.getX();
由於我們設置的時候,是設置的Integer,所以在取值的時候,強制轉換是不會出錯的。
同理,FloatPoint的設置和取值也是類似的,代碼如下:
- ObjectPoint floatPoint = new ObjectPoint();
- floatPoint.setX(new Float(100.12f));
- Float floatX = (Float)floatPoint.getX();
但問題來了:注意,注意,我們這裏使用了強制轉換,我們這裏setX()和getX()寫得很近,所以我們明確的知道我們傳進去的是Float類型,那如果我們記錯了呢?
比如我們改成下面這樣,編譯時會報錯嗎:
- ObjectPoint floatPoint = new ObjectPoint();
- floatPoint.setX(new Float(100.12f));
- String floatX = (String)floatPoint.getX();
不會!!!我們問題的關鍵在於這句:
- String floatX = (String)floatPoint.getX();
強制轉換時,會不會出錯。因爲編譯器也不知道你傳進去的是什麼,而floatPoint.getX()返回的類型是Object,所以編譯時,將Object強轉成String是成立的。必然不會報錯。
而在運行時,則不然,在運行時,floatPoint實例中明明傳進去的是Float類型的變量,非要把它強轉成String類型,肯定會報類型轉換錯誤的!
那有沒有一種辦法在編譯階段,即能合併成同一個,又能在編譯時檢查出來傳進去類型不對呢?當然,這就是泛型。
下面我們將對泛型的寫法和用法做一一講解。
二、各種泛型定義及使用
1、泛型類定義及使用
我們先看看泛型的類是怎麼定義的:- //定義
- class Point<T>{// 此處可以隨便寫標識符號
- private T x ;
- private T y ;
- public void setX(T x){//作爲參數
- this.x = x ;
- }
- public void setY(T y){
- this.y = y ;
- }
- public T getX(){//作爲返回值
- return this.x ;
- }
- public T getY(){
- return this.y ;
- }
- };
- //IntegerPoint使用
- Point<Integer> p = new Point<Integer>() ;
- p.setX(new Integer(100)) ;
- System.out.println(p.getX());
- //FloatPoint使用
- Point<Float> p = new Point<Float>() ;
- p.setX(new Float(100.12f)) ;
- System.out.println(p.getX());
從結果中可以看到,我們實現了開篇中IntegerPoint類和FloatPoint類的效果。下面來看看泛型是怎麼定義及使用的吧。
(1)、定義泛型:Point<T>
首先,大家可以看到Point<T>,即在類名後面加一個尖括號,括號裏是一個大寫字母。這裏寫的是T,其實這個字母可以是任何大寫字母,大家這裏先記着,可以是任何大寫字母,意義是相同的。
(2)類中使用泛型
這個T表示派生自Object類的任何類,比如String,Integer,Double等等。這裏要注意的是,T一定是派生於Object類的。爲方便起見,大家可以在這裏把T當成String,即String在類中怎麼用,那T在類中就可以怎麼用!所以下面的:定義變量,作爲返回值,作爲參數傳入的定義就很容易理解了。
- //定義變量
- private T x ;
- //作爲返回值
- public T getX(){
- return x ;
- }
- //作爲參數
- public void setX(T x){
- this.x = x ;
- }
下面是泛型類的用法:
- //IntegerPoint使用
- Point<Integer> p = new Point<Integer>() ;
- p.setX(new Integer(100)) ;
- System.out.println(p.getX());
- //FloatPoint使用
- Point<Float> p = new Point<Float>() ;
- p.setX(new Float(100.12f)) ;
- System.out.println(p.getX());
- Point<String> p = new Point<String>() ;
而泛型類的構造則需要在類名後添加上<String>,即一對尖括號,中間寫上要傳入的類型。
因爲我們構造時,是這樣的:class Point<T>,所以在使用的時候也要在Point後加上類型來定義T代表的意義。
然後在getVar()和setVar()時就沒有什麼特殊的了,直接調用即可。
從上面的使用時,明顯可以看出泛型的作用,在構造泛型類的實例的時候:
- //IntegerPoint使用
- Point<Integer> p = new Point<Integer>() ;
- //FloatPoint使用
- Point<Float> p = new Point<Float>() ;
前面我們提到ArrayList也是泛型,我們順便它的實現:
- public class ArrayList<E>{
- …………
- }
(4)使用泛型實現的優勢
相比我們開篇時使用Object的方式,有兩個優點:
(1)、不用強制轉換
- //使用Object作爲返回值,要強制轉換成指定類型
- Float floatX = (Float)floatPoint.getX();
- //使用泛型時,不用強制轉換,直接出來就是String
- System.out.println(p.getVar());
可以看到,當我們構造時使用的是String,而在setVar時,傳進去Integer類型時,就會報錯。而不是像Object實現方式一樣,在運行時纔會報強制轉換錯誤。
2、多泛型變量定義及字母規範
(1)、多泛型變量定義上在我們只定義了一個泛型變量T,那如果我們需要傳進去多個泛型要怎麼辦呢?
只需要在類似下面這樣就可以了:
- class MorePoint<T,U>{
- }
- class MorePoint<T,U,A,B,C>{
- }
- class MorePoint<T,U> {
- private T x;
- private T y;
- private U name;
- public void setX(T x) {
- this.x = x;
- }
- public T getX() {
- return this.x;
- }
- …………
- public void setName(U name){
- this.name = name;
- }
- public U getName() {
- return this.name;
- }
- }
- //使用
- MorePoint<Integer,String> morePoint = new MorePoint<Integer, String>();
- morePoint.setName(”harvic”);
- Log.d(TAG, ”morPont.getName:” + morePoint.getName());
(2)、字母規範
在定義泛型類時,我們已經提到用於指定泛型的變量是一個大寫字母:
- class Point<T>{
- …………
- }
- E — Element,常用在java Collection裏,如:List<E>,Iterator<E>,Set<E>
- K,V — Key,Value,代表Map的鍵值對
- N — Number,數字
- T — Type,類型,如String,Integer等等
再重複一遍,使用哪個字母是沒有特定意義的!只是爲了提高可讀性!!!!
3、泛型接口定義及使用
在接口上定義泛型與在類中定義泛型是一樣的,代碼如下:
- interface Info<T>{ // 在接口上定義泛型
- public T getVar() ; // 定義抽象方法,抽象方法的返回值就是泛型類型
- public void setVar(T x);
- }
與泛型類的定義一樣,也是在接口名後加尖括號;
(1)、使用方法一:非泛型類
但是在使用的時候,就出現問題了,我們先看看下面這個使用方法:
- class InfoImpl implements Info<String>{ // 定義泛型接口的子類
- private String var ; // 定義屬性
- public InfoImpl(String var){ // 通過構造方法設置屬性內容
- this.setVar(var) ;
- }
- @Override
- public void setVar(String var){
- this.var = var ;
- }
- @Override
- public String getVar(){
- return this.var ;
- }
- }
- public class GenericsDemo24{
- public void main(String arsg[]){
- InfoImpl i = new InfoImpl(“harvic”);
- System.out.println(i.getVar()) ;
- }
- };
- class InfoImpl implements Info<String>{
- …………
- }
然後在在這裏我們將Info<String>中的泛型變量T定義填充爲了String類型。所以在重寫時setVar()和getVar()時,IDE會也我們直接生成String類型的重寫函數。
最後在使用時,沒什麼難度,傳進去String類型的字符串來構造InfoImpl實例,然後調用它的函數即可。
- public class GenericsDemo24{
- public void main(String arsg[]){
- InfoImpl i = new InfoImpl(“harvic”);
- System.out.println(i.getVar()) ;
- }
- };
在方法一中,我們在類中直接把Info<T>接口給填充好了,但我們的類,是可以構造成泛型類的,那我們利用泛型類來構造填充泛型接口會是怎樣呢?
- interface Info<T>{ // 在接口上定義泛型
- public T getVar() ; // 定義抽象方法,抽象方法的返回值就是泛型類型
- public void setVar(T var);
- }
- class InfoImpl<T> implements Info<T>{ // 定義泛型接口的子類
- private T var ; // 定義屬性
- public InfoImpl(T var){ // 通過構造方法設置屬性內容
- this.setVar(var) ;
- }
- public void setVar(T var){
- this.var = var ;
- }
- public T getVar(){
- return this.var ;
- }
- }
- public class GenericsDemo24{
- public static void main(String arsg[]){
- InfoImpl<String> i = new InfoImpl<String>(“harvic”);
- System.out.println(i.getVar()) ;
- }
- };
- class InfoImpl<T> implements Info<T>{ // 定義泛型接口的子類
- private T var ; // 定義屬性
- public InfoImpl(T var){ // 通過構造方法設置屬性內容
- this.setVar(var) ;
- }
- public void setVar(T var){
- this.var = var ;
- }
- public T getVar(){
- return this.var ;
- }
- }
然後在使用時,就是構造一個泛型類的實例的過程,使用過程也不變。
- public class GenericsDemo24{
- public static void main(String arsg[]){
- Info<String> i = new InfoImpl<String>(“harvic”);
- System.out.println(i.getVar()) ;
- }
- };
那我們稍微加深點難度,構造一個多個泛型變量的類,並繼承自Info接口:
- class InfoImpl<T,K,U> implements Info<U>{ // 定義泛型接口的子類
- private U var ;
- private T x;
- private K y;
- public InfoImpl(U var){ // 通過構造方法設置屬性內容
- this.setVar(var) ;
- }
- public void setVar(U var){
- this.var = var ;
- }
- public U getVar(){
- return this.var ;
- }
- }
使用時是這樣的:泛型類的基本用法,不再多講,代碼如下:
- public class GenericsDemo24{
- public void main(String arsg[]){
- InfoImpl<Integer,Double,String> i = new InfoImpl<Integer,Double,String>(“harvic”);
- System.out.println(i.getVar()) ;
- }
- }
4、泛型函數定義及使用
上面我們講解了類和接口的泛型使用,下面我們再說說,怎麼單獨在一個函數裏使用泛型。比如我們在新建一個普通的類StaticFans,然後在其中定義了兩個泛型函數:- public class StaticFans {
- //靜態函數
- public static <T> void StaticMethod(T a){
- Log.d(”harvic”,“StaticMethod: ”+a.toString());
- }
- //普通函數
- public <T> void OtherMethod(T a){
- Log.d(”harvic”,“OtherMethod: ”+a.toString());
- }
- }
使用方法如下:
- //靜態方法
- StaticFans.StaticMethod(”adfdsa”);//使用方法一
- StaticFans.<String>StaticMethod(”adfdsa”);//使用方法二
- //常規方法
- StaticFans staticFans = new StaticFans();
- staticFans.OtherMethod(new Integer(123));//使用方法一
- staticFans.<Integer>OtherMethod(new Integer(123));//使用方法二
首先,我們看靜態泛型函數的使用方法:
- StaticFans.StaticMethod(“adfdsa”);//使用方法一
- StaticFans.<String>StaticMethod(”adfdsa”);//使用方法二
方法一,可以像普通方法一樣,直接傳值,任何值都可以(但必須是派生自Object類的類型,比如String,Integer等),函數會在內部根據傳進去的參數來識別當前T的類別。但儘量不要使用這種隱式的傳遞方式,代碼不利於閱讀和維護。因爲從外觀根本看不出來你調用的是一個泛型函數。
方法二,與方法一不同的地方在於,在調用方法前加了一個<String>來指定傳給<T>的值,如果加了這個<String>來指定參數的值的話,那StaticMethod()函數裏所有用到的T類型也就是強制指定了是String類型。這是我們建議使用的方式。
同樣,常規泛型函數的使用也有這兩種方式:
- StaticFans staticFans = new StaticFans();
- staticFans.OtherMethod(new Integer(123));//使用方法一
- staticFans.<Integer>OtherMethod(new Integer(123));//使用方法二
方法一,隱式傳遞了T的類型,與上面一樣,不建議這麼做。
方法二,顯示將T賦值爲Integer類型,這樣OtherMethod(T a)傳遞過來的參數如果不是Integer那麼編譯器就會報錯。
進階:返回值中存在泛型
上面我們的函數中,返回值都是void,但現實中不可能都是void,有時,我們需要將泛型變量返回,比如下面這個函數:
- public static <T> List<T> parseArray(String response,Class<T> object){
- List<T> modelList = JSON.parseArray(response, object);
- return modelList;
- }
5、其它用法:Class<T>類傳遞及泛型數組
(1)、使用Class<T>傳遞泛型類Class對象有時,我們會遇到一個情況,比如,我們在使用JSON解析字符串的時候,代碼一般是這樣的
- public static List<SuccessModel> parseArray(String response){
- List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);
- return modelList;
- }
這段代碼的意義就是根據SuccessModel解析出List<SuccessModel>的數組。
- public class SuccessModel {
- private boolean success;
- public boolean isSuccess() {
- return success;
- }
- public void setSuccess(boolean success) {
- this.success = success;
- }
- }
- public static List<SuccessModel> parseArray(String response){
- List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);
- return modelList;
- }
先來看代碼:
- public static <T> List<T> parseArray(String response,Class<T> object){
- List<T> modelList = JSON.parseArray(response, object);
- return modelList;
- }
這是因爲Class<T>也是一泛型,它是傳來用來裝載類的class對象的,它的定義如下:
- public final class Class<T> implements Serializable {
- …………
- }
(2)、定義泛型數組
在寫程序時,大家可能會遇到類似String[] list = new String[8];的需求,這裏可以定義String數組,當然我們也可以定義泛型數組,泛型數組的定義方法爲 T[],與String[]是一致的,下面看看用法:
- //定義
- public static <T> T[] fun1(T…arg){ // 接收可變參數
- return arg ; // 返回泛型數組
- }
- //使用
- public static void main(String args[]){
- Integer i[] = fun1(1,2,3,4,5,6) ;
- Integer[] result = fun1(i) ;
- }
- public static <T> T[] fun1(T…arg){ // 接收可變參數
- return arg ; // 返回泛型數組
- }
由於可變長參數在輸入後,會保存在arg這個數組中,所以,我們直接把數組返回即可。
轉自:http://blog.csdn.net/harvic880925/article/details/49872903
下面是我自己實際使用泛型的幾個實例。
希望看完上面的文章之後,再看實際使用的例子,可以更好的理解和使用和實際使用。
關於泛型類的使用實例
- import lombok.Data;
- @Data
- public class MultiObject<T> {
- /**
- * 成功狀態
- */
- private boolean success;
- /**
- * 異常
- */
- private Exception ex;
- /**
- * 數據
- */
- private T obj;
- public MultiObject() {
- }
- /**
- * 注意:當傳入的泛型是Boolean時,就和第三個構造函數衝突了。
- */
- public MultiObject(boolean success) {
- this.success = success;
- }
- public MultiObject(Exception ex) {
- this.success = false;
- this.ex = ex;
- }
- public MultiObject(T value) {
- this.success = true;
- this.obj = value;
- }
- }
import lombok.Data;
@Data
public class MultiObject<T> {
/**
* 成功狀態
*/
private boolean success;
/**
* 異常
*/
private Exception ex;
/**
* 數據
*/
private T obj;
public MultiObject() {
}
/**
* 注意:當傳入的泛型是Boolean時,就和第三個構造函數衝突了。
*/
public MultiObject(boolean success) {
this.success = success;
}
public MultiObject(Exception ex) {
this.success = false;
this.ex = ex;
}
public MultiObject(T value) {
this.success = true;
this.obj = value;
}
}
簡單解釋下這個model。
在實際業務代碼裏面,可能有很多種操作,然後我們關心這個操作的執行結果,主要有幾點。
1,成功與否。對應屬性success。
2,異常信息。對應屬性ex。若是操作正常執行,則就不在意這個屬性的值。
3,我們操作的最終目的對象。對應屬性obj。
泛型牛逼的地方就是在這個地方。
如果你不用泛型,而使用Object類型,那麼每次執行完之後,我們即使得到這個結果,還得類型轉換一下,那麼這下就像文章上面描述的那樣。分分鐘出現castfailexception。也就是類型轉換異常啦。
但是,若是使用了這個泛型之後,那麼我們的某個操作所需要的返回結果是什麼類型,就可以 傳入什麼類型,而且在實際取得返回結果的時候,就不需要使用類型轉換,這樣就很好的達到了目的。
這個主要是代碼設計層次的提高。寫再多的業務代碼,要是不提高,那麼寫的都是渣。
關於,這個model代碼裏面爲啥沒有getter和setter,都是因爲使用@Data這個註解,可以自動填充這個getter和setter。所以。就表在意這個問題啦。在其他地方可以正常使用各個屬性getter和setter方法,雖然這些方法,你暫時看不見。有興趣的可以瞭解下lombok。
關於泛型方法的使用實例
這個地方就有2個,但是上面文章也都講到啦。1,一個是泛型表示某一個類型的參數。爲的傳遞某一類的參數對象
2,另一個則是傳遞的不是參數,而是代表Class,某一個類。
恰巧我都使用過,就正好記錄一下實際使用實例。
- /**
- * 將Json字符串信息轉換成對應的Java對象
- *
- * @param json json字符串對象
- * @param c 對應的類型
- */
- public static <T> T parseJsonToObj(String json, Class<T> c) {
- try {
- JSONObject jsonObject = JSONObject.parseObject(json);
- return JSON.toJavaObject(jsonObject, c);
- } catch (Exception e) {
- LOG.error(e.getMessage());
- }
- return null;
- }
/**
* 將Json字符串信息轉換成對應的Java對象
*
* @param json json字符串對象
* @param c 對應的類型
*/
public static <T> T parseJsonToObj(String json, Class<T> c) {
try {
JSONObject jsonObject = JSONObject.parseObject(json);
return JSON.toJavaObject(jsonObject, c);
} catch (Exception e) {
LOG.error(e.getMessage());
}
return null;
}
然後是具體調用的地方的代碼。
- Collector collectorObj = JSONUtils.parseJsonToObj(collector, Collector.class);
- Flume flume = JSONUtils.parseJsonToObj(flumeJson, Flume.class);
- Probe probe = JSONUtils.parseJsonToObj(probeJson, Probe.class);
Collector collectorObj = JSONUtils.parseJsonToObj(collector, Collector.class);
Flume flume = JSONUtils.parseJsonToObj(flumeJson, Flume.class);
Probe probe = JSONUtils.parseJsonToObj(probeJson, Probe.class);
可以看到,真的只是因爲傳入的參數類型不一樣,但若你不知道泛型的話,那你就得沒遇到一個類型的轉換,你就得寫一個這麼個方法。
- /**
- * @param dest 目的集合
- * @param source 源集合
- * @param <T> 集合參數的類型
- */
- private static <T> void listAddAllAvoidNPE(List<T> dest, List<T> source) {
- if (source == null) {
- return;
- }
- dest.addAll(source);
- }
- private static <T> void listAddAvoidNull(List<T> dest, T source) {
- if (source == null) {
- return;
- }
- dest.add(source);
- }
/**
* @param dest 目的集合
* @param source 源集合
* @param <T> 集合參數的類型
*/
private static <T> void listAddAllAvoidNPE(List<T> dest, List<T> source) {
if (source == null) {
return;
}
dest.addAll(source);
}
private static <T> void listAddAvoidNull(List<T> dest, T source) {
if (source == null) {
return;
}
dest.add(source);
}
這個就是傳入的參數爲某一類的參數,主要是要使用參數對象,而不是上面的那個使用的參數的類Class 我這方法提出來,主要是因爲,直接使用list類的addAll()方法,如果添加的是null,那麼就會拋異常。但是總不能我在所有使用的地方,都判斷一下我要添加的參數是不是null,然後再調用list的addAll()方法吧。那樣的話,這樣的判斷代碼會囉嗦的海了去了。所以,就這麼提出來了。
這個時候,這個T,使用起來就像使用我們常用的一般對象一樣,我這的參數是個List類型,當然也可是其他類型的,姿勢都一樣。
然後是具體調用的地方的代碼
- List<ProbeObject> list = Lists.newArrayList();
- listAddAllAvoidNPE(list, decoder.getProperties());
List<ProbeObject> list = Lists.newArrayList();
listAddAllAvoidNPE(list, decoder.getProperties());
這個方法的第二個參數的返回值可能是null,所以,直接調用addAll(),就會拋空指針異常。所以,就如上,那麼一提取。就好多啦。