泛型是什么

• 泛型（Generics）是編程語言中的一種類型參數(shù)化機制，它允許在定義類、接口或方法時使用類型參數(shù)。這些類型參數(shù)可以在實際使用時被具體的類型所替換，從而實現(xiàn)代碼的復(fù)用性和靈活性。通過泛型，可以編寫更加通用的組件，同時保持類型安全。

引入

• 在實際的需求中，我們可能會遇見需要接收一個參數(shù)但是參數(shù)的類型不能確定，最簡單的方法就是定義多個類型成員變量， 但隨著接收參數(shù)的類型增加，去類中創(chuàng)建多個成員變量就會顯得很麻煩，比如：當(dāng)data變量可能為整型、浮點型、布爾型、字符型、字符串型的任何一種，總不能都去創(chuàng)建一個該類型的data成員變量吧，這時候就需要使用泛型了

泛型的應(yīng)用

泛型在類中的應(yīng)用

• 如下方代碼所示，我們使用了<T>給該類指定了一個需要接收的參數(shù)，這個參數(shù)實際上要接收的是一個類型值。這就是泛型參數(shù)，而后面的屬性的類型，方法參數(shù)的類型就是由參數(shù)T來決定的：

package com.generic;
//public class Box{  
public class Box<T>{
    // private int data;  
    private T data;  
    // private String data;
    //public void setData(int data) {  
    //      this.data = data;        }
    public void setData(T data) {  
            this.data = data;  
    }  
    //public int getData() {  
    //  return data;  
    //}  
    public T getData() {  
        System.out.println("data類型是:" + this.data.getClass());    
        return data;  
    }  
}

• 我們在GenericMain類中使用Box類，我們先指定Box的類型，在創(chuàng)建Box的對象，如下方代碼所示:

public class GenericMain {  
    public static void main(String[] args){  
        Box <boxInter> = new Box<>();  
        boxInter.setData(9);
        Box<String> boxString = new Box<>();  
        boxString.setData("Hello World");
        //測試用例：
        int data = boxInter.getData();  
        System.out.println("data的值是:" + data); 
        String dataStr = boxString.getData();   
        System.out.println("data的值是" + dataStr); 
        //輸出案例：  
        //data類型是:class java.lang.Integer  
        //data的值是:9
        //data類型是:class java.lang.String  
        //data的值是Hello World  
     }
}

• 拓展：實際上我們平時使用的ArrayList容器就是利用率泛型來成為不同類型的容器，即為先指定類型后創(chuàng)建與類型匹配的對象，可以按住ctrl+右擊查看ArrayList的源碼，會發(fā)現(xiàn)實際上ArrayList的源碼中也有一個泛型參數(shù)<E>

//ArrayList的源碼開頭 
public class ArrayList<E> extends AbstractList<E>{  ...  

泛型在接口的應(yīng)用(多態(tài)--類型校驗)

• 可以創(chuàng)建一個接口，該接口用于實現(xiàn)，根據(jù)不同的類型，進行不同的輸出，如下方代碼所示：
  • 創(chuàng)建一個擁有泛型參數(shù)的接口，在接口中創(chuàng)建一個抽象方法
  • 抽象方法中指定傳入?yún)?shù)的類型由泛型決定

public interface Printtable<T> {  
    void print(T data);  
}

• 創(chuàng)建實現(xiàn)接口的類
  • 先創(chuàng)建一個指定類型為Integer的類

  package com.generic;  
  //定義類來實現(xiàn)接口  
  //public class IntegerPrinttable implements Printtable{
  //我們還需要指定處理泛型中的哪種類型，這樣寫的好處是java會幫我們做類型檢查，
  //使用接口的對象的泛型該實現(xiàn)類的泛型是否匹配  
  public class IntegerPrinttable implements Printtable<Integer>{  
      // @Override  
      // public void print(Object data) { }
      @Override  
      public void print(Integer data) {  
          System.out.println("我被用于指定輸出Interger類型的參數(shù)" + data);  
          // 提供接口中的抽象方法的具體實現(xiàn)  
      }  
  }  

  • 創(chuàng)建一個類來實現(xiàn)接口，指定類型為String

  package com.generic;
  //定義類來實現(xiàn)接口  
  public class StringPrinttable implements Printtable<String>{  
      // 提供接口中的抽象方法的具體實現(xiàn)  
      @Override  
      public void print(String data) {  
          System.out.println("我被用于指定輸出String類型的參數(shù)" + data);
      }  
  }

• 在Box類中使用接口
  • 為了使用接口，可以先創(chuàng)建一個接口的引用private Printtable<T> printtable;
  • 創(chuàng)建一個使用該接口的方法printData(直接調(diào)用接口的引用拿到的對象中的print方法);
  • 最后我們寫一個Box的構(gòu)造方法，形式參數(shù)為Printtable<T> printtable，即為接口的引用，但需注意的是，這里的目的不是傳入接口對象（接口本身也不能實例化為對象），而是利用向上轉(zhuǎn)型（父類持有子類對象）持有實現(xiàn)類的對象，利用向上轉(zhuǎn)型的特性，實現(xiàn)多態(tài)

  public class Box<T>{  
      private T data;  
      private Printtable<T> printtable;  
      //在類中將接口聲明，可以看為，我們需要在這個類中使用該接口的實現(xiàn)
      public Box(Printtable<T> printtable) {  
          this.printtable = printtable; 
          //這里傳入實現(xiàn)了printtable接口類的對象，這里實際上是向上轉(zhuǎn)型  
          //這里的目的實際上就是在使用print方法時通過接口選擇那種print方法  
      }      
      public void setData(T data) {  
          this.data = data;  
      }  
      public T getData() {  
          System.out.println("data類型是:" + this.data.getClass());  
          System.out.println(this.data);  
          return data;  
      }  
      public void  printData() {  
          printtable.print(this.data);
          //這里我們使用實現(xiàn)了接口的類的對象中的方法  
      }
  }

• 在主類GenericMain中進行測試
  • 在Box類中我們寫了構(gòu)造方法要求像傳入一個接口實現(xiàn)類的對象，至于具體傳入哪個則是根據(jù)Box對象選擇了泛型的哪一種來決定的
  • 之后就可以調(diào)用box中的方法了
  • 我們分別調(diào)用boxInter.printData(); boxString.printData();，printData會根據(jù)父類接口持有的類對象，匹配實現(xiàn)接口的子類的對象中的方法

  public class GenericMain {  
      public static void main(String[] args){  
      //創(chuàng)建容器容器中添加元素  
      Box<Integer> boxInter = new Box<>(new IntegerPrinttable());  
      boxInter.setData(9);
      //創(chuàng)建容器容器中添加元素
      Box<String> boxString = new Box<>(new StringPrinttable());  
      boxString.setData("Hello World");  
      //測試用例：  
      boxInter.printData();  
      boxString.printData();  
      //輸出案例：  
      /*   
      我被用于指定輸出Interger類型的參數(shù)9
          我被用于指定輸出String類型的參數(shù)Hello World
      */    
      }
  }

• 泛型在接口中的應(yīng)用的例子中，即體現(xiàn)了面向?qū)ο蟮亩鄳B(tài)特性，又體現(xiàn)了泛型能夠進行類型校驗的功能，在創(chuàng)建box對象的時候，使用的先指定類型，后創(chuàng)建與指定類型匹配的對象
  • 在上面的例子中，我們可以試著創(chuàng)建不匹配指定泛型的接口實現(xiàn)類對象，可以發(fā)現(xiàn)因為類型不匹配ide給我們標(biāo)紅報錯了

    

  • 因為我們本應(yīng)給Printtable<String> printtable賦值public class StringPrinttable implements Printtable<String>,即為父類接口未持有匹配的子實現(xiàn)類

    

泛型在方法中的應(yīng)用

• 創(chuàng)建一個方法，如下方代碼所示

public static<T> void printList(ArrayList<T> list){  
    for(T data:list){  
        System.out.println(data);  
    }  
}

• 調(diào)用方法，如下方代碼所示
  • 在這里不需要給public static<T> void printList(ArrayList<T> list)傳單獨的類型給泛型，因為在printList方法的原型中只要求傳入ArrayList的對象，而對象中就已經(jīng)指定了泛型的類型了

public static void main(String[] args){  
        //列表泛型方法測試用例是  
        ArrayList<Integer> list = new ArrayList<>();  
        list.add(9);  
        list.add(8);  
        list.add(7);  
        printList(list);
        //這里String會被當(dāng)作泛型T的值直接傳入
}

到此這篇關(guān)于Java泛型及類型校驗的文章就介紹到這了,更多相關(guān)Java類型校驗內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論