java 泛型函数

1.java  泛型函数

在Java中，泛型是一种允许在编译时定义和使用类型参数（类型变量）的方式，这些类型参数在运行时会被实际的类型所替代。泛型函数（通常被称为泛型方法）是泛型的一个主要应用。泛型方法允许你定义一个方法，该方法可以接受任意类型的参数，并在方法体内使用该类型，而无需进行强制类型转换。

下面是一个泛型方法的示例：

	public class GenericMethodDemo {
	// 泛型方法，用于交换两个变量的值
	public static <T> void swap(T[] arr, int i, int j) {
	T temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
	}
	public static void main(String[] args) {
	// 创建一个Integer类型的数组
	Integer[] intArray = {1, 2, 3, 4, 5};
	System.out.println("Before swap: " + Arrays.toString(intArray));
	// 调用泛型方法交换intArray中索引为1和3的元素
	swap(intArray, 1, 3);
	System.out.println("After swap: " + Arrays.toString(intArray));
	// 创建一个String类型的数组
	String[] strArray = {"a", "b", "c", "d", "e"};
	System.out.println("Before swap: " + Arrays.toString(strArray));
	// 调用泛型方法交换strArray中索引为1和3的元素
	swap(strArray, 1, 3);
	System.out.println("After swap: " + Arrays.toString(strArray));
	}
	}

在这个例子中，swap 方法是一个泛型方法，它接受一个类型参数 T。这个类型参数用于指定数组的元素类型，以及用于临时存储交换值的变量 temp 的类型。泛型方法通过 <T> 语法来声明类型参数，并且类型参数可以出现在方法的任何部分（参数、局部变量、返回类型等）。

在 main 方法中，我们分别使用 Integer 类型和 String 类型的数组来调用 swap 方法，展示了泛型方法的灵活性。由于 swap 方法是泛型的，它不需要为每种可能的类型都编写一个特定的版本。

2.java 非静态的 泛型函数 

在Java中，非静态的泛型函数（通常称为泛型方法）与静态泛型方法的区别在于非静态方法属于类的实例，并且可以访问类的实例字段（非静态字段）。泛型方法的定义与静态泛型方法类似，只是在方法声明中不包含static关键字。

下面是一个非静态泛型方法的示例：

	public class GenericClassDemo {
	// 非静态泛型方法，用于打印泛型类型的值
	public <T> void printValue(T value) {
	System.out.println("The value is: " + value);
	}
	// 一个实例字段（非静态字段）
	private String instanceField = "I'm an instance field!";
	public static void main(String[] args) {
	// 创建GenericClassDemo的实例
	GenericClassDemo demo = new GenericClassDemo();
	// 调用非静态泛型方法，传入一个Integer值
	demo.printValue(123);
	// 调用非静态泛型方法，传入一个String值
	demo.printValue("Hello, World!");
	// 注意：由于printValue是非静态的，它不能直接在静态上下文中被调用
	// GenericClassDemo.printValue(123); // 这会编译错误
	// 访问实例字段
	System.out.println(demo.instanceField);
	}
	}

在这个示例中，GenericClassDemo 类有一个非静态泛型方法 printValue，它接受一个类型为 T 的参数并打印其值。此外，该类还有一个非静态字段 instanceField。在 main 方法中，我们创建了一个 GenericClassDemo 的实例 demo，并通过这个实例调用了 printValue 方法，分别传入了一个 Integer 值和一个 String 值。由于 printValue 是非静态的，它必须通过一个类的实例来调用，而不能直接在静态上下文中调用（如 GenericClassDemo.printValue(123); 这样的调用会编译失败）。

请注意，泛型方法中的类型参数 T 是在方法签名中声明的，并且可以在方法的参数、局部变量、返回类型等位置使用。在上面的示例中，T 只在方法参数中使用，但你也可以在方法体内部使用 T 类型的局部变量，或者作为方法的返回类型（如果方法需要返回泛型类型的值）。

 3.java 泛型方法 带约束

在Java中，你可以为泛型方法添加类型约束，以确保传递给泛型方法的参数类型满足某些条件。这通常通过使用extends和super关键字来实现，它们分别用于上界（upper bounds）和下界（lower bounds）约束。

上界约束 (extends)

使用extends关键字可以为泛型参数设置上界约束，表示该泛型类型必须是某个类的子类或实现了某个接口。如果使用了extends但没有指定具体的类，那么默认的约束是Object。

	public class GenericMethodDemo {
	// 泛型方法，接受一个实现了Comparable接口的T类型参数
	public static <T extends Comparable<T>> void sort(List<T> list) {
	// 这里可以使用T的compareTo方法，因为T实现了Comparable<T>
	Collections.sort(list);
	}
	public static void main(String[] args) {
	List<Integer> integerList = Arrays.asList(3, 1, 4, 1, 5, 9);
	sort(integerList); // 可以，因为Integer实现了Comparable<Integer>
	List<String> stringList = Arrays.asList("apple", "banana", "cherry");
	sort(stringList); // 可以，因为String实现了Comparable<String>
	// List<Object> objectList = Arrays.asList(new Object(), new Object());
	// sort(objectList); // 编译错误，因为Object没有实现Comparable<Object>
	}
	}

在这个例子中，sort方法接受一个List<T>作为参数，其中T是实现了Comparable<T>接口的任意类型。由于Integer和String都实现了Comparable接口，所以我们可以将它们的列表传递给sort方法。但是，如果你尝试传递一个List<Object>，编译器会报错，因为Object类没有实现Comparable<Object>接口。

下界约束 (super)

使用super关键字可以为泛型参数设置下界约束，表示该泛型类型必须是某个类的超类或某个接口的实现类。这在处理数字类型或需要保证某种类型层次结构的场景中特别有用。

	public class GenericMethodDemo {
	// 泛型方法，接受一个Number或其子类型的T类型参数
	public static <T extends Number> void printNumber(T number) {
	System.out.println("The number is: " + number);
	}
	// 泛型方法，接受一个Number或其父类型的T类型参数（尽管这种情况不常见，但语法上是允许的）
	public static <T super Integer> void printIntegerOrSuper(T number) {
	// 注意：这里我们不能直接对T类型的变量进行太多操作，因为它可能是Number的超类
	// 但我们可以检查它是否是Integer或其子类的一个实例
	if (number instanceof Integer) {
	System.out.println("The number is an Integer or a subclass of Integer: " + number);
	} else {
	System.out.println("The number is a superclass of Integer: " + number.getClass().getName());
	}
	}
	public static void main(String[] args) {
	printNumber(123); // 可以，因为Integer是Number的子类
	printNumber(3.14); // 可以，因为Double是Number的子类
	// printNumber("hello"); // 编译错误，因为String不是Number的子类
	printIntegerOrSuper(123); // 输出 "The number is an Integer or a subclass of Integer: 123"
	// printIntegerOrSuper(3.14); // 编译错误，因为Double不是Integer的超类
	// 但你可以传递Integer的超类实例，尽管这样做可能不太常见或有用
	}
	}

在这个例子中，printNumber方法接受一个Number或其子类型的参数，而printIntegerOrSuper方法则接受一个Integer或其超类型的参数。但请注意，在实际编程中，使用super关键字来定义泛型参数的下界约束并不常见，因为这样做会限制泛型类型的可用性和灵活性。