泛型接口和泛型方法

泛型接口的定义语法：

interface 接口名称 <泛型标识，泛型标识，…> {
    泛型标识 方法名(); 
    .....
}

泛型接口的使用

• 实现类不是泛型类，接口要明确数据类型

• 实现类也是泛型类，实现类和接口的泛型类行要保持一致

  小案例：

package com.genericity.demo1;

/**
 * 泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
 */
public class Pair<T,E> implements Generic<T>  {
    private T key;
    private E value;

    public Pair(T key, E value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public T getKey() {
        return key;
    }

    public E getValue(){
        return value;
    }
}

package com.genericity.demo1;

import com.sun.xml.internal.ws.api.ha.StickyFeature;

public class MainClass {
    public static void main(String[] args) {
        ImplClass implClass = new ImplClass();
        String key1 = implClass.getKey();
        System.out.println(key1);

        System.out.println("========================================================");

        Pair<String, Integer> strIntegerPair = new Pair<>("today",1000);
        String key = strIntegerPair.getKey();
        Integer value = strIntegerPair.getValue();
        System.out.println("key:"+key+" value:"+value);


    }
}

today is nice
============================
key:today value:1000

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型。

泛型方法：是在调用方法的时候指明泛型的具体类型。

修饰符 <T，E, ...> 返回值类型 方法名(形参列表) { 
     方法体... 
}
1.public与返回值中间非常重要，可以理解为声明此方法为泛型方法。
2.只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
3.< T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
4.与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

小案例：

package com.genericity;


import javax.lang.model.element.VariableElement;
import java.util.ArrayList;
import java.util.Random;

public class ProductGetter<T> {
    //奖品
    private T product;
    //奖品池
    ArrayList<T> list = new ArrayList<>();
    //随机数生成器
    Random random = new Random();

    //添加奖品
    public void addProduct(T t){
        list.add(t);
    }

    /**
     * 抽奖方法
     * 注意：这个方法是不能够申明成static静态类型的
     * @return
     */
    public T getProduct(){
        product = list.get(random.nextInt(list.size()));
        return product;
    }

    /**
     * 定义泛型方法
     * @param list 参数 奖品列表
     * @param <E> 泛型标识，具体类型，由调用方法的时候来指定
     * @return
     */
    public <E> E getProduct(ArrayList<E> list){
        return list.get(random.nextInt(list.size()));
    }

    /**
     * 静态泛型方法
     * @param t
     * @param k
     * @param v
     * @param <T>
     * @param <K>
     * @param <V>
     */
    public static <T,K,V>  void getType(T t,K k,V v){
        System.out.println(t+":"+t.getClass().getSimpleName());
        System.out.println(k+":"+k.getClass().getSimpleName());
        System.out.println(v+":"+v.getClass().getSimpleName());
    }


}

package com.genericity;

import java.util.ArrayList;

public class Test2 {
    public static void main(String[] args) {
        //泛型类中的成员方法的使用
        ProductGetter<Integer> productGetter = new ProductGetter<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(100);
        list1.add(200);
        list1.add(300);
        //泛型方法的调用，类型是通过调用方法的时候来指定的
        Integer product = productGetter.getProduct(list1);
        System.out.println("product:"+product);

        System.out.println("----------------------------------------");
        //泛型方法的调用，类型是通过调用方法的时候来指定的
        ArrayList<String> strlist = new ArrayList<>();
        strlist.add("笔记本电脑");
        strlist.add("苹果手机");
        strlist.add("扫地机器人");
        String product1 = productGetter.getProduct(strlist);
        System.out.println("product1:"+product1);

        System.out.println("----------------------------------------");
        ArrayList<Integer> intlist = new ArrayList<>();
        intlist.add(1000);
        intlist.add(2000);
        intlist.add(3000);
        int product2 = productGetter.getProduct(intlist);
        System.out.println("product1:"+product2);


        System.out.println("----------------------------------------");
        //调用多个泛型类型的静态泛型方法
        ProductGetter.getType("扫地僧",100,true);



    }
}

product:200
----------------------------------------
product1:笔记本电脑
----------------------------------------
product1:1000
----------------------------------------
扫地僧:String
100:Integer
true:Boolean

泛型方法与可变参数

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

小案例：

   /**
     * 可变长参数的泛型方法
     * @param e
     * @param <E>
     */
    public static <E> void geVariable(E... e){
        for (int i = 0; i < e.length; i++) {
            System.out.print(e[i]+" ");
        }
    }

      //可变参数的泛型方法的调用
        ProductGetter.geVariable("a", "b", "c");

运行结果：a b c

泛型方法的总结：

• 泛型方法能使方法独立于类而产生变化

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

  总的来说，在实际工作中，我们能使用泛型方法的，尽量使用泛型方法，不要使用泛型类。