java ＜T＞ 是什么？

public static <T> T createDefault(Class<T> clazz) {
    try {
        return clazz.getDeclaredConstructor().newInstance();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

看这个方法，总共3个T，返回的又是一个实例对象。如果是一个新手，或者猛一看源码的同学简直是天书，这是JAVA 嘛？JAVA 现在进化了？我学的是什么？
但是实际上并不难，只是定义的T 让你觉得莫名其妙。只是官方推荐用法。
首先这个T 只是一个T 不是语法要求，只是约定；
你可以用任何合法标识符代替 T；
但为了代码清晰、团队协作、符合行业标准，请优先使用 T, E, K, V 等通用命名；
不要为了“看起来像具体类型”而用名词命名泛型参数（如 User, Data），这会造成误解。

更复杂一些

// 单泛型：用 T
class Box<T> { ... }

// 双泛型：T 和 U
public static <T, U> void copy(List<T> src, List<U> dest) { ... }

// Map：K 和 V
interface Map<K, V> { ... }

1.第一个< T>：泛型类型参数（类型变量） T 是一个占位符，代表“调用时确定的具体类型”。
2.第二个 T：返回类型
3.第三个Class: 带泛型的T 实体，举个例子T是User,那么就是Class< User>
4.返回值：return clazz.getDeclaredConstructor().newInstance();
返回一个Class 的T 实例对象，相对于T t = new T();
第二个T 和 返回值一定要一样，举个例子：T 是User 那么返回的实例对象就必须是User。

在 Java 中，< T> 和 < Object> 虽然都涉及“类型”，但它们在语义、用途和类型安全性上有本质区别。下面是详细对比：

✅ 1. < T>：泛型类型参数（类型变量）
T 是一个占位符，代表“调用时确定的具体类型”。
它是泛型机制的一部分，用于编写类型安全且可复用的代码。
编译器会在编译期进行类型推断和检查，避免运行时 ClassCastException。
示例：

public static <T> List<T> wrap(T item) {
    return new ArrayList<>(List.of(item));
}

// 使用
List<String> list1 = wrap("hello");      // T 推断为 String
List<Integer> list2 = wrap(42);          // T 推断为 Integer
✅ 类型安全：list1 只能放 String，list2 只能放 Integer。

第一个 < T> 是必须的（在静态泛型方法中）
如果你在一个方法里要使用泛型类型变量（比如 T），就必须先声明它。

第一个 < T> 叫做 “泛型方法的类型参数声明”。
它的作用是：告诉编译器：“我这个方法要用一个叫 T 的类型变量，请允许我在签名和方法体里使用它。”

参数类型必须是 T

但是泛型中的 T 不是“绑定到某个参数位置”的，而是“代表一个类型”，它可以出现在参数、返回值或方法内部，只要逻辑上需要类型安全和复用。”

所以你完全不用纠结“是不是某个参数必须叫 T”——

哪里需要通用类型，哪里就用 T；不需要的地方，就用具体类型。

❌ 2. < Object>：固定使用 Object 类型
Object 是 Java 中所有类的父类，但它是具体类型，不是泛型参数。
如果你用 Object 代替泛型，就失去了类型安全，需要手动强制转换。
示例（不推荐）：

public static List<Object> wrap(Object item) {
    return new ArrayList<>(List.of(item));
}

// 使用
List<Object> list = wrap("hello");
String s = (String) list.get(0);  // 必须强制转换，不安全！
⚠️ 风险：如果 list 里实际存的是 Integer，强转成 String 会抛出 ClassCastException。

🚫 常见误区
有人以为 “T 就是 Object”，这是错误的。

虽然 JVM 在运行时会类型擦除（把 T 擦成 Object），但在编译期，T 提供了严格的类型约束，而 Object 没有。

✅ 最佳实践
优先使用泛型 < T>，除非你明确需要处理完全未知类型的对象（极少见）。
不要用 Object 来“模拟泛型”，那会失去泛型存在的意义。
补充：如果你写成

public static PredictRespVO<Object> ok(String message, Object data)

那么返回的 PredictRespVO 的 data 字段永远是 Object 类型，使用者必须强转，既不安全也不优雅。
而用 < T>：

public static <T> PredictRespVO<T> ok(String message, T data)

使用者拿到的就是 PredictRespVO、PredictRespVO 等精确类型，无需强转，IDE 还能智能提示。

✅ 结论：

< T> 是带类型安全的通用化，< Object> 是无类型的通用化。

在现代 Java 开发中，应尽可能使用泛型 < T>。

@Data
public class PredictRespVO<T> {
    private Integer retCode;
    private String message;
    private T data;

    public PredictRespVO(Integer retCode, String message, T data) {
        this.retCode = retCode;
        this.message = message;
        this.data = data;
    }

    public PredictRespVO() {
    }


    // 工厂方法
    public static <T> PredictRespVO<T> success(T data) {
        return new PredictRespVO<>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMsg(), data);
    }

    public static <T> PredictRespVO<T> error() {
        return new PredictRespVO<>(ResultCode.SYSTEM_ERROR.getCode(), ResultCode.SYSTEM_ERROR.getMsg(), null);
    }

    public static <T> PredictRespVO<T> error(String message) {
        return new PredictRespVO<>(ResultCode.SYSTEM_ERROR.getCode(), message, null);
    }

    public static <T> PredictRespVO<T> error(Integer retCode, String message) {
        return new PredictRespVO<>(retCode, message, null);
    }

    public static <T> PredictRespVO<T> ok(String message, T data) {
        return new PredictRespVO<>(200, message, data);
    }
}

泛型类和普通类有什么主要区别？

使用的场景：
✅ 情况一：你真的不需要泛型（最常见）

public static <T> String process(T input) {
    return "处理完成";
}

语法上 ✅ 合法；
但逻辑上 ❌ < T> 是多余的，因为：
你没用 input 做任何依赖类型的操作；
返回值是固定的 String，和 T 无关；
调用时 T 被推断了，但毫无作用。
✅ 更好的写法（去掉泛型）：

public static String process(Object input) {
    return "处理完成";
}

或者如果只接受特定类型，就用具体类型。

📌 原则：不要为了“看起来高级”而加泛型。只有当类型信息对逻辑或类型安全有影响时，才用泛型。
✅ 情况二：你用了 T，但返回固定类型（合理场景）
有些工具方法会接收泛型参数，但返回固定类型，比如日志、序列化：

public static <T> String toJson(T obj) {
    return new Gson().toJson(obj); // 把任意对象转成 JSON 字符串
}

// 调用
String json1 = toJson("hello");
String json2 = toJson(new User());

✅ 这是合理使用泛型的例子：

输入类型可变（T）；
输出固定为 String；
泛型让方法能安全接受任意类型，无需强转。
所以：虽然返回 String，但因为参数是 T 且被实际使用了，泛型是有意义的。

❌ 情况三：你声称返回 T，却返回 String（编译错误！）

public static <T> T getSomething(T input) {
    return "hello"; // ❌ 编译错误！
}

方法签名说“返回 T”，但你返回了 String；
编译器无法保证 “hello” 就是 T（比如调用时 T = Integer）；
所以 编译失败。
除非你强制转换（不推荐）：

return (T) "hello"; // ⚠️ unchecked cast，运行时可能 ClassCastException