【技术积累】Java中的泛型【一】

合集 - 【技术积累】Java理论技术(4)

1.【技术积累】Java中的常用类【一】07-192.【技术积累】Java中的集合框架【一】06-18

3.【技术积累】Java中的泛型【一】06-12

4.【技术积累】Java中的JVM【一】06-07

收起

泛型是什么

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

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

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

什么是类型参数？

Java中的类型参数是用于泛型编程的占位符，可以用来表示任何类型。它们用尖括号 "<>" 括起来，放置在类名或方法名后面，用来指定通用类型。

 

例如，以下代码中的 T 就是一个类型参数：

 

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

 

在上面的代码中，T 代表一个通用类型。可以在创建 MyClass 对象时指定 T 的具体类型，如：

 

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

这样，intObj 对象中的 value 的类型就是 Integer，strObj 对象中的 value 的类型就是 String。

 

类型参数可以用在类、方法、接口等地方，用来实现通用的算法。使用类型参数可以允许我们编写一次通用的代码，可以用于不同类型的数据，是 Java 泛型编程的核心特性。

什么是类型擦除？

类型擦除（type erasure）是指在Java编译期间，对泛型类型参数信息的擦除，将所有泛型类型参数都用它们的上界（或Object类型）替换，从而在运行时不会保留泛型类型信息。

具体来说，编译器会将泛型类、泛型接口中的类型参数用对应的类型上限（即extends关键字后面的类型）替换，泛型方法中的类型参数也会被替换。例如，对于以下泛型类：

public class Pair<T, S> {
    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;
    }
}

这就是类型擦除的过程，所有泛型类型信息都被擦除并替换为Object类型。

虽然泛型类型信息被擦除，但在运行时可以通过反射机制获取到泛型类型信息，这使得泛型在运行时仍然可以使用。但是，由于类型擦除，泛型类型参数在运行时无法进行类型检查，因此可能会导致类型安全问题。

什么是通配符类型？

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

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

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

有界通配符类型是指使用符号 ? extends 或 ? super，限制泛型参数的类型范围。例如，List 表示泛型参数必须是 Number 类型或其子类型。而 List 表示泛型参数必须是 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
}

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，从而使Child类也成为具有泛型特性的类。

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

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

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

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

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

public class ExampleClass<T> {
    public <E> void exampleMethod(E element) {
        List<T> list = new ArrayList<>();
        list.add((T) element);
        System.out.println("Element added to list: " + list.get(0));
    }
     public static void main(String[] args) {
        ExampleClass<String> example = new ExampleClass<>();
        example.exampleMethod(10);
        example.exampleMethod("Hello");
    }
}

在这个例子中， ExampleClass  是一个带有泛型参数  T  的泛型类。

exampleMethod是一个泛型方法，它声明了一个泛型参数  E ，并在方法体中使用了  T 。

在main方法中，我们创建了一个  ExampleClass对象，并使用  exampleMethod  方法添加了两个元素，一个是整数，一个是字符串。

由于我们在main方法中创建的是一个  ExampleClass对象，因此在  exampleMethod  中使用的  T  类型将被解析为  String  类型。

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

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

1. 泛型的类型擦除机制

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