15,泛型

15.1泛型

泛型的符號：<泛型識別符號,泛型識別符號……>

泛型的作用：泛型就是用於接收具體引用資料型別的引數範圍。

泛型什麼時候用？

當操作的引用資料型別不確定的時候，就可以使用泛型。

使用泛型的好處：

1,將執行時期的問題轉到的編譯時期。

2,避免了強轉的麻煩。

泛型是JDK1.5的新特性，目的是增加安全性。

15.2泛型的擦除和補償

java原始檔中定義的泛型在執行時會被擦除，生成的位元組碼檔案是不帶泛型的，稱為泛型的擦除。

當在執行.class

泛型在集合、類、方法和介面中都有廣泛的應用。

15.3泛型類

當類中操作的引用資料型別不確定時，就可以使用泛型類

類上定義泛型的格式：

許可權飾符　class類名<泛型識別符號1，泛型識別符號2…….>{

…….CODE;

}

如：集合框架中的ArrayList<E>類,定義了泛型，用來明確集合中要存放什麼型別的元素，集合物件建立時需要傳入具體的引用資料型別，一旦集合的泛型接收了具體的引用資料型別，那麼這個集合中只能儲存這一型別的元素，當傳入其它型別的元素，編譯器就會報錯。

   ArrayList<String>al=new ArrayList<String>();

      //新增元素

      al.add("abc1");

      al.add("abc2");

      al.add("abc2");

      al.add("abc1");

      al.add("abc4");

      al.add("abc5");

for(Iterator<String> it=al.iterator();it.hasNext();){

      String s=it.next();//如果不加泛型就需要強轉：String s=(String)it.next();

      System.out.println(s);

      }

 

如上，集合泛型為String型別，那麼集合中的元素，就必須是這一型別，否則編譯會報錯，提高了安全性。

在元素的取出過程中，因為next()取出的元素型別預設是Object型別，如果加了泛型就不需要再進行強轉的動作，否則必須要強轉，避免了強轉的麻煩。

如：以下自定義類中使用的泛型。

public class GenericDemo{

   public static void main(String[]args){

   Person<String,Integer> person=new Person<String,Integer>("lisi",23);//建立物件時指定具體泛型型別。

   Student<String,Integer> student=new student<String,Integer>("zhangsan",23,100);

      person.show();

      student.show();    

   }

}

class Person<N,A>{//Person類上定義了泛型

   private Aa;

   private Nn;

   Person(){

      

   }  

   Person(N n,A a){//構造引數使用了類上的泛型

      this.n=n;

      this.a=a;

   }  

   public void show(){

      System.out.println("姓名："+this.n+"　年齡："+this.a);

   }

}

class Student<N,A>extends Person<N,A>{//當子類繼承父類時，沒有傳入具體泛型型別時，子類也要定義泛型　

   private A a;

   private N n;

   private int s;

   Student(N n, A a, int s) {

      this.n=n;

      this.a=a;

      this.s = s;

   }

   public void show(){

      System.out.println("姓名："+this.n+"年齡："+this.a+"分數："+this.s);

   }  

}

/*

 姓名：lisi　年齡：23

姓名：zhangsan年齡：23分數：100

 */

 

15.4泛型方法

如果一個類定義了泛型，那麼類中的方法可以使用類上的泛型作為引數。當然，如果方法中的引數型別不確定，則可以在方法上重新定義泛型。

注意：泛型在方法上的位置，只能定義在返回值的前面，修飾符的後面

格式：

許可權修飾符　成員修飾符　<泛型識別符號1,泛型識別符號2……>返回值型別　方法名稱（泛型識別符號1　變數,泛型識別符號2　變數,.....,其它引數）{

            方法體；　　

    }

如：

class Generic<T>{//定義了泛型的類

   private T  t;

   Generic(T t){

      this.t=t;

   }

   public void show_1(T t){//此方法的引數直接使用了類上的泛型，類上傳入什麼型別，這個方法的引數就是什麼型別。

   }

   public <A> void show_2(A a){//此方法的引數，沒有使用類上的泛型，而是使用了其他的泛型，則需要在方法上定義泛型。

   }

   public static <B> void show_3(B b){//注意，對於靜態方法的引數是不能直接訪問類上的泛型的，如果要使用泛型則需要在方法上重新定義泛型。

  }

}

注意：對於靜態方法是不能直接訪問類上的泛型的，因為類上的泛型是依賴物件的，而靜態方法不需要物件去呼叫，所以，靜態方法不能直接使用類上定義的泛型。如果靜態方法要使用泛型，則需要在靜態方法上定義泛型。

15.5泛型介面

格式：

interface介面名<泛型識別符號１，泛型識別符號2……>{

}

如：

interface Inter<T>{

   void show(T t);

}

注意：如果一個類實現了帶有泛型的介面時，如果沒有明確具體泛型型別，則這個類也必須要定義泛型。

如：

interface Inter<T>{

   void show(T t);

}

class Generic <T> implements Inter<T>{//沒有明確介面上泛型的具體型別，類也要定義泛型

 

   @Override

   public void show(T t) {

  }  

}

如果在實現一個泛型介面時，明確具體的泛型型別，就把具體的型別傳給介面上的泛型。這樣類上就需要再定義泛型。

如：

interface Inter<T>{

   void show(T t);

}

class Genericimplements Inter<String>{//明確介面上泛型的具體型別，直接傳入具體型別到介面上的泛型。

 

   @Override

   publicvoid show(String t) {

  }  

}

 

15.6泛型萬用字元

泛型萬用字元：?，表示未知的泛型型別。

用字母作為泛型識別符號和泛型萬用字元?有什麼區別呢?

用字母作為泛型的識別符號，可以對其進行操作。

如：泛型方中，作為方法的返回值　，作為一個型別，宣告一個變數，傳給類中的建構函式等等。

public <T> T show(T t){

//方法體；
}

而泛型萬用字元，代表未知的任意型別，是不能夠直接操作的，萬用字元多用於對泛型的限定。

泛型的限定分為：上限和下限

上限：<? extends具體引用型別A>　，表示可以接收A型別及其A的子類型別。

下限：<? super具體引用型別B>，表示可以收的B型別及B的父類型別。

上限和下限同樣可以用於對字母泛型識別符號的限定。

如：上限

public class GenericDemo{

   public static void main(String[]args){

      new Generic().show("abc"); //傳入字串型別，可以列印

      new Generic().show(123);//傳入其它型別，就報錯。

   }

}

class Generic{

   public <T extends String> void show(T t){//show(T t)方法的引數型別T必須是，String及其子類，不能傳入其它型別引數。

      System.out.println(t);

   }

}

如：下限

public class GenericDemo<T>{

   public static void main(String[]args){

      Person<String> p=new Person<String>("LISI",23);

      new Generic().show(p);

   }  

}

class Generic{

   public void show(Person<?super String> g){//此方法，用來接收Person型別　引數，對Person的泛型進行了下限。

      System.out.println(g.getT()+":"+g.getAge());

   }  

}

class Person<T>{

   private T t;

   private int age;

   public Person(T t,int age) {

      super();

      this.t = t;

      this.age = age;

   }

   

   public T getT() {

      return t;

   }

 

   public int getAge() {

     return age;

   }
}

15.7泛型在集合中的應用

泛型在集合中都有所應用，集合中使用泛型可以避免強轉。集合定義泛型，在建立集合物件時，可以明確具體的泛型型別，元素在取出時，就不需再進行強轉。

如：ArrayList集合

public class GenericDemo<T>{

   public static void main(String[]args){

      ArrayList al=newArrayList();//建立集合物件

      al.add("abc1");//add(Objectobj);方法中接收的引數都會被提升為Object型別。

      al.add("abc2");

      al.add("abc3");

      al.add("abc4");

      

      Iterator it=al.iterator();

      while(it.hasNext()){

         String s=(String)it.next();//新增的元素被提升為Object型別，取出時也是Object型別，要強轉。

         System.out.println(s);

      }

   }  

}

因為沒有加泛型，所以在元素取出時必須要強轉。

把泛型加入集合:

：

import java.util.ArrayList;

import java.util.Iterator;

 

public class GenericDemo<T>{

   public static void main(String[]args){

      ArrayList<String> al=new ArrayList<String>();//建立集合物件,並明確泛型型別

      al.add("abc1");//add(Objectobj);方法中接收的引數都會被提升為Object型別。

      al.add("abc2");

      al.add("abc3");

      al.add("abc4");

      

      Iterator <String>it=al.iterator();//元素的取出明確泛型

      while(it.hasNext()){

         String s=it.next();//新增的元素被是String，取出時也是String型別，不需要強轉。

         System.out.println(s);

      }

   }  

}

可見，泛型的應用，不僅可以對集合中元素的新增進行型別的限定，增強安全性，避免出錯，而且避免了元素在取出中強轉的麻煩。