• 语法：
class 类名称 <泛型标识,泛型标识,……>{
	private 泛型标识 变量名;
	……
}
常用的 泛型标识：T、E、K、V
• 使用语法：
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();
Java1.7以后，后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();
• MainClass类
package itiheima_09;

//泛型类
public class MainClass<T> {
    //定义成员变量，T：是由外部使用类指定
    private T key;

    //get、set方法
    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }

    //构造方法
    public MainClass(T key) {
        this.key = key;
    }
    public MainClass() {
    }

    //toString方法

    @Override
    public String toString() {
        return "MainClass{" +
                "key=" + key +
                '}';
    }
}
• MainDemo类
package itiheima_09;

public class MainDemo {
    public static void main(String[] args) {
        MainClass<String> stringMainDemo = new MainClass<>("hello");
        String key1 = stringMainDemo.getKey();
        System.out.println(key1);    //hello

        MainClass<Integer> intMainDemo = new MainClass<>(100);
        int key2 = intMainDemo.getKey();    //包装类类型装换为基本数据类型：拆箱
        System.out.println(key2);   //100

        //泛型类在创建对象的时候，没有指定类型，将按照Object类型操作
        MainClass mainClass = new MainClass(100);
        Object key3 = mainClass.getKey();
        System.out.println(key3);   //100

        //泛型类不支持基本数据类型，只支持包装类类型
        //MainClass<int> objectMainClass = new MainClass<int>();
        
        
        //同一泛型类，根据不同的数据类型创建的对象，本质是同一类型
        System.out.println(stringMainDemo.getClass());  //class itiheima_09.MainClass
        System.out.println(intMainDemo.getClass());     //class itiheima_09.MainClass
        System.out.println(stringMainDemo.getClass() == intMainDemo.getClass());    //true
    }
}

抽奖实现
• ProductGetter
package itiheima_10;

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

public class ProductGetter<T> {

    Random random = new Random();

    //奖品
    private T product;

    //奖品池
    ArrayList<T> list = new ArrayList<>();

    //添加奖品
    public void addProduct(T t){
        list.add(t);
    }
   
    //抽奖
    public T getProduct() {
        product = list.get(random.nextInt(list.size()));
        return product;
    }
}
• MainClass
package itiheima_10;

public class MainClass {
    public static void main(String[] args) {
        //创建抽奖类对象，指定数据类型
        ProductGetter<String> stringProductGetter = new ProductGetter<>();
        String[] strProducts = {"苹果手机","华为手机","扫地机器人","咖啡机"};

        //遍历数组
        for (int i = 0; i < strProducts.length; i++) {
            //添加到奖池
            stringProductGetter.addProduct(strProducts[i]);
        }
        //抽奖
        String product1 = stringProductGetter.getProduct();
        System.out.println("恭喜您，你抽中了：" + product1);

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

        ProductGetter<Integer> integerProductGetter = new ProductGetter<>();
        int[] intProducts = {10000,5000,3000,500,300000};

        for (int i = 0; i < intProducts.length; i++) {
            integerProductGetter.addProduct(intProducts[i]);
        }
       
        Integer product2 = integerProductGetter.getProduct();
        System.out.println(product2);
    }
}

• 子类是泛型类，子类和父类泛型类型要一致
class ChildGeneric<T> extends Generic<T>
• 子类不是泛型类，父类要明确泛型的数据类型
class ChildGeneric extends Generic<String>

接口中定义了一个泛型方法 doSomething，该方法接受一个类型为 T 的参数并返回一个类型为 T 的结果。使用该接口时，可以根据需要指定具体的类型参数
public interface MyInterface<T> {
    T doSomething(T t);
}

方法使用了一个类型参数 T，并返回了一个 T 类型的元素。这个方法可以用于任何类型的数组
public static <T> T getFirst(T[] array) {
    if (array.length == 0) {
        return null;
    }
    return array[0];
}
调用泛型方法，你需要在方法名之前指定它的类型参数
String[] words = {"hello", "world"};
String firstWord = getFirst(words);
调用了 getFirst 方法，并将字符串类型的数组传递给它。因为 getFirst 方法是一个泛型方法，编译器会推断出类型参数 T 是 String，所以该方法返回了第一个字符串元素 "hello"

类型通配符是Java中的一种特殊语法，用于表示未知类型。它使用问号（?）作为通配符，可以出现在泛型类、泛型方法、变量声明等位置，在泛型类或方法中，类型通配符可以用来表示任何类型
public class Box<T> {
    public void setValue(T value) { ... }
    public T getValue() { ... }

    // 使用类型通配符定义一个方法，可以接受任何类型的Box对象
    public void copyValue(Box<?> box) {
        T value = box.getValue(); // 读取box中的值
        setValue(value); // 将值设置到当前对象中
    }
}

类型通配符的上限指定了通配符所代表的类型的最大边界。在 Java 中，可以使用 extends 关键字指定类型通配符的上限。例如，如果要创建一个泛型方法，该方法只能接受 Number 类型及其子类的参数，则可以使用以下语法：
public <T extends Number> void methodName(T parameterName) {
    // 方法实现
}
在这个例子中，类型通配符 <T extends Number> 的上限是 Number 类型，这意味着方法只能接受 Number 类型及其子类的参数

泛型通配符的下限指定了通配符所代表的类型的最小边界。在 Java 中，可以使用 super 关键字指定泛型通配符的下限。例如，如果要创建一个泛型方法，该方法只能接受 Integer 类型及其父类的参数，则可以使用以下语法：
public void methodName(List<? super Integer> parameterName) {
    // 方法实现
}
在这个例子中，泛型通配符 <? super Integer> 的下限是 Integer 类型的父类，这意味着该方法可以接受类型为 Integer、Number、Object 等超类的 List 参数

泛型数组是指可以存储任意类型元素的数组，它在声明时需要指定元素类型的占位符，例如：
其中，T 是一个类型参数（type parameter），可以被任意类型所替换（例如 String、Integer 等）
T[] arr = new T[10]; // 使用占位符 T 声明一个长度为 10 的泛型数组
运行时，Java 虚拟机是无法获知 T 的实际类型的，因此无法创建一个真正的泛型数组。因此，上面的代码会导致编译错误。要想创建一个泛型数组，可以通过类型擦除和强制类型转换来实现，例如：
Object[] arr = new Object[10]; // 创建 Object 类型的数组
T t = (T) arr[0]; // 强制类型转换为 T 类型
这种方式虽然可以创建一个泛型数组，但不建议使用，因为强制类型转换可能会导致运行时错误。通常情况下，可以使用集合类（例如 ArrayList）来代替泛型数组，以避免这个问题
ArrayList<T> list = new ArrayList<>();
T t = list.get(0); // 直接获取 T 类型元素
这样就不需要使用强制类型转换来将 Object 类型转换为 T 类型了，同时也可以通过 ArrayList 的动态扩容特性方便地添加或删除元素

泛型是一种编程语言的特性，允许程序员可以在编译时不指定类型，而在运行时再确定类型，从而提高代码的灵活性和重用性。反射是Java中一个非常强大的特性，它使得程序可以在运行时获取类、方法、属性等的信息，并且可以动态地调用这些对象
泛型反射的实现就是对泛型类型进行反射操作。通过泛型反射可以获取泛型类型的参数类型、父类、接口等信息，还可以创建泛型对象、调用泛型方法等。为了实现泛型反射，需要使用到Java中的Type、ParameterizedType、GenericArrayType等相关的API
下面是一个简单的泛型反射示例：
public class Generic<T> {
    private T value;

    public Generic(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Generic<Integer> generic = new Generic<>(123);

        // 获取泛型参数类型
        Type type = generic.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType paramType = (ParameterizedType) type;
            Type[] argTypes = paramType.getActualTypeArguments();
            System.out.println(argTypes[0]);
        }

        // 创建泛型对象
        Class<?> clazz = Class.forName("Generic");
        Constructor<?> constructor = clazz.getDeclaredConstructor(Object.class);
        constructor.setAccessible(true);
        Generic<String> generic2 = (Generic<String>) constructor.newInstance("hello");
        System.out.println(generic2.getValue());
    }
}
这个示例中定义了一个泛型类Generic<T>，并在其中获取泛型参数类型、创建泛型对象。运行结果为：
class java.lang.Integer
hello