Java中的通配符类型是一种泛型类型，用于表示未知类型的泛型参数。 通配符类型由问号（？）表示，其可以用作方法的参数类型、字段类型、局部变量类型等任何地方需要使用泛型类型的地方。

通配符类型有两种形式：无界通配符类型和有界通配符类型。

无界通配符类型是指使用符号 ? 表示未知类型，例如 List<?>。在使用无界通配符类型时，不能添加任何元素到集合中，因为这个集合的元素类型是未知的。但是，可以从集合中获取元素，并将其转换为 Object 类型。

有界通配符类型是指使用符号 ? extends 或 ? super，限制泛型参数的类型范围。例如，List<? extends Number> 表示泛型参数必须是 Number 类型或其子类型。而 List<? super Integer> 表示泛型参数必须是 Integer 类型或其父类型。在使用有界通配符类型时，可以添加元素到集合中，并能获取它们。

注意，通配符类型不能用于泛型类或泛型接口的定义，只能作为方法参数或返回类型的通用形式使用。

什么是泛型方法和泛型类

泛型方法和泛型类是Java中重要的概念，它们的作用是为了提高代码的可重用性和安全性。

泛型方法是在方法的声明中使用泛型类型，使得方法可以接受不同类型的参数，同时还可以指定返回值或方法体中使用的泛型类型。泛型方法通常有以下特点：

1. 泛型方法可以在方法中定义自己的类型参数，也可以使用类定义的类型参数。
2. 泛型方法可以接受任意类型的参数，即可以接受参数化类型，也可以接受普通类型。
3. 泛型方法可以有多个类型参数，也可以没有类型参数。
4. 泛型方法可以有泛型类型的返回值。

下面是一个使用泛型方法的例子：

public static <T> void printArray(T[] array) {

    for (int i = 0; i < array.length; i++) {

        System.out.print(array[i] + " ");

    }

    System.out.println();

}

在这个例子中，我们定义了一个名为 printArray 的泛型方法，它接受一个泛型数组作为参数，并且使用 for 循环遍历数组的每个元素，最后输出所有元素到控制台。

泛型类是在类的声明中使用泛型类型，使得类可以接受不同类型的参数，同时还可以指定类中使用的泛型类型。泛型类通常有以下特点：

1. 泛型类可以在类名后面添加泛型类型参数。
2. 泛型类可以在类中定义泛型类型的实例变量。
3. 泛型类可以有泛型类型的构造方法。
4. 泛型类可以有泛型类型的方法。

下面是一个使用泛型类的例子：

public class Box<T> {

    private T value;

    public Box(T value) {

        this.value = value;

    }

    public T getValue() {

        return value;

    }

    public void setValue(T value) {

        this.value = value;

    }

    public static void main(String[] args) {

        Box<Integer> box = new Box<>(10);

        System.out.println(box.getValue());

    }

}

在这个例子中，我们定义了一个名为 Box 的泛型类，它有一个泛型类型参数 T，同时定义了一个名为 value 的实例变量，以及相应的 get 和 set 方法。在 main 方法中，我们创建了一个 Box 对象，并且使用泛型类型为 Integer 的参数，然后输出了这个对象的值到控制台。

总的来说，泛型方法和泛型类是Java中非常重要的概念，它们可以为我们提供更加灵活和安全的编程方式，同时也是提高代码可读性和可维护性的有效手段。

泛型类中是否可以继承泛型类

Java中泛型类可以继承泛型类，这一特性被称为泛型的继承或泛型的子类化。

在泛型类继承中，子类继承的父类可以是泛型类也可以是非泛型类。当子类继承的父类是泛型类时，子类可以继承父类的泛型类型；也可以在继承时指定自己的泛型类型。

下面是一个范例来展示Java中泛型类继承泛型类的用法：

public class Parent<T> {

    // 泛型类型 T

    private T data;

    public void setData(T data) {

        this.data = data;

    }

    public T getData() {

        return data;

    }

}

public class Child<T> extends Parent<T> {

    // 继承泛型类 Parent<T>

}

public class Test {

    public static void main(String[] args) {

        Child<String> child = new Child<String>(); // 子类指定了泛型类型为 String

        child.setData("Hello World");

        System.out.println(child.getData()); // 输出结果为 "Hello World"

    }

}

在上面的例子中，Child类继承了Parent类，由于Parent类是一个泛型类，所以Child类又继承了Parent类的泛型类型T。而在定义Child类时，也可以在继承Parent类时指定T的具体类型，如Child<String>，从而使Child类也成为具有泛型特性的类。

总结一下，Java中允许泛型类继承泛型类，子类也可以使用父类的泛型类型或为自己指定泛型类型。这个特性可以帮助开发者更好地管理和组织泛型类，能够提升代码的可重用性和可读性。

泛型方法中是否可以声明泛型类

Java中泛型方法可以声明泛型类，这样可以在方法中使用泛型类型参数，从而在方法中实现通用的操作。

除了声明泛型类，泛型方法还可以声明泛型方法参数、返回类型，以及利用泛型通配符进行类型转换等常用操作。

以下是一个简单的示例，展示了在泛型方法中声明泛型类的用法：

public class MyClass<T> {

    public <E> void printElements(E[] elements) {

        for (E element : elements) {

            System.out.println(element.toString());

        }

        T obj = new T();  // 泛型类类型参数T在泛型方法中使用

    }

}

public class Test {

    public static void main(String[] args) {

        Integer[] integers = {1, 2, 3, 4, 5};

        String[] strings = {"Hello", "World"};

        MyClass<Integer> myClass = new MyClass<>();

        myClass.printElements(integers);

        MyClass<String> myClass1 = new MyClass<>();

        myClass1.printElements(strings);

    }

}

在上述代码中，我们定义了一个泛型类 MyClass<T>，其中，又定义了一个名为 printElements 的泛型方法，该方法中使用了泛型类型参数 E[]，并在方法中对数组元素进行遍历输出；同时，方法中也使用了泛型类型参数 T，在方法中初始化一个泛型类类型参数T的对象。

在Test类中，我们实例化了两个 MyClass 类，分别强制指定泛型类型参数为 Integer 类型和 String 类型，并通过执行各自的 printElements 方法来打印数组元素。

通过这种方式，Java中的泛型方法不仅支持泛型类型参数，也支持对泛型类（包括实例化泛型类对象）的操作，从而让我们可以实现更加通用的方法封装，提升代码的可读性和复用性。

为什么类型参数不能是原始类型

1. 泛型的类型擦除机制

Java中的泛型是通过类型擦除机制实现的。泛型类和方法会在编译时通过擦除类型信息来去除泛型的影响，转换成原始类型。例如，List<String>和List<Integer>在编译后都会变成List<Object>。

原始类型与泛型类无法一起使用，这样会破坏Java 的类型安全。如果类型参数允许原始类型，那么在擦除类型信息之后，无法在运行时获得类型信息，这就导致了无法编写通用的泛型代码。

1. 原始类型的限制

原始类型不能继承任何类，也无法实现任何接口。如果类型参数可以是原始类型，那么泛型类就无法利用Java强大的面向对象特性来实现更加复杂、灵活的结构。

1. 自动类型转换问题

Java中自动类型转换和类型擦除机制可能会导致类型参数变为原始类型。例如，我们在泛型方法中将一个原始类型转换为一个泛型类型参数，当运行时擦除类型时，这个泛型类型变成了Object类型，而不是我们想要的类型参数。

综上所述，Java中为什么类型参数不能是原始类型，是因为这种做法会破坏Java的类型安全和面向对象特性，无法实现通用的泛型代码。

//类型边界为Number及其子类

public class GenericClass<T extends Number> {

private T number;

public GenericClass(T number) {

this.number = number;

}

public T getNumber() {

return number;

}

}

GenericClass<Integer> intClass = new GenericClass<>(10);

GenericClass<Double> doubleClass = new GenericClass<>(3.14);

//类型边界为String及其父类

public class GenericClass<T super String> {

private T str;

public GenericClass(T str) {

	this.str = str;

}

public T getString() {

	return str;

}

}

GenericClass<Object> objClass = new GenericClass<>("Hello World");

GenericClass<CharSequence> charSeqClass = new GenericClass<>("Hello World");

public class Animal {}

public class Dog extends Animal {}

//泛型协变

public class GenericClass<T> {

public T getAnimal() {

return null;

}

}

GenericClass<Dog> dogClass = new GenericClass<>();

GenericClass<? extends Animal> animalClass = dogClass;

Animal animal = animalClass.getAnimal(); //协变成Animal类型

Dog dog = dogClass.getAnimal(); //无需转换，返回类型为Dog

public class ParentClass<T> {

T t;

public T getT() {

return t;

}

}

public class ChildClass<T> extends ParentClass<T> {

}

ChildClass<String> child = new ChildClass<>();

child.setT("Hello"); //继承父类中的泛型类型T

String s = child.getT(); //继承父类中的泛型类型T

//类实现接口时使用泛型类型

public interface MyInterface<T> {

public T getT();

}

public class MyClass<T> implements MyInterface<T> {

}

MyClass<String> myClass = new MyClass<>();

String s = myClass.getT(); //使用泛型类型T