Java泛型提升代码复用性的方法

泛型在Java集合框架中的核心应用是提供编译时类型安全检查，避免运行时类型转换异常。1. 使用泛型后，集合如List在声明时即限定元素类型，向List添加Integer会触发编译错误；2. 从泛型集合中获取元素时无需强制类型转换，编译器已确知返回类型；3. 消除了使用Object类型集合时频繁的强制转换及ClassCastException风险；4. 提升代码可读性、可维护性和复用性，使集合框架更加安全高效。这一机制广泛应用于ArrayList、HashMap等集合类，是Java泛型最典型和最重要的实践场景。

Java代码中利用泛型，本质上是在编写代码时引入了“类型参数”的概念，这让我们的类、接口和方法能够处理多种数据类型，同时在编译阶段就保证了类型安全。它直接解决了传统Java中，为了通用性而不得不使用Object类型带来的强制类型转换和潜在的运行时错误问题，从而大幅提升了代码的复用性和健壮性。

解决方案

泛型让代码变得更“聪明”，它不再是写死只处理特定类型，而是可以像一个模具，根据你传入的类型来铸造出对应的实例。想想看，如果没有泛型，你可能需要为存储整数的列表写一个IntList，为存储字符串的列表写一个StringList，这显然是重复劳动。泛型则提供了一个List，这个T就像一个占位符，你实例化时告诉它T是Integer，它就是List；告诉它是String，它就是List。这种参数化的能力，使得一套代码逻辑能适应不同的数据类型，极大地减少了冗余代码，让系统设计更加优雅。

泛型的核心在于编译时期的类型检查。当你声明List时，编译器就知道这个列表只能放字符串。如果你不小心往里面塞了个整数，它会立刻报错，而不是等到程序运行起来才发现类型转换异常。这种“提前发现问题”的机制，是泛型对代码质量和可维护性最大的贡献之一。它将许多本应在运行时暴露的类型错误，提前到了编译期，降低了调试成本。

// 没有泛型时，可能需要这样处理，或者使用Object并进行强制类型转换
// public class MyIntegerBox {
//     private Integer data;
//     public MyIntegerBox(Integer data) { this.data = data; }
//     public Integer getData() { return data; }
// }
// public class MyStringBox {
//     private String data;
//     public MyStringBox(String data) { this.data = data; }
//     public String getData() { return data; }
// }

// 有了泛型，一个类就够了
public class GenericBox { // T是类型参数，可以代表任何类型
    private T data;

    public GenericBox(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public static void main(String[] args) {
        GenericBox integerBox = new GenericBox<>(123);
        System.out.println("Integer Box Data: " + integerBox.getData()); // 无需类型转换

        GenericBox stringBox = new GenericBox<>("Hello Generics!");
        System.out.println("String Box Data: " + stringBox.getData()); // 无需类型转换

        // 编译错误：类型不匹配
        // integerBox = new GenericBox<>("This is a string"); 
    }
}

通过这种方式，我们避免了为每种数据类型都编写一个Box类，一套GenericBox代码就能满足所有需求，复用性自然就上去了。

泛型在Java集合框架中的核心应用是什么？

如果你经常使用Java，那么你几乎不可能避开集合框架，而泛型在这里简直是如鱼得水，发挥得淋漓尽致。可以说，泛型就是为集合框架量身定制的。想象一下，如果没有泛型，我们写List、Set、Map时会是怎样一番景象？

早期的Java版本，集合类存储的都是Object类型。这意味着你往ArrayList里放什么都行，整数、字符串、自定义对象，它来者不拒。但当你从列表里取数据的时候，问题就来了：取出来的是Object，你需要手动把它强制转换成你期望的类型。比如，你明明知道里面都是字符串，但每次取出来还得写(String) list.get(i)。这不仅繁琐，而且危险。万一你放进去的是字符串，取的时候却误以为是整数，强转就会抛出ClassCastException，程序直接崩溃。

有了泛型，一切都变了。当你声明List myStringList = new ArrayList<>();时，你就明确告诉编译器：这个列表里只允许存放String类型的对象。当你调用myStringList.add(new Integer(123))时，编译器会立即报错，因为它知道Integer不是String。同样，当你调用String s = myStringList.get(0);时，编译器已经知道get(0)返回的必然是String类型，所以你根本不需要进行任何强制类型转换。

这种编译时期的类型检查，彻底消除了运行时ClassCastException的风险，让代码变得更加安全可靠。同时，也让代码更易读、更简洁，因为那些烦人的类型转换代码统统不见了。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GenericCollectionsDemo {
    public static void main(String[] args) {
        // 使用泛型的ArrayList
        List names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        // names.add(123); // 编译错误：类型不匹配

        String firstName = names.get(0); // 无需类型转换，编译器知道是String
        System.out.println("First name: " + firstName);

        // 使用泛型的HashMap
        Map studentMap = new HashMap<>();
        studentMap.put(101, "张三");
        studentMap.put(102, "李四");
        // studentMap.put("key", "value"); // 编译错误：键或值类型不匹配

        String studentName = studentMap.get(101); // 无需类型转换
        System.out.println("Student 101: " + studentName);

        // 尝试一个没有泛型的老式集合（不推荐，但为了对比）
        // List rawList = new ArrayList();
        // rawList.add("Hello");
        // rawList.add(123);
        // String s = (String) rawList.get(0); // 需要强制转换
        // Integer i = (Integer) rawList.get(1); // 需要强制转换
        // String wrong = (String) rawList.get(1); // 运行时错误：ClassCastException
    }
}

通过泛型，我们得到了一个既安全又高效的集合框架，它让开发者能够专注于业务逻辑，而不是疲于应对类型转换的潜在问题。

如何编写一个简单的泛型类或泛型方法？

泛型编程的入门其实并不复杂，核心在于理解类型参数T（或者其他大写字母，比如E for Element, K for Key, V for Value）的含义。它就像一个临时的占位符，在类或方法被具体使用时才被替换为实际的类型。

编写泛型类： 泛型类通常用于创建可以操作不同类型数据的容器类或工具类。我们之前看到的GenericBox就是一个典型的例子。

// 泛型类的定义：在类名后面用尖括号<>声明一个或多个类型参数
public class Pair { // K代表键的类型，V代表值的类型
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public static void main(String[] args) {
        // 使用泛型类，指定具体的类型参数
        Pair studentAge = new Pair<>("Alice", 20);
        System.out.println("Student: " + studentAge.getKey() + ", Age: " + studentAge.getValue());

        Pair coordinate = new Pair<>(10.5, "Latitude");
        System.out.println("Coordinate: " + coordinate.getKey() + ", Type: " + coordinate.getValue());

        // 尝试赋值不同类型会报错
        // studentAge.setKey(123); // 编译错误
    }
}

这里的Pair可以存储任意两种类型的数据对，这比你为String, Integer写一个StringIntegerPair，再为Double, String写一个DoubleStringPair要高效得多。

编写泛型方法： 泛型方法则是在方法级别上实现类型参数化，它可以在普通类中定义，也可以在泛型类中定义。泛型方法的类型参数通常在方法的返回类型之前声明。

public class GenericMethodDemo {

    // 泛型方法的定义：在返回类型之前声明类型参数
    public static  void printArray(T[] array) {
        System.out.print("Array elements: ");
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    // 另一个泛型方法：返回两个元素中较大的一个（需要T实现Comparable接口）
    public static > T findMax(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"apple", "banana", "cherry"};
        Double[] doubleArray = {1.1, 2.2, 3.3};

        printArray(intArray);    // 编译器会自动推断T为Integer
        printArray(stringArray); // 编译器会自动推断T为String
        printArray(doubleArray); // 编译器会自动推断T为Double

        System.out.println("Max of 10 and 20: " + findMax(10, 20));
        System.out.println("Max of 'zebra' and 'apple': " + findMax("zebra", "apple"));
    }
}

printArray方法能够打印任何类型的数组，而findMax方法则能比较任何可比较的类型。注意findMax中的T extends Comparable，这叫做类型边界，它限制了T必须是可比较的类型，否则compareTo方法就无法调用。这种限制确保了方法的逻辑在运行时是有效的。

通过这些简单的例子，你会发现泛型让代码的通用性和复用性达到了一个新的高度，而且是在保证类型安全的前提下实现的。

泛型中的类型擦除（Type Erasure）是什么，它对泛型编程有什么影响？

谈到Java泛型，就不得不提“类型擦除”这个概念，它有点像泛型背后的一个“秘密”或者说“妥协”。简单来说，类型擦除是指Java编译器在编译泛型代码时，会将所有的泛型信息（比如List中的）擦除掉，替换成它们的限定类型（如果没有限定，就替换成Object）。这意味着在运行时，List和List在JVM看来，都是同一个东西——List（或者更精确地说，是List