泛型继承是指在泛型类或泛型接口中使用继承关系。通过继承，我们可以在子类中使用父类的泛型类型，并且可以进一步扩展或限制泛型类型的范围。在泛型继承中，可以有以下几种情况：

类泛型继承：一个泛型类可以继承另一个泛型类，并且可以在子类中保留或添加新的泛型类型。例如：

class Parent<T> {
    // ...
}

class Child<T> extends Parent<T> {
    // ...
}

在这个例子中，子类Child继承了父类Parent的泛型类型，并且可以在子类中使用该泛型类型。

接口泛型继承：一个泛型接口可以继承另一个泛型接口，并且可以在子接口中保留或添加新的泛型类型。例如：

interface Parent<T> {
    // ...
}

interface Child<T> extends Parent<T> {
    // ...
}

在这个例子中，子接口Child继承了父接口Parent的泛型类型，并且可以在子接口中使用该泛型类型。 类泛型实现接口泛型：一个泛型类可以实现一个泛型接口，并且可以在实现类中保留或添加新的泛型类型。例如：

interface MyInterface<T> {
    // ...
}

class MyClass<T> implements MyInterface<T> {
    // ...
}

在这个例子中，类MyClass实现了接口MyInterface的泛型类型，并且可以在实现类中使用该泛型类型。 通过泛型继承，我们可以在子类或子接口中使用父类或父接口的泛型类型，并且可以进一步扩展或限制泛型类型的范围，从而提供更多的灵活性和重用性。

下面是两个简单的案例来说明泛型继承的用法： 案例一：类泛型继承

class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

class ToyBox<T> extends Box<T> {
    public void play() {
        T item = getItem();
        System.out.println("Playing with " + item.toString());
    }
}

public class Main {
    public static void main(String[] args) {
        ToyBox<String> stringToyBox = new ToyBox<>();
        stringToyBox.setItem("Teddy Bear");
        stringToyBox.play(); // 输出：Playing with Teddy Bear

        ToyBox<Integer> intToyBox = new ToyBox<>();
        intToyBox.setItem(123);
        intToyBox.play(); // 输出：Playing with 123
    }
}

在这个案例中，Box类是一个泛型类，用于存储物品。ToyBox类继承了Box类，并添加了play方法来玩耍存储的物品。通过泛型继承，ToyBox类可以使用Box类的泛型类型，并在play方法中使用该泛型类型。

案例二：接口泛型继承

interface List<T> {
    void add(T item);
    T get(int index);
}

interface Stack<T> extends List<T> {
    T pop();
}

class ArrayList<T> implements List<T> {
    private T[] array;
    private int size;

    public ArrayList() {
        array = (T[]) new Object[10];
        size = 0;
    }

    public void add(T item) {
        array[size++] = item;
    }

    public T get(int index) {
        return array[index];
    }
}

class ArrayStack<T> implements Stack<T> {
    private ArrayList<T> list;

    public ArrayStack() {
        list = new ArrayList<>();
    }

    public void add(T item) {
        list.add(item);
    }

    public T get(int index) {
        return list.get(index);
    }

    public T pop() {
        return list.get(list.size - 1);
    }
}

public class Main {
    public static void main(String[] args) {
        Stack<String> stack = new ArrayStack<>();
        stack.add("A");
        stack.add("B");
        stack.add("C");
        System.out.println(stack.pop()); // 输出：C
    }
}

在这个案例中，List是一个泛型接口，定义了添加和获取元素的方法。Stack接口继承了List接口，并添加了pop方法来弹出栈顶元素。ArrayList类实现了List接口，用数组来存储元素。ArrayStack类实现了 Stack接口，并使用ArrayList类来实现栈的功能。通过泛型继承，ArrayStack类可以使用List接口和 ArrayList类的泛型类型。