将泛型列表声明为父类的成员

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

// 定义一个泛型父类
class GenericParent<T> {
    protected List<T> items; // 泛型列表作为成员变量

    public GenericParent() {
        this.items = new ArrayList<>(); // 初始化列表
    }

    public void addItem(T item) {
        items.add(item); // 添加元素到列表
    }

    public List<T> getItems() {
        return items; // 获取列表
    }
}

// 定义一个继承自GenericParent的子类，指定具体类型为String
class StringChild extends GenericParent<String> {
    // 子类可以添加特定于String的操作
}

// 定义另一个继承自GenericParent的子类，指定具体类型为Integer
class IntegerChild extends GenericParent<Integer> {
    // 子类可以添加特定于Integer的操作
}

public class Main {
    public static void main(String[] args) {
        StringChild stringChild = new StringChild();
        stringChild.addItem("Hello");
        stringChild.addItem("World");
        System.out.println(stringChild.getItems()); // 输出: [Hello, World]

        IntegerChild integerChild = new IntegerChild();
        integerChild.addItem(1);
        integerChild.addItem(2);
        System.out.println(integerChild.getItems()); // 输出: [1, 2]
    }
}

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public abstract class GenericParent<T> {
    public Class<T> getGenericType() {
        Type superClass = getClass().getGenericSuperclass();
        if (superClass instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) superClass;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            return (Class<T>) actualTypeArguments[0];
        } else {
            throw new IllegalArgumentException("Missing type parameter.");
        }
    }
}