自定义泛型方法

不是说方法使用了接口或者类的泛型就叫泛型方法
比如下面的这个Collection中的方法就不是泛型方法，而是普通方法

boolean add(E e);

这个方法是泛型方法：

<T> T[] toArray(T[] a);

泛型方法是说这个方法不确定放什么类型的结构
Collection< E >，接口声明处用的是E，用E的位置一定不是泛型方法，泛型方法是额外的有新的标识，和定义时的那个标识没关系，不是同一个。泛型方法所属的类或者接口是不是带泛型是无所谓的
比如Order中的这三个方法都不是泛型方法

public class Order<T>{
    String orderName;
    int orderId;

    T orderT;


    public Order(){
        T[] arr=(T[])new Object[10];
    }
    public Order(String orderName,int orderId,T orderT){
        this.orderName=orderName;
        this.orderId=orderId;
        this.orderT=orderT;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    
}

    public List<E> copyFromArrayToList(E[] arr){

    }

上面这么做编译器会误认为有一个类叫做E，而不会把E看成泛型参数，而现在E是变量，调用的时候才会确定

要这么做才会识别为泛型参数：

    public <E> List<E> copyFromArrayToList(E[] arr){

    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
    //形参放数组，把数组当中的元素放到List当中，返回List
    //数组类型是具体的某种类型
    public <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list =new ArrayList<>();
        for(E e:arr){
            list.add(e);
        }
        return list;
    }
}
public class test02{

    public static void main(String[] args) {
        //测试泛型方法
        Order<String> order=new Order<>();
        Integer[] arr=new Integer[]{1,2,3,4};
        //泛型方法在调用时指明泛型参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);//<Integer>是由我们放的数组的类型决定的
        System.out.println(list);//[1,2,3,4]
    }
}

泛型方法可以是static的，即可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。因为E是在调用的时候确定的，不管是对象调的还是类调的，调用的时候确定类型即可

    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list =new ArrayList<>();
        for(E e:arr){
            list.add(e);
        }
        return list;
    }