泛型实战：复用代码还是独立方法？

🌟 一、什么时候需要使用泛型？

泛型（Generics）的核心目的是：编写“与具体类型无关”的通用代码，同时保持类型安全。

✅ 需要使用泛型的场景：

场景	说明	示例
1. 容器类（集合、栈、队列等）	容器本身不关心存的是什么类型，但要保证取出来的是正确的类型	List<String>, Map<Integer, User>
2. 工具方法（通用逻辑）	方法逻辑与类型无关，只是“传递”或“处理”对象	T max(T a, T b), void swap(T[] arr, int i, int j)
3. 返回自身类型的方法（链式调用）	如 Builder 模式、流式 API	StringBuilder append(...), Stream<T> filter(...)
4. 类型安全的回调/函数式接口	如 Function<T, R>, Predicate<T>	list.stream().filter(user -> user.isActive())

---

✅ 示例：不使用泛型 vs 使用泛型

❌ 不使用泛型（Java 1.4 时代）：

public class Box {
    private Object item;
    public void set(Object item) { this.item = item; }
    public Object get() { return item; }
}

// 使用时需要强制类型转换，且不安全
Box box = new Box();
box.set("hello");
String s = (String) box.get(); // 正确
String s2 = (String) box.get(); // 运行时可能 ClassCastException

✅ 使用泛型：

public class Box<T> {
    private T item;
    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

// 使用时无需强转，编译期检查
Box<String> stringBox = new Box<>();
stringBox.set("hello");
String s = stringBox.get(); // 类型安全，无需强转

✅ 优势：类型安全 + 无需强转 + 代码复用

---

❌ 二、什么时候需要为不同类型定义不同的方法？（即：不用泛型）

当不同类型的处理逻辑完全不同时，就不能用泛型，而应为每种类型写独立的方法。

需要为不同类型定义不同方法的场景：

场景	说明	示例
1. 业务逻辑差异大	比如 int 要加 1，String 要转大写，逻辑完全不同	process(Integer i) vs process(String s)
2. 依赖类型特有方法	方法内部调用了某个类型的特有方法，无法通用	user.getName() vs order.getId()
3. 性能敏感，需避免装箱/泛型开销	如 int 和 long 的数学运算，用泛型会有装箱开销	sum(int[] arr) vs sum(long[] arr)
4. 原始类型（primitive types）的高性能计算	泛型不支持 int、double 等原始类型（会自动装箱）	数值计算库（如 FastUtil）为每种原始类型提供单独实现

---

✅ 示例：不同类型的处理逻辑不同

// ❌ 不能用一个泛型方法处理
public void process(Object obj) {
    if (obj instanceof Integer) {
        System.out.println((Integer)obj + 1);
    } else if (obj instanceof String) {
        System.out.println(((String)obj).toUpperCase());
    } else if (obj instanceof List) {
        System.out.println("List size: " + ((List<?>)obj).size());
    }
}

// ✅ 正确做法：方法重载（Overload）
public void process(Integer i) {
    System.out.println(i + 1);
}

public void process(String s) {
    System.out.println(s.toUpperCase());
}

public void process(List<?> list) {
    System.out.println("List size: " + list.size());
}

✅ 这样更清晰、性能更好、类型安全。

---

🔄 三、泛型 vs 方法重载 vs Object

方式	适用场景	优点	缺点
泛型	逻辑通用，类型无关	类型安全、复用性强、无需强转	不能处理原始类型高性能场景
方法重载	不同类型逻辑不同	性能好、逻辑清晰	代码重复、维护成本高
Object	兼容老代码或类型不确定	灵活	运行时类型错误、需强转

---

✅ 四、最佳实践总结

情况	推荐做法
通用容器或工具类	✅ 使用泛型
逻辑相同，只是类型不同	✅ 使用泛型
不同类型，逻辑完全不同	✅ 使用方法重载
高性能数值计算	✅ 为 int、long 等提供专用方法
需要调用类型特有方法	✅ 不用泛型，用具体类型或重载

---

🔁 五、一句话总结

用泛型：当“做什么”相同，只是“对什么做”不同。
不用泛型：当“做什么”本身就因类型而异。

✅ 举例：

• List<T>.add(T) → 用泛型（都是“添加”）
• Integer.parseInt(s) vs Double.parseDouble(s) → 不用泛型，逻辑不同
• Collections.sort(List<T>) → 用泛型（排序逻辑通用）

---

如果你在设计一个工具类或 API，问自己：

1. 这个方法的逻辑是否对所有类型都一样？
2. 是否只是“传递”或“操作结构”，而不关心具体内容？

如果是，就用泛型；如果否，就考虑方法重载或具体类型实现。