Java 泛型

Java泛型是Java语言中的一个重要特性，它使我们能够编写具有类型安全性的代码。泛型在Java中被广泛应用于集合、类库和框架中。在本篇博客中，我们将详细介绍Java泛型的定义、使用方式、类型擦除以及泛型的限制等方面。

定义

Java泛型是一种参数化类型的概念，它允许在类或方法定义时使用类型参数，这些类型参数在使用时可以通过实际类型进行替换。Java泛型的定义方式如下：

class ClassName<T> {
  // class body
}

or 

interface InterfaceName<T> {
  // interface body
}

or 

public <T> void methodName(T t) {
  // method body
}

其中，<T>表示类型参数，它可以是任何标识符，但通常使用单个大写字母表示类型参数。在类或接口定义中，T可以用于任何地方需要表示类型的地方。在方法定义中，T可以用于方法参数、方法返回值以及方法体中需要表示类型的地方。

使用方式

Java泛型的使用方式主要有以下几种：

1. 类型参数

在类或接口定义中，可以使用类型参数来表示类或接口中的类型。例如，以下代码定义了一个泛型类Pair，它可以存储两个任意类型的对象：

public class Pair<T, U> {
  private T first;
  private U second;

  public Pair(T first, U second) {
    this.first = first;
    this.second = second;
  }

  public T getFirst() {
    return first;
  }

  public U getSecond() {
    return second;
  }
}

在上面的代码中，T和U都是类型参数，它们在类定义中表示任意类型。

2. 泛型方法

在方法定义中，可以使用类型参数来表示方法参数、方法返回值以及方法体中需要表示类型的地方。例如，以下代码定义了一个泛型方法printArray，它可以打印任何类型的数组：

public static <T> void printArray(T[] array) {
  for (T item : array) {
    System.out.println(item);
  }
}

在上面的代码中，<T>表示类型参数，它在方法定义中表示任意类型。

3. 通配符

Java泛型还提供了通配符?，它可以用来表示任意类型。例如，以下代码定义了一个方法printList，它可以打印任何类型的列表：

public static void printList(List<?> list) {
  for (Object item : list) {
    System.out.println(item);
  }
}

在上面的代码中，List<?>表示一个列表，它可以包含任何类型的元素。

类型擦除

Java泛型是通过类型擦除来实现的。在编译时，Java编译器会将所有泛型类型转换为它们的原始类型。例如，以下代码中的泛型类型Pair<String, Integer>在编译时将被转换为原始类型Pair：

Pair<String, Integer> pair = new Pair<>("Hello", 123);

在类型擦除过程中，所有泛型类型参数都将被替换为它们的上界，例如：

class Pair<T extends Comparable<T>> {
  // ...
}

上面的代码中，类型参数T的上界是Comparable<T>，在类型擦除时，T将被替换为Comparable。

限制

Java泛型有一些限制，例如：

1. 不能使用基本类型作为类型参数，例如Pair<int, int>是不合法的，应该使用Pair<Integer, Integer>。

2. 不能创建泛型类型的数组，例如new T[]是不合法的。

3. 不能使用类型参数来创建实例，例如new T()是不合法的。

4. 不能使用类型参数来创建静态变量，例如static T value是不合法的。

示例代码

下面是一个简单的Java程序，用于演示Java泛型的使用：

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

public class GenericsDemo {
  public static void main(String[] args) {
    Pair<String, Integer> pair = new Pair<>("Hello", 123);
    System.out.println(pair.getFirst());
    System.out.println(pair.getSecond());

    Integer[] intArray = {1, 2, 3};
    String[] strArray = {"Hello", "World"};
    printArray(intArray);
    printArray(strArray);

    List<Integer> intList = new ArrayList<>();
    intList.add(1);
    intList.add(2);
    intList.add(3);
    printList(intList);

    List<String> strList = new ArrayList<>();
    strList.add("Hello");
    strList.add("World");
    printList(strList);
  }

  public static <T> void printArray(T[] array) {
    for (T item : array) {
      System.out.println(item);
    }
  }

  public static void printList(List<?> list) {
    for (Object item : list) {
      System.out.println(item);
    }
  }
}

class Pair<T, U> {
  private T first;
  private U second;

  public Pair(T first, U second) {
    this.first = first;
    this.second = second;
  }

  public T getFirst() {
    return first;
  }

  public U getSecond() {
    return second;
  }
}

在这个示例中，我们定义了一个泛型类Pair，它可以存储两个任意类型的对象，并且定义了一个泛型方法printArray，它可以打印任何类型的数组。我们还定义了一个方法printList，它可以打印任何类型的列表。

运行上述代码，我们将会看到以下输出：

Hello
123
1
2
3
Hello
World
1
2
3
Hello
World

通过这个示例，我们可以看到Java泛型的使用方式以及类型擦除的影响。

总结

Java泛型是Java语言中的一个重要特性，它允许我们编写具有类型安全性的代码。Java泛型的定义方式、使用方式以及类型擦除等内容都是我们在日常开发中需要了解的内容。希望本篇博客能够帮助你更好地理解Java泛型的使用。