使用泛型约束

1. 泛型约束的基本概念

1.1 什么是泛型？

在 Java 中，泛型是一种允许我们在定义类、接口和方法时，使用类型参数的特性。通过泛型，程序可以在编译时确定类型，从而避免了类型转换的风险，并提高了代码的重用性和可维护性。

例如，当我们定义一个容器类时，使用泛型可以让该容器适应不同的数据类型，而不需要为每个数据类型编写单独的类。

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

在上述代码中，T 是泛型类型参数，它代表了一个类型，可以是任何类型。通过泛型，我们可以创建一个适应多种数据类型的 Box 类。

1.2 为什么需要泛型约束？

泛型本身非常强大，但在某些情况下，我们希望对泛型的类型参数进行限制，以便使其只接受某些类型。这时，我们就可以使用 泛型约束。

泛型约束 是一种通过限定泛型类型参数的范围来确保泛型类型在特定约束范围内的机制。通过使用 extends 关键字，我们可以指定泛型类型参数必须是某个类的子类，或者实现了某个接口。

1.3 泛型约束的语法

泛型约束通过 extends 关键字来指定。例如：

T extends Number 表示类型 T 必须是 Number 类或其子类。
T extends Comparable<T> 表示类型 T 必须实现了 Comparable 接口。

public <T extends Number> void printNumber(T number) {
    System.out.println(number);
}

在这个例子中，T 必须是 Number 或其子类的实例（如 Integer、Double 等）。这样我们就可以确保传入的方法参数一定是一个数字类型。

2. 泛型约束的常见使用场景

2.1 限制泛型类型为类的子类

通过泛型约束，我们可以限制泛型的类型参数只能是某个类的子类或该类本身。例如，限制泛型为 Number 或其子类。

示例：限制为 `Number` 的子类

public class NumberPrinter {
    // 只接受 Number 或其子类类型的参数
    public <T extends Number> void printNumber(T number) {
        System.out.println("数字: " + number);
    }

    public static void main(String[] args) {
        NumberPrinter printer = new NumberPrinter();
        
        printer.printNumber(123);        // Integer 类型
        printer.printNumber(12.34);      // Double 类型
        // printer.printNumber("abc");  // 编译错误，不能传入字符串类型
    }
}

代码分析：

泛型约束：方法 printNumber 使用了 T extends Number 约束，意味着 T 必须是 Number 类型或其子类（如 Integer、Double）。
类型安全：通过泛型约束，编译器会自动检查类型，确保传入的类型符合要求。如果我们尝试传入非 Number 类型的数据（比如字符串），会发生编译错误。

2.2 限制泛型类型实现接口

我们也可以使用泛型约束来限制泛型类型必须实现某个接口。这通常在需要对泛型类型进行某些操作时很有用，确保泛型类型能够满足某个接口的要求。

示例：限制为实现了 `Comparable` 接口的类型

public class ComparatorUtil {
    // 只接受实现了 Comparable 接口的类型
    public static <T extends Comparable<T>> T findMax(T a, T b) {
        if (a.compareTo(b) > 0) {
            return a;
        } else {
            return b;
        }
    }

    public static void main(String[] args) {
        Integer a = 10;
        Integer b = 20;
        
        System.out.println("较大的数是: " + findMax(a, b));  // 输出 20
        
        // 如果我们尝试传入没有实现 Comparable 接口的类型，会导致编译错误
        // String str1 = "apple";
        // String str2 = "banana";
        // System.out.println(findMax(str1, str2));  // 编译错误，String 实现了 Comparable，但示例展示了更多可能性。
    }
}

代码分析：

泛型约束：方法 findMax 使用了 T extends Comparable<T> 约束，意味着 T 必须实现 Comparable<T> 接口。
比较操作：在方法内部使用了 compareTo 方法来比较两个对象，这要求 T 类型的对象必须实现 Comparable 接口。

2.3 多重泛型约束

有时，我们需要限制一个类型满足多个条件。此时可以使用 多重泛型约束，通过 extends 关键字来同时限定多个类型条件。

示例：多重泛型约束

public class Utility {
    // 限制 T 同时满足 Number 类型和 Comparable 接口
    public static <T extends Number & Comparable<T>> T findMax(T a, T b) {
        if (a.compareTo(b) > 0) {
            return a;
        } else {
            return b;
        }
    }

    public static void main(String[] args) {
        Integer a = 10;
        Integer b = 20;
        
        System.out.println("较大的数是: " + findMax(a, b));  // 输出 20
    }
}

代码分析：

多重约束：T extends Number & Comparable<T> 同时限制了 T 必须是 Number 类型或其子类，并且必须实现 Comparable 接口。
多重约束的作用：确保传入的对象不仅可以进行数字比较，还能进行自定义的顺序比较。

3. 泛型方法中的约束

3.1 使用泛型方法

泛型方法可以独立于类进行定义，在方法签名中指定类型参数，并且可以为类型参数设置约束。

示例：泛型方法与约束

public class Utility {

    // 泛型方法，限制 T 必须是 Number 或其子类
    public static <T extends Number> double sum(T num1, T num2) {
        return num1.doubleValue() + num2.doubleValue();
    }

    public static void main(String[] args) {
        Integer a = 10;
        Double b = 20.5;
        
        System.out.println("总和是: " + sum(a, b));  // 输出 30.5
    }
}