Java基础-泛型使用在Java中，泛型允许你编写更通用、类型安全的代码。泛型通常用于类、接口和方法中，以允许它们与不同

Java泛型：深入理解与实战应用

前言

Java中的泛型（Generics）是JDK 1.5引入的一个重要特性，它为类型参数化提供了支持。通过泛型，我们可以在编译时指定类、接口和方法的类型参数，从而提高代码的复用性、类型安全性和可读性。本文将详细介绍Java泛型的使用，包括泛型类、泛型接口、泛型方法、通配符以及边界等高级特性。

一、泛型类

泛型类允许我们定义一个类，该类可以操作任意类型的数据。

	// 定义一个泛型类
	class Box<T> {

	    private T item;
	    public void setItem(T item) {

	        this.item = item;
	    }

	    public T getItem() {

	        return item;

	    }

	}

	public class GenericClassDemo {

	    public static void main(String[] args) {

	        // 使用泛型类

	        Box<Integer> intBox = new Box<>();
	        intBox.setItem(123);
	        System.out.println("Stored Integer: " + intBox.getItem());
	        Box<String> stringBox = new Box<>();
	        stringBox.setItem("Hello, World!");
	        System.out.println("Stored String: " + stringBox.getItem());

	    }

	}

说明：

Box<T> 是一个泛型类，其中 T 是一个类型参数。
在创建 Box 对象时，我们可以指定 T 的具体类型，如 Integer 或 String。

二、泛型接口

泛型接口与泛型类类似，允许接口定义类型参数。

java
	// 定义一个泛型接口

	interface Processor<T> {

	    void process(T item);
	}

	// 实现泛型接口的类

	class StringProcessor implements Processor<String> {

	    @Override

	    public void process(String item) {

	        System.out.println("Processing string: " + item);
	    }
	}
	public class GenericInterfaceDemo {

	    public static void main(String[] args) {

	        // 使用泛型接口的实现类

	        Processor<String> stringProcessor = new StringProcessor();

	        stringProcessor.process("Generic Interface Example");

	    }
	}

说明：

Processor<T> 是一个泛型接口，其中 T 是一个类型参数。
StringProcessor 类实现了 Processor<String> 接口，并提供了具体的 process 方法实现。

三、泛型方法

泛型方法允许我们在方法级别上使用泛型。

	public class GenericMethodDemo {
	    // 定义一个独立的泛型方法

	    public static <E> void print(E element) {

	        System.out.println("Element: " + element);
	    }
	    public static void main(String[] args) {

	        // 使用泛型方法
	        print(3.14);
	        print("Another Generic Method Example");

	    }

	}

说明：

<E> 声明了一个类型参数 E，它可以在方法签名中使用。
print 方法可以接受任何类型的参数并打印。

四、通配符与边界

1. 通配符 `?`

通配符 ? 表示未知类型，常用于定义泛型方法的参数或泛型类的字段。

	import java.util.List;
	public class WildcardDemo {
	    public static void printList(List<?> list) {
	        for (Object item : list) {
	            System.out.println(item);
	        }
	    }
	    public static void main(String[] args) {
	        List<Integer> intList = List.of(1, 2, 3);
	        List<String> stringList = List.of("a", "b", "c");
	        printList(intList);
	        printList(stringList);
	    }
	}

说明：

List<?> 表示一个包含未知类型元素的列表。
printList 方法可以接受任何类型的 List。

2. 边界

边界用于限制泛型参数的类型范围。

上界：<T extends Number> 表示 T 必须是 Number 类型或其子类。
下界：<T super Integer> 表示 T 必须是 Integer 类型或其父类（不常用）。

	import java.util.List;
	public class BoundedWildcardDemo {
	    // 使用上界

	    public static double sumOfList(List<? extends Number> list) {

	        double sum = 0;

	        for (Number num : list) {
	            sum += num.doubleValue();
	        }
	        return sum;
	    }

	    public static void main(String[] args) {
	        List<Integer> intList = List.of(1, 2, 3);
	        List<Double> doubleList = List.of(1.1, 2.2, 3.3);
	        System.out.println("Sum of Integer list: " + sumOfList(intList));
	        System.out.println("Sum of Double list: " + sumOfList(doubleList));
	    }
	}

说明：

List<? extends Number> 表示一个包含 Number 类型或其子类元素的列表。
sumOfList 方法可以计算任何 Number 类型列表的和。

五、泛型的优点

类型安全：泛型提供了编译时的类型检查，避免了类型转换异常。
代码复用：通过泛型，我们可以编写更通用的代码，减少重复代码。
可读性：泛型使代码更清晰，易于理解。

六、总结

Java泛型是一个强大的特性，它极大地提高了代码的复用性、类型安全性和可读性。通过泛型类、泛型接口、泛型方法、通配符以及边界等高级特性，我们可以编写出更加灵活和健壮的代码。希望本文能帮助你更好地理解和应用Java泛型。

希望这篇文章对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。

Java基础-泛型使用