1､两个实例变量强制使用相同的T类型

通过定义一个类并将泛型参数应用于类中的多个实例变量，这样可以确保这两个实例变量具有相同的类型。

public class Main {
  public static void main(String[] args) {
        // 创建一个实例，确保两个实例变量有相同的类型
        GenericExample<Integer> example = new GenericExample<>(10, 20);
        example.printValues();
    }
}
// 定义一个类，使用泛型T来约束两个实例变量
class GenericExample<T> {
    private T first;
    private T second;

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

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void printValues() {
        System.out.println("First: " + first);
        System.out.println("Second: " + second);
    }

  
}

2､使用泛型方法

如不想使用类级别的泛型，可以在方法级别使用泛型来约束两个实例变量的类型一致。

public class Main {
    
    public static <T> void printSameTypeValues(T first, T second) {
        System.out.println("First: " + first);
        System.out.println("Second: " + second);
    }

    public static void main(String[] args) {
        // 调用泛型方法，确保两个参数有相同的类型
        printSameTypeValues(10, 20);  // Integer类型
        printSameTypeValues("Hello", "World");  // String类型
    }
}

3、使用通配符来约束类型

如要传入多个不同类型的对象，但仍然确保它们的泛型类型相同，可以使用通配符来进行限制。

import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 创建泛型对象
        Pair<Integer> pair1 = new Pair<>(10, 20);
        pair1.printValues();

        Pair<Double> pair2 = new Pair<>(5.5, 10.5);
        pair2.printValues();

        // 使用上界通配符
        List<Number> list1 = List.of(1, 2.5, 3L);  // Number 类型列表
        List<Integer> list2 = List.of(10, 20, 30);  // Integer 类型列表

        Pair.compareUpperBound(list1, list2);  // 上界通配符示例

        // 使用下界通配符
        List<Number> list3 = List.of(10, 20, 30);  // Number 类型列表
        List<Object> list4 = List.of("A", "B", "C");  // Object 类型列表

        Pair.compareLowerBound(list3, list4);  // 下界通配符示例
    }
}

class Pair<T> {
    T first;
    T second;

    // 构造函数
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    // 打印两个实例变量的值
    public void printValues() {
        System.out.println("First: " + first + ", Second: " + second);
    }

    // 使用上界通配符，确保两个实例变量是同一类型或兼容类型
    public static void compareUpperBound(List<? extends Number> list1, List<? extends Number> list2) {
        // 确保 list1 和 list2 都是 Number 或其子类（如 Integer、Double）
        System.out.println("List 1 first element: " + list1.get(0));
        System.out.println("List 2 first element: " + list2.get(0));
    }

    // 使用下界通配符，确保两个实例变量是同一类型或兼容类型
    public static void compareLowerBound(List<? super Integer> list1, List<? super Integer> list2) {
        // 确保 list1 和 list2 都是 Integer 或其父类（如 Number 或 Object）
        System.out.println("List 1 first element: " + list1.get(0));
        System.out.println("List 2 first element: " + list2.get(0));
    }
}