泛型详解与示例

泛型是Java编程语言中一种强大的特性，它使得类、接口和方法能够以一种更加通用和安全的方式进行设计。通过泛型，可以实现在编译时期对数据类型进行检查，提高代码的可读性和健壮性。本文将详细介绍Java泛型的相关概念，并提供具体的代码示例。

1. 泛型基础概念

泛型的主要目的是参数化类型，允许在定义类、接口和方法时使用类型参数，然后在使用时指定具体的类型。泛型的语法使用尖括号 <T> 表示，其中 T 是类型参数的占位符。

// 泛型类示例
public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

2. 泛型类和泛型方法

2.1 泛型类示例

public class Pair<T, U> {
    private T first;
    private U second;

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

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

2.2 泛型方法示例

public class GenericMethodExample {
    // 泛型方法
    public <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        GenericMethodExample example = new GenericMethodExample();

        // 调用泛型方法
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        example.printArray(intArray);

        String[] stringArray = { "apple", "orange", "banana" };
        example.printArray(stringArray);
    }
}

3. 通配符（Wildcards）

通配符允许在泛型中使用不确定的类型。通配符使用 ? 表示。

public class WildcardExample {
    // 使用通配符的泛型方法
    public static void printList(List<?> list) {
        for (Object element : list) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
        List<String> stringList = Arrays.asList("apple", "orange", "banana");

        // 调用使用通配符的泛型方法
        printList(integerList);
        printList(stringList);
    }
}

4. 限定泛型类型（Bounded Generics）

通过限定泛型类型，可以确保泛型只能是某些类型的子类或实现了某些接口的类。

public class BoundedGenericsExample {
    // 限定泛型类型的泛型方法
    public static <T extends Number> double sumOfList(List<T> list) {
        double sum = 0.0;
        for (T element : list) {
            sum += element.doubleValue();
        }
        return sum;
    }

    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
        List<Double> doubleList = Arrays.asList(1.1, 2.2, 3.3, 4.4, 5.5);

        // 调用限定泛型类型的泛型方法
        System.out.println("Sum of integers: " + sumOfList(integerList));
        System.out.println("Sum of doubles: " + sumOfList(doubleList));
    }
}

以上是Java泛型的基本概念和常见用法。通过合理使用泛型，可以增强代码的灵活性和安全性，使得代码更具可维护性和可扩展性。