java泛型

知识点：

1.泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

2.如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。

3.在java中是”不能创建一个确切的泛型类型的数组”的。

附：学习代码

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}
--------------------- 
//作者：VieLei 
//来源：CSDN 
//原文：https://blog.csdn.net/s10461/article/details/53941091 
//版权声明：本文为博主原创文章，转载请附上博文链接！

package com.wsy.test;

public class Fruit {
    @Override
    public String toString() 
    {
        return "fruit";
    }
    
}

package com.wsy.test;

public class Apple extends Fruit {
    @Override
    public String toString() 
    {
        return "apple";
    }
}

package com.wsy.test;

public class Person {
    @Override
    public String toString() 
    {
        return "person";
    }
}

package com.wsy.test;
    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
        //在泛型类中生命一个泛型方法，使用泛型T，使用的是可变参数的
        public <T> void show_4(T...args) 
        {
            for(T t :args) 
            {
                System.out.println(t);
            }
        }
    }

package com.wsy.test;

public class GenericFruit {



    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();
        
        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
        //泛型方法和可变参数的测试
        generateTest.show_4("123",123,222,"34.2",324.21,'s');
    }
}

package com.wsy.test;
import java.util.*;
public class Test1 {

    public static void main(String[] args)
    {
        List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
        Object o = lsa;    
        Object[] oa = (Object[]) o;    
        List<Integer> li = new ArrayList<Integer>();    
        li.add(new Integer(3));    
        oa[1] = li; // Correct.    
        Integer i = (Integer) lsa[1].get(0); // OK 
        System.out.println(i);
//        --------------------- 
//        作者：VieLei 
//        来源：CSDN 
//        原文：https://blog.csdn.net/s10461/article/details/53941091 
//        版权声明：本文为博主原创文章，转载请附上博文链接！
    }
}

参考链接：

https://blog.csdn.net/s10461/article/details/53941091