Java泛型的边界与通配符 - 摩柯技术社区

Java泛型的边界

在Java泛型中，边界（Bounds）用于限制类型参数的取值范围。通过设置边界，我们可以确保在泛型代码中使用的类型具有特定的行为或属性。Java泛型的边界主要分为上限边界（Upper Bounds）和下限边界（Lower Bounds）。

上限边界（Upper Bounds）

上限边界指定类型参数必须是某个特定类型或其子类。语法上，使用关键字extends来声明上限边界。例如，假设有一个Number类以及它的子类Integer和Double，我们定义一个泛型方法来计算数字列表的总和，代码如下：

import java.util.List;

public class UpperBoundExample {
    public static double sum(List<? extends Number> list) {
        double sum = 0;
        for (Number num : list) {
            sum += num.doubleValue();
        }
        return sum;
    }
}

在上述代码中，List<? extends Number>表示list参数可以是任何Number类型或其子类型的列表。这里的通配符?代表一个未知类型，extends Number则限定了这个未知类型必须是Number或Number的子类。这样，无论是List<Integer>还是List<Double>都可以作为参数传递给sum方法。

再来看一个类的泛型上限边界示例：

class Box<T extends Number> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

在这个Box类中，类型参数T被限定为Number或Number的子类。这意味着在创建Box对象时，只能传入Number及其子类的实例：

Box<Integer> intBox = new Box<>(10);
Box<Double> doubleBox = new Box<>(10.5);
// 以下代码将无法编译，因为String不是Number的子类
// Box<String> stringBox = new Box<>("Hello");

上限边界的作用在于，当我们在泛型代码中需要使用特定类型的方法或属性时，如果不设置上限边界，编译器无法确定类型参数是否具有这些方法或属性。通过设置上限边界为具有这些方法或属性的类型，我们可以在泛型代码中安全地调用这些方法。例如，在前面的sum方法中，由于类型参数被限定为Number或其子类，所以可以安全地调用doubleValue方法。

下限边界（Lower Bounds）

下限边界指定类型参数必须是某个特定类型或其超类。语法上，使用关键字super来声明下限边界。例如，假设我们有一个Integer类和它的超类Number，以及Object类（Number的超类），我们定义一个方法来将一个Integer对象添加到一个列表中，代码如下：

import java.util.List;

public class LowerBoundExample {
    public static void addInteger(List<? super Integer> list) {
        list.add(new Integer(10));
    }
}

在上述代码中，List<? super Integer>表示list参数可以是任何Integer类型或其超类的列表。这意味着List<Integer>、List<Number>甚至List<Object>都可以作为参数传递给addInteger方法。

下限边界的主要用途在于写入操作。当我们希望向一个集合中添加特定类型或其子类型的元素时，使用下限边界可以确保集合的类型足够通用以接受这些元素。例如，在addInteger方法中，我们可以向List<? super Integer>类型的列表中添加Integer对象，因为List<? super Integer>可以代表Integer的超类类型的列表，而超类类型的列表肯定能够容纳Integer对象。

Java泛型的通配符

通配符（Wildcards）是Java泛型中一个非常重要的概念，它允许我们在泛型类型中表示未知类型。通配符主要有三种形式：无界通配符（Unbounded Wildcards）、上限通配符（Upper Bounded Wildcards）和下限通配符（Lower Bounded Wildcards）。

无界通配符（Unbounded Wildcards）

无界通配符使用?来表示。例如，List<?>表示一个元素类型未知的列表。无界通配符主要用于以下几种场景：

读取数据：当我们只需要从集合中读取数据，而不需要写入数据时，可以使用无界通配符。例如：

import java.util.List;

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

在上述代码中，printList方法接受一个List<?>类型的参数，它可以打印任何类型的列表。因为这里只是读取列表中的元素，所以使用无界通配符是安全的。 2. 与泛型类型无关的操作：某些操作与集合中的元素类型无关，只关注集合本身的属性，如集合的大小等。例如：

import java.util.List;

public class UnboundedWildcardSizeExample {
    public static int getListSize(List<?> list) {
        return list.size();
    }
}

在getListSize方法中，只关心列表的大小，而不关心列表中元素的具体类型，因此可以使用无界通配符。

需要注意的是，使用无界通配符的集合在写入数据时会受到限制。因为编译器无法确定?代表的具体类型，所以除了null之外，不能向List<?>类型的集合中添加任何元素。例如：

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

public class UnboundedWildcardWriteExample {
    public static void main(String[] args) {
        List<?> list = new ArrayList<>();
        // 以下代码将无法编译
        // list.add(new Integer(10)); 
        list.add(null);
    }
}

在上述代码中，尝试向List<?>类型的list中添加Integer对象会导致编译错误，但可以添加null，因为null可以赋值给任何引用类型。

上限通配符（Upper Bounded Wildcards）

上限通配符其实就是我们前面提到的上限边界与通配符结合的形式，使用? extends Type来表示，其中Type是某个具体类型。例如，List<? extends Number>表示一个元素类型是Number或Number子类的列表。

上限通配符主要用于读取数据的场景，并且在读取数据时可以利用类型的继承关系进行操作。例如，前面提到的计算数字列表总和的方法：

import java.util.List;

public class UpperBoundedWildcardSumExample {
    public static double sum(List<? extends Number> list) {
        double sum = 0;
        for (Number num : list) {
            sum += num.doubleValue();
        }
        return sum;
    }
}

在这个方法中，由于List<? extends Number>表示列表中的元素是Number或Number的子类，所以可以安全地调用Number类的doubleValue方法来计算总和。

下限通配符（Lower Bounded Wildcards）

下限通配符是下限边界与通配符结合的形式，使用? super Type来表示，其中Type是某个具体类型。例如，List<? super Integer>表示一个元素类型是Integer或Integer超类的列表。

下限通配符主要用于写入数据的场景。例如，前面提到的向列表中添加Integer对象的方法：

import java.util.List;

public class LowerBoundedWildcardAddExample {
    public static void addInteger(List<? super Integer> list) {
        list.add(new Integer(10));
    }
}

在这个方法中，List<? super Integer>类型的列表可以接受Integer对象，因为它表示的是Integer或其超类类型的列表，而超类类型的列表肯定能够容纳Integer对象。

通配符与类型擦除

在Java中，泛型是通过类型擦除（Type Erasure）机制来实现的。这意味着在编译之后，泛型类型信息会被擦除，只保留原始类型。例如，对于List<Integer>，在编译后会变成List，Integer类型信息被擦除。

通配符在类型擦除过程中也遵循一定的规则。对于上限通配符? extends Type，擦除后会变成Type。例如，List<? extends Number>擦除后变为List<Number>。对于下限通配符? super Type，擦除后会变成Object。例如，List<? super Integer>擦除后变为List<Object>。

理解通配符与类型擦除的关系对于编写正确的泛型代码非常重要。由于类型擦除的存在，在运行时无法获取泛型的实际类型参数，这就要求我们在编译时通过通配符等机制来确保类型安全。例如，在使用通配符时，编译器会根据通配符的类型边界来检查代码的类型安全性，尽管运行时这些类型信息已经被擦除。

通配符与泛型方法重载

在Java中，通配符在泛型方法重载时会带来一些特殊的情况。由于类型擦除的存在，泛型方法的重载可能不像普通方法重载那样直观。

例如，考虑以下两个方法：

public static void printList(List<Integer> list) {
    for (Integer num : list) {
        System.out.println(num);
    }
}

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

在上述代码中，这两个printList方法看似构成了重载关系。然而，由于类型擦除，在编译后这两个方法的签名实际上是相同的（都变为printList(List)），因此会导致编译错误。

为了正确地进行泛型方法重载，我们需要确保重载方法的签名在类型擦除后仍然是不同的。例如，可以通过改变方法参数的数量或使用不同的类型参数来实现：

public static void printList(List<Integer> list) {
    for (Integer num : list) {
        System.out.println(num);
    }
}

public static void printList(List<Integer> list, boolean isDebug) {
    if (isDebug) {
        System.out.println("Debug mode: ");
    }
    for (Integer num : list) {
        System.out.println(num);
    }
}

在这个例子中，第二个printList方法增加了一个boolean类型的参数，这样在类型擦除后，两个方法的签名仍然不同，从而构成了有效的重载。

实际应用场景

集合框架：在Java集合框架中，通配符和泛型边界被广泛应用。例如，Collections类中的许多方法都使用了通配符和泛型边界。Collections.copy方法的声明如下：

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    // 方法实现
}

在这个方法中，src参数使用了上限通配符? extends T，表示源列表中的元素类型是T或T的子类，这样可以确保从源列表中读取的数据是T类型或其子类。dest参数使用了下限通配符? super T，表示目标列表的元素类型是T或T的超类，这样可以确保目标列表能够容纳从源列表中复制过来的T类型元素。

自定义泛型库：当开发自定义的泛型库时，通配符和泛型边界可以提高库的通用性和类型安全性。例如，假设我们开发一个数据处理库，其中有一个方法用于处理具有特定接口的对象列表：

interface DataProcessor<T> {
    void process(T data);
}

class DataProcessorUtil {
    public static <T> void processData(List<? extends T> dataList, DataProcessor<T> processor) {
        for (T data : dataList) {
            processor.process(data);
        }
    }
}

在上述代码中，processData方法接受一个List<? extends T>类型的列表和一个DataProcessor<T>类型的处理器。List<? extends T>表示列表中的元素是T或T的子类，这样可以确保列表中的元素都可以被DataProcessor<T>处理器处理。

框架开发：在框架开发中，通配符和泛型边界可以提供灵活的扩展机制。例如，在一个Web框架中，可能会有一个用于处理不同类型请求的方法：

interface RequestHandler<T> {
    void handle(T request);
}

class RequestDispatcher {
    public static <T> void dispatch(List<? super T> requests, RequestHandler<T> handler) {
        for (T request : requests) {
            handler.handle(request);
        }
    }
}

在这个例子中，dispatch方法接受一个List<? super T>类型的请求列表和一个RequestHandler<T>类型的处理器。List<? super T>表示请求列表的元素类型是T或T的超类，这样可以确保请求列表能够容纳不同具体类型但继承自T的请求对象，而RequestHandler<T>则负责处理这些请求。

常见错误与陷阱

通配符使用不当导致编译错误：如前面提到的泛型方法重载问题，如果通配符使用不当，可能会导致编译错误。例如，在试图重载泛型方法时，如果没有正确处理通配符，使得编译后的方法签名相同，就会出现“方法重复声明”的错误。
类型擦除带来的运行时问题：由于类型擦除，在运行时无法获取泛型的实际类型参数。这可能会导致一些看似正确的代码在运行时出现问题。例如，假设我们有一个泛型类Box：

class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

如果我们在代码中这样使用：

Box<Integer> intBox = new Box<>(10);
Box<String> stringBox = new Box<>("Hello");
// 以下代码看似可以编译通过，但在运行时会出错
Box<?> box = intBox;
box = stringBox;

在运行时，由于类型擦除，Box<Integer>和Box<String>在编译后都是Box类型，因此可以将stringBox赋值给box，但如果后续试图从box中获取Integer类型的值，就会导致ClassCastException。

混淆上限和下限通配符：上限通配符主要用于读取数据，下限通配符主要用于写入数据。如果混淆了这两种通配符的使用场景，可能会导致代码无法达到预期的效果。例如，将上限通配符用于写入数据的场景，会导致编译错误，因为编译器无法确定具体的类型是否能够被写入。

为了避免这些错误和陷阱，我们需要深入理解通配符和泛型边界的概念，以及类型擦除的机制。在编写泛型代码时，仔细考虑类型的读取和写入操作，合理使用通配符和泛型边界，并且注意代码在编译时和运行时的行为差异。

通过对Java泛型的边界与通配符的深入理解和掌握，我们能够编写出更加通用、类型安全的Java代码，在处理集合、自定义泛型库以及框架开发等场景中发挥出泛型的强大威力。无论是在日常的应用开发还是大型项目中，正确使用泛型的边界与通配符都能够提高代码的质量和可维护性。