泛型介面的定義語法：

interface 介面名稱 <泛型標識，泛型標識，…> {
    泛型標識 方法名(); 
    .....
}

泛型介面的使用

• 實現類不是泛型類，介面要明確資料型別

• 實現類也是泛型類，實現類和介面的泛型類行要保持一致

  小案例：

 1 package com.genericity.demo1;
 2 
 3 /**
 4  * 泛型介面的實現類，是一個泛型類，那麼要保證實現介面的泛型類泛型標識包含泛型介面的泛型標識
 5  */
 6 public class Pair<T,E> implements Generic<T>  {
 
 7     private T key;
 8     private E value;
 9 
10     public Pair(T key, E value) {
11         this.key = key;
12         this.value = value;
13     }
14 
15     @Override
16     public T getKey() {
17         return key;
18     }
19 
20     public E getValue(){
21         return value;
22     }
23
 
 }

 1 package com.genericity.demo1;
 2 
 3 import com.sun.xml.internal.ws.api.ha.StickyFeature;
 4 
 5 public class MainClass {
 6     public static void main(String[] args) {
 7         ImplClass implClass = new ImplClass();
 8         String key1 = implClass.getKey();
 9         System.out.println(key1);
 
10 
11         System.out.println("========================================================");
12 
13         Pair<String, Integer> strIntegerPair = new Pair<>("today",1000);
14         String key = strIntegerPair.getKey();
15         Integer value = strIntegerPair.getValue();
16         System.out.println("key:"+key+" value:"+value);
17 
18 
19     }
20 }

1 today is nice
2 ============================
3 key:today value:1000

泛型方法

泛型類，是在例項化類的時候指明泛型的具體型別。

泛型方法：是在呼叫方法的時候指明泛型的具體型別。

修飾符 <T，E, ...> 返回值型別 方法名(形參列表) { 
     方法體... 
}
1.public與返回值中間非常重要，可以理解為宣告此方法為泛型方法。
2.只有聲明瞭的方法才是泛型方法，泛型類中的使用了泛型的成員方法並不是泛型方法。
3.< T >表明該方法將使用泛型型別T，此時才可以在方法中使用泛型型別T。
4.與泛型類的定義一樣，此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的引數常用於表示泛型。

小案例：

 1 package com.genericity;
 2 
 3 
 4 import javax.lang.model.element.VariableElement;
 5 import java.util.ArrayList;
 6 import java.util.Random;
 7 
 8 public class ProductGetter<T> {
 9     //獎品
10     private T product;
11     //獎品池
12     ArrayList<T> list = new ArrayList<>();
13     //隨機數生成器
14     Random random = new Random();
15 
16     //新增獎品
17     public void addProduct(T t){
18         list.add(t);
19     }
20 
21     /**
22      * 抽獎方法
23      * 注意：這個方法是不能夠申明成static靜態型別的
24      * @return
25      */
26     public T getProduct(){
27         product = list.get(random.nextInt(list.size()));
28         return product;
29     }
30 
31     /**
32      * 定義泛型方法
33      * @param list 引數 獎品列表
34      * @param <E> 泛型標識，具體型別，由呼叫方法的時候來指定
35      * @return
36      */
37     public <E> E getProduct(ArrayList<E> list){
38         return list.get(random.nextInt(list.size()));
39     }
40 
41     /**
42      * 靜態泛型方法
43      * @param t
44      * @param k
45      * @param v
46      * @param <T>
47      * @param <K>
48      * @param <V>
49      */
50     public static <T,K,V>  void getType(T t,K k,V v){
51         System.out.println(t+":"+t.getClass().getSimpleName());
52         System.out.println(k+":"+k.getClass().getSimpleName());
53         System.out.println(v+":"+v.getClass().getSimpleName());
54     }
55 
56 
57 }

 1 package com.genericity;
 2 
 3 import java.util.ArrayList;
 4 
 5 public class Test2 {
 6     public static void main(String[] args) {
 7         //泛型類中的成員方法的使用
 8         ProductGetter<Integer> productGetter = new ProductGetter<>();
 9         ArrayList<Integer> list1 = new ArrayList<>();
10         list1.add(100);
11         list1.add(200);
12         list1.add(300);
13         //泛型方法的呼叫，型別是通過呼叫方法的時候來指定的
14         Integer product = productGetter.getProduct(list1);
15         System.out.println("product:"+product);
16 
17         System.out.println("----------------------------------------");
18         //泛型方法的呼叫，型別是通過呼叫方法的時候來指定的
19         ArrayList<String> strlist = new ArrayList<>();
20         strlist.add("膝上型電腦");
21         strlist.add("蘋果手機");
22         strlist.add("掃地機器人");
23         String product1 = productGetter.getProduct(strlist);
24         System.out.println("product1:"+product1);
25 
26         System.out.println("----------------------------------------");
27         ArrayList<Integer> intlist = new ArrayList<>();
28         intlist.add(1000);
29         intlist.add(2000);
30         intlist.add(3000);
31         int product2 = productGetter.getProduct(intlist);
32         System.out.println("product1:"+product2);
33 
34 
35         System.out.println("----------------------------------------");
36         //呼叫多個泛型型別的靜態泛型方法
37         ProductGetter.getType("掃地僧",100,true);
38 
39 
40 
41     }
42 }

1 product:200
2 ----------------------------------------
3 product1:膝上型電腦
4 ----------------------------------------
5 product1:1000
6 ----------------------------------------
7 掃地僧:String
8 100:Integer
9 true:Boolean

泛型方法與可變引數

public <E> void print(E... e){
    for (E e1 : e) {
        System.out.println(e);
    }
}

小案例：

 1    /**
 2      * 可變長引數的泛型方法
 3      * @param e
 4      * @param <E>
 5      */
 6     public static <E> void geVariable(E... e){
 7         for (int i = 0; i < e.length; i++) {
 8             System.out.print(e[i]+" ");
 9         }
10     }

      //可變引數的泛型方法的呼叫
        ProductGetter.geVariable("a", "b", "c");

執行結果：a b c

泛型方法的總結：

• 泛型方法能使方法獨立於類而產生變化

• 如果static方法要使用泛型能力，就必須使其成為泛型方法

  總的來說，在實際工作中，我們能使用泛型方法的，儘量使用泛型方法，不要使用泛型類。