1
public class ObjectBox {
2
    private Object value;
3

4
    public void set(Object value) { this.value = value; }
5
    public Object get() { return value; }
6
}

1
ObjectBox box = new ObjectBox();
2
box.set("张三");
3
String name = (String) box.get(); // 取出来必须强转
4

5
box.set(123);                     // 放个整数进去——编译通过（123 自动装箱成 Integer）
6
String oops = (String) box.get(); // 运行时才炸：ClassCastException

1
public class Box<T> {
2
    private T value;
3
    public void set(T value) { this.value = value; }
4
    public T get() { return value; }
5
}

1
Box<String> box = new Box<>();
2
box.set("张三");
3
String name = box.get();                 // 不用强转，编译器知道是 String
4

5
box.set(123);                            // ❌ 编译期就报错

1
public class Pair {
2
    private Object first;                 // T 被换成了 Object
3
    private Object second;
4

5
    public Pair(Object first, Object second) { ... }
6
    public Object getFirst() { return first; }
7
}

1
Pair<String> a = new Pair<>("x", "y");
2
Pair<Integer> b = new Pair<>(1, 2);
3
System.out.println(a.getClass() == b.getClass());   // true

1
Pair<String> a = new Pair<>("张三", "李四");
2
Pair raw = a;              // 原始类型，绕过检查
3
raw.setFirst(123);         // ⚠️ 只有 unchecked 警告，照样编译
4
String s = a.getFirst();   // 编译器仍按 String 处理 → 运行时 ClassCastException

1
Pair<Employee> p = new Pair<>(e1, e2);
2
Employee e = p.getFirst();

1
Employee e = (Employee) p.getFirst();

1
p.setFirst(e);          // 传进去：Employee → Object，向上转，不需要
2
Employee e = p.getFirst();   // 取出来：Object → Employee，向下转，必须强转

1
public class Employee implements Comparable<Employee> {
2
    private double salary;
3

4
    @Override
5
    public int compareTo(Employee other) {
6
        return Double.compare(salary, other.salary);
7
    }
8
}

1
public class Employee implements Comparable {
2
    public int compareTo(Employee other) {        // 你写的那个
3
        return Double.compare(salary, other.salary);
4
    }
5

6
    // 编译器生成的桥方法
7
    public int compareTo(Object other) {
8
        return compareTo((Employee) other);
9
    }
10
}

1
@SuppressWarnings("unchecked")
2
Pair<Employee> p = oldLibrary.getPair();   // 我确认它装的是 Employee

1
Pair<int> p;              // ❌ 基本类型不能当类型实参
2
Pair<Integer> q;          // ✅ 用包装器

1
if (x instanceof Pair<String>) { }    // ❌ 编译错误
2
if (x instanceof Pair) { }            // ✅ 只能这么写

1
Pair<String>[] arr = new Pair<String>[10];   // ❌
2
Pair<?>[] arr2 = new Pair<?>[10];            // ❌ 通配符也不行

1
Pair<String>[] arr = new Pair<String>[10];      // 假设这行合法
2
Object[] objs = arr;                            // 数组协变，允许
3
objs[0] = new Pair<Integer>(1, 2);              // 只检查「是不是 Pair」，放行
4
String s = arr[0].getFirst();                   // 实际是 Integer → ClassCastException

1
@SafeVarargs
2
public static <T> void addAll(List<T> list, T... values) {
3
    for (T v : values) list.add(v);
4
}

1
public static <T> T create() {
2
    return new T();          // ❌ 运行时不知道 T 是什么
3
}

1
public static <T> T create(Supplier<T> factory) {
2
    return factory.get();
3
}
4

5
Employee e = create(() -> new Employee("张三", 5000));

1
T[] arr = new T[10];         // ❌

1
public class Box<T> {
2
    private static T value;              // ❌
3
    public static T get() { return null; }  // ❌
4
}

1
public static <U> U identity(U x) { return x; }   // ✅ 另一个类型变量

1
class MyException<T> extends Exception { }   // ❌ 泛型类不能继承 Throwable
2
try { ... } catch (T e) { }                  // ❌

1
@SuppressWarnings("unchecked")
2
static <T extends Throwable> void sneakyThrow(Throwable t) throws T {
3
    throw (T) t;
4
}

1
public class Pair<T> {
2
    public boolean equals(T value) { ... }   // ❌ 编译错误
3
}

1
public static void printName(Pair<Employee> p) {
2
    System.out.println(p.getFirst().getName());
3
}

1
public static void printName(Pair<? extends Employee> p) {
2
    System.out.println(p.getFirst().getName());   // ✅ 读出来是 Employee
3
}

1
public static void printName(Pair<? extends Employee> p) {
2
    p.setFirst(new Employee("张三", 5000));   // ❌
3
    p.setFirst(new Manager("张三", 5000));    // ❌ 连 Manager 也不行
4
}

1
public static void addManager(Pair<? super Manager> p) {
2
    p.setFirst(new Manager("李四", 8000));   // ✅
3
}

1
Pair<?> p;

1
public static boolean isEmpty(Pair<?> p) {
2
    return p.getFirst() == null;
3
}

1
public static void swap(Pair<?> p) {
2
    ? t = p.getFirst();      // ❌ ? 不是类型名，不能用来声明变量
3
    ...
4
}

1
public static void swap(Pair<?> p) {
2
    swapHelper(p);
3
}
4

5
private static <T> void swapHelper(Pair<T> p) {
6
    T t = p.getFirst();      // ✅ 这里的 T 是具体的
7
    p.setFirst(p.getSecond());
8
    p.setSecond(t);
9
}

1
Class<String> c = String.class;
2
String s = c.getDeclaredConstructor().newInstance();   // 直接返回 String

1
public static <T> T create(Class<T> c) throws Exception {
2
    return c.getDeclaredConstructor().newInstance();
3
}
4

5
Employee e = create(Employee.class);     // 返回 Employee

1
class MyList extends ArrayList<String> { }
2

3
Type t = MyList.class.getGenericSuperclass();   // ArrayList<String>