泛型是什么

Java中的泛型是一种能够让用户在编写代码时避免使用明确的类型而进行类型参数化的机制。Java中的泛型可以让编程者在代码编写时不必关心具体类型，只用关心类型之间的关系和相互转换，从而在编写代码的过程中实现类型的复用。这使得代码更加简洁、可读性更高，并且可以提高代码的可维护性和可扩展性。

(相关资料图)

Java泛型可以在类、方法、接口、以及数组等多个地方使用，并且可以结合约束条件来限制类型参数的类型。例如，在定义一个泛型类时，可以使用定义一个泛型类型参数，T可以代表任何具体类型，例如Integer、String、Map等。在使用泛型时，可以将具体类型传递给类型参数，然后在方法或者类中使用该类型参数，从而实现代码的类型自动化。

Java中的泛型还具有类型检查和类型擦除的特性。类型检查可以检查在编译时期是否使用了正确的类型，避免了在运行时期由于类型转换错误而产生的异常。而类型擦除则是Java泛型在实现时使用的一种技术，它会去掉泛型中的类型参数信息，并将其变为原始类型，在运行时也不会保留泛型的信息，从而实现Java泛型的运行时兼容性。

什么是类型参数？

public class MyClass {    private T value;        public void setValue(T value) {        this.value = value;    }        public T getValue() {        return value;    }}

MyClass intObj = new MyClass<>();MyClass strObj = new MyClass<>();

什么是类型擦除？

public class Pair {    private T first;    private S second;    public Pair(T first, S second) {        this.first = first;        this.second = second;    }    public T getFirst() {        return first;    }    public S getSecond() {        return second;    }}

public class Pair {    private Object first;    private Object second;    public Pair(Object first, Object second) {        this.first = first;        this.second = second;    }    public Object getFirst() {        return first;    }    public Object getSecond() {        return second;    }}

什么是通配符类型？

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

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

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

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

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

什么是泛型方法和泛型类

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

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

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

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

public static  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 {    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 box = new Box<>(10);        System.out.println(box.getValue());    }}

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

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

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

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

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

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

public class Parent {    // 泛型类型 T    private T data;    public void setData(T data) {        this.data = data;    }    public T getData() {        return data;    }}public class Child extends Parent {    // 继承泛型类 Parent}public class Test {    public static void main(String[] args) {        Child child = new Child(); // 子类指定了泛型类型为 String        child.setData("Hello World");        System.out.println(child.getData()); // 输出结果为 "Hello World"    }}

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

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

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

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

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

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

public class MyClass {    public  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 myClass = new MyClass<>();        myClass.printElements(integers);        MyClass myClass1 = new MyClass<>();        myClass1.printElements(strings);    }}

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

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

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

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

1. 泛型的类型擦除机制

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