java--泛型--泛型接口&泛型方法(代码片段)

package com.model.fanxing;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/30 22:14
 * 泛型接口和实现类
 * 1.泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类的反省表示中要包含 泛型接口的泛型标识
 * 2.泛型接口的实现类，不是一个泛型类是，要保证泛型接口的泛型标识要指定具体的 类型，否则泛型接口的实现类会报错
 * 为什么子类的和父类的泛型类型标识要一样呢，我们创建子类对象是，需要现创建父类对象，我们会为子类指定具体的泛型类型，
 * 这是如果子类和父类的泛型类型不一致时，父类无法的得到具体的类型，就无法创建具体的实例对象，无法创建父类对象，就无法创建子类对象
 *
 * */
public class FanXingDemo05 
    public static void main(String[] args) 
        Chile chile = new Chile();
        System.out.println(chile.getValue());

        ChileOne<String> strChileOne = new ChileOne<>();
        strChileOne.setName("张紫韩");
        System.out.println(strChileOne.getValue());
    

//泛型接口
interface Parent<T>
    public T getValue();

//泛型接口的实现类
class Chile implements  Parent<String>
    @Override
    public String getValue() 
        return "张紫韩";
    

//泛型接口的实现类（实现了是泛型类）
class ChileOne<T> implements Parent<T>
    private T name;

    public ChileOne() 

    

    @Override
    public T getValue() 
        return name;
    

    public void setName(T name) 
        this.name = name;
    

    public ChileOne(T name) 
        this.name = name;
    
　　

package com.model.fanxing;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/30 23:03
 * 演示泛型方法的使用
 * 泛型方法和泛型类没有关系，当泛型类中标识类和泛型方法的标识类中有相同的标识符时，他们直接也不会相互影响，即泛型类指定的类型，
 * 于泛型方法指定的类型是两码事，他们事不会相互影响，泛型方法脱离泛型类的控制
 *
 * 泛型方法的返回值可以时泛型方法指定的任意类型，而泛型类中的成员方法返回的只能是类中指定的泛型类型
 * 泛型方法可以是静态的，泛型类中的成员方法不能是静态的
 *
 * 泛型方法支持静态的
 * 支持可变参数的泛型方法
 *
 */
public class FanXingDemo06 
    public static void main(String[] args) 
        Product<String> product = new Product<>();
        product.add("a");
        product.add("b");
        product.add("c");
        product.add("d");
        System.out.println(product.getProduct());

        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        System.out.println(product.getProduct02(list));
        ArrayList<String> strList = new ArrayList<>();
        strList.add("a");
        strList.add("b");
        strList.add("c");
        strList.add("d");
        System.out.println(product.getProduct02(strList));

//        静态的泛型方法的调用
        System.out.println(Product.getProduct04(strList));
//        可变参数的泛型方法的调用
        product.get(1,2,3,4,5,6);
        product.get("a","b","c","d");

    

class Product<E>
    private E product;

    List<E> list=new ArrayList<>();
    public void add(E product)
        list.add(product);
    
    public E getProduct()
       product=list.get(new Random().nextInt(list.size()));
       return product;
    
    public <T> T getProduct02(ArrayList<T> list2) //泛型方法有标识符列表 <E,T>,且只有标识列表中有的标识符，返回值和参数中才能用

        return list2.get(new Random().nextInt(list2.size()));
    
    public <E> E getProduct03(ArrayList<E> list3) //泛型方法有标识符列表 <E,T>

        return list3.get(new Random().nextInt(list3.size()));
    

//    静态的泛型方法
    public static <E> E getProduct04(ArrayList<E> list4) //泛型方法有标识符列表 <E,T>,

        return list4.get(new Random().nextInt(list4.size()));
    

//    可变参数的泛型方法
    public <E> void get(E... e)
        for (E v:e)
            System.out.println(v);