1
Throwable
2
├── Error                     ← JVM 层面的严重错误，程序员管不了
3
│     ├── OutOfMemoryError    ← 内存耗尽
4
│     ├── StackOverflowError  ← 栈溢出（无限递归）
5
│     └── NoClassDefFoundError
6
│
7
└── Exception                 ← 程序可以处理的异常
8
      ├── RuntimeException    ← 运行时异常（非受检，Unchecked）
9
      │     ├── NullPointerException       ← 空指针
10
      │     ├── IndexOutOfBoundsException  ← 索引越界
11
      │     ├── ArithmeticException        ← 算术异常（除以 0）
12
      │     ├── ClassCastException         ← 类型转换失败
13
      │     ├── IllegalArgumentException   ← 参数不合法
14
      │     ├── IllegalStateException      ← 状态不合法
15
      │     └── NumberFormatException      ← 字符串转数字失败
16
      │
17
      └── 其他 Exception 子类   ← 受检异常（Checked）
18
            ├── IOException            ← 输入输出错误
19
            ├── SQLException           ← 数据库错误
20
            ├── FileNotFoundException  ← 文件找不到
21
            └── InterruptedException   ← 线程被中断

1
// ❌ 编译报错：未处理的 IOException
2
public void readFile() {
3
    FileInputStream fis = new FileInputStream("a.txt");
4
}
5

6
// ✅ 方式一：try/catch 处理
7
public void readFile() {
8
    try {
9
        FileInputStream fis = new FileInputStream("a.txt");
10
    } catch (FileNotFoundException e) {
11
        System.err.println("文件不存在：" + e.getMessage());
12
    }
13
}
14

15
// ✅ 方式二：throws 声明抛出，让调用者处理
16
public void readFile() throws FileNotFoundException {
17
    FileInputStream fis = new FileInputStream("a.txt");
18
}

1
String s = null;
2
s.length();       // 运行时抛 NullPointerException，编译期不报错

1
// ❌ 传统写法，繁琐且容易漏 close
2
BufferedReader br = null;
3
try {
4
    br = new BufferedReader(new FileReader("a.txt"));
5
    return br.readLine();
6
} catch (IOException e) {
7
    ...
8
} finally {
9
    if (br != null) {
10
        try { br.close(); } catch (IOException e) { ... }
11
    }
12
}
13

14
// ✅ try-with-resources
15
try (BufferedReader br = new BufferedReader(new FileReader("a.txt"))) {
16
    return br.readLine();
17
} catch (IOException e) {
18
    ...
19
}
20
// 出了 try 块 br 自动关闭，即使抛异常也会关

1
try (
2
    InputStream in = new FileInputStream("in.txt");
3
    OutputStream out = new FileOutputStream("out.txt")
4
) {
5
    in.transferTo(out);
6
} catch (IOException e) {
7
    e.printStackTrace();
8
}

1
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
2
try (br) {           // 直接引用外部变量
3
    return br.readLine();
4
}

1
// throw：抛异常
2
public void setAge(int age) {
3
    if (age < 0) {
4
        throw new IllegalArgumentException("年龄不能为负数：" + age);
5
    }
6
    this.age = age;
7
}
8

9
// throws：声明异常
10
public void readFile(String path) throws IOException {
11
    BufferedReader br = new BufferedReader(new FileReader(path));
12
    ...
13
}
14

15
// 两者常常同时出现
16
public void process(String path) throws IOException {
17
    if (path == null) {
18
        throw new IllegalArgumentException("path 不能为 null");   // 非受检，不需要声明
19
    }
20
    readFile(path);   // 受检，向上抛
21
}

1
// 非受检异常（推荐）：继承 RuntimeException
2
public class BusinessException extends RuntimeException {
3
    private final String code;
4

5
    public BusinessException(String code, String message) {
6
        super(message);
7
        this.code = code;
8
    }
9

10
    public BusinessException(String code, String message, Throwable cause) {
11
        super(message, cause);
12
        this.code = code;
13
    }
14

15
    public String getCode() { return code; }
16
}
17

18
// 受检异常：继承 Exception
19
public class InsufficientBalanceException extends Exception {
20
    public InsufficientBalanceException(double balance, double amount) {
21
        super("余额不足：当前 %.2f，需要 %.2f".formatted(balance, amount));
22
    }
23
}
24

25
// 使用
26
public void withdraw(double amount) {
27
    if (amount > balance) {
28
        throw new BusinessException("INSUFFICIENT_BALANCE", "余额不足");
29
    }
30
}

1
List list = new ArrayList();
2
list.add("hello");
3
list.add(123);            // 编译器不报错
4

5
String s = (String) list.get(0);   // ✅
6
String n = (String) list.get(1);   // ❌ 运行时 ClassCastException

1
List<String> list = new ArrayList<>();
2
list.add("hello");
3
// list.add(123);         // ❌ 编译报错
4

5
String s = list.get(0);   // ✅ 无需强转

1
const list: string[] = [];
2
list.push("hello");
3
// list.push(123);        // ❌ 类型错误

1
public class Box<T> {
2
    private T content;
3

4
    public void put(T item) {
5
        this.content = item;
6
    }
7

8
    public T take() {
9
        return content;
10
    }
11
}
12

13
// 使用
14
Box<String> stringBox = new Box<>();
15
stringBox.put("hello");
16
String s = stringBox.take();       // 无需强转
17

18
Box<Integer> intBox = new Box<>();
19
intBox.put(42);
20
Integer n = intBox.take();

1
public class Pair<K, V> {
2
    private final K key;
3
    private final V value;
4

5
    public Pair(K key, V value) {
6
        this.key = key;
7
        this.value = value;
8
    }
9

10
    public K getKey() { return key; }
11
    public V getValue() { return value; }
12
}
13

14
Pair<String, Integer> p = new Pair<>("age", 25);

1
public interface Comparable<T> {
2
    int compareTo(T other);
3
}
4

5
public class Student implements Comparable<Student> {
6
    private int score;
7

8
    @Override
9
    public int compareTo(Student other) {
10
        return Integer.compare(this.score, other.score);
11
    }
12
}

1
public class Utils {
2
    // 泛型方法：接受任意类型的 List，返回同类型的第一个元素
3
    public static <T> T first(List<T> list) {
4
        return list.isEmpty() ? null : list.get(0);
5
    }
6

7
    // 多类型参数
8
    public static <K, V> Map<V, K> invert(Map<K, V> map) {
9
        Map<V, K> result = new HashMap<>();
10
        for (Map.Entry<K, V> e : map.entrySet()) {
11
            result.put(e.getValue(), e.getKey());
12
        }
13
        return result;
14
    }
15

16
    // 类型参数带边界（bounded）
17
    public static <T extends Comparable<T>> T max(T a, T b) {
18
        return a.compareTo(b) >= 0 ? a : b;
19
    }
20

21
    // 多边界（用 &）
22
    public static <T extends Number & Comparable<T>> T maxNum(T a, T b) {
23
        return a.compareTo(b) >= 0 ? a : b;
24
    }
25
}
26

27
// 使用（编译器通常能推断，也可以显式指定）
28
List<String> names = List.of("a", "b");
29
String first = Utils.first(names);              // 推断为 String
30
String first2 = Utils.<String>first(names);     // 显式
31

32
Utils.max(3, 5);                                // int
33
Utils.max("a", "b");                            // String

1
List<String> strings = new ArrayList<>();
2
List<Integer> ints = new ArrayList<>();
3

4
// 运行时它们是同一个类
5
System.out.println(strings.getClass() == ints.getClass());
6
// true，都是 java.util.ArrayList
7

8
// 擦除后 List<String> 变成 List，T 变成 Object（或边界类型）

1
// ❌ 不能用泛型类型做 instanceof
2
if (list instanceof List<String>) { ... }       // 编译报错
3
if (list instanceof List<?>) { ... }            // ✅
4

5
// ❌ 不能 new 泛型数组
6
List<String>[] arr = new List<String>[10];      // 编译报错
7
List<?>[] arr = new List<?>[10];                // ✅
8

9
// ❌ 不能 new 类型参数
10
public <T> T create() {
11
    return new T();                              // 编译报错
12
}
13
// 变通：传 Class<T>
14
public <T> T create(Class<T> clazz) throws Exception {
15
    return clazz.getDeclaredConstructor().newInstance();
16
}
17

18
// ❌ 静态字段/方法不能用类的类型参数
19
public class Box<T> {
20
    // static T item;              // 编译报错
21
    static <T> void method() {}    // ✅ 但方法可以有自己的类型参数
22
}
23

24
// ❌ 不能对基本类型使用泛型
25
List<int> nums;                    // 编译报错
26
List<Integer> nums;                // ✅ 用包装类

1
// ❌ List<Integer> 不是 List<Number> 的子类！
2
public void print(List<Number> list) { ... }
3
List<Integer> ints = List.of(1, 2, 3);
4
// print(ints);   // 编译报错
5

6
// ✅ 用通配符
7
public void print(List<?> list) {
8
    for (Object o : list) System.out.println(o);
9
}
10
print(ints);      // ✅
11
print(List.of("a", "b"));   // ✅

1
// T 必须是 Number 或其子类
2
public class NumberBox<T extends Number> {
3
    private T value;
4
    public double doubleValue() { return value.doubleValue(); }
5
}
6

7
NumberBox<Integer> intBox = new NumberBox<>();     // ✅
8
// NumberBox<String> strBox = new NumberBox<>();   // ❌ String 不是 Number
9

10
// 多边界：T 必须同时满足
11
public <T extends Comparable<T> & Serializable> void sort(T[] arr) { ... }

1
public Result<User> findUser(Long id) {
2
    if (id == null) {
3
        return Result.failure("INVALID_ID", "id 不能为 null");
4
    }
5
    User user = userDao.findById(id);
6
    if (user == null) {
7
        return Result.failure("NOT_FOUND", "用户不存在");
8
    }
9
    return Result.success(user);
10
}
11

12
// 链式转换
13
Result<String> nameResult = findUser(1L)
14
    .map(User::getName)
15
    .map(String::toUpperCase);
16

17
String name = nameResult.orElse("Anonymous");

1
// ===== 异常 =====
2
// 层次：Throwable → Error / Exception
3
// Exception → RuntimeException（非受检）+ 其他（受检）
4

5
// try/catch/finally
6
try { ... }
7
catch (IOException | SQLException e) { ... }   // 多异常合并（JDK 7+）
8
catch (Exception e) { ... }
9
finally { ... }
10

11
// try-with-resources（推荐）
12
try (BufferedReader br = new BufferedReader(new FileReader("a.txt"))) {
13
    return br.readLine();
14
}
15

16
// 抛异常
17
throw new IllegalArgumentException("参数错误");
18
public void m() throws IOException { ... }
19

20
// 自定义异常
21
public class BusinessException extends RuntimeException {
22
    public BusinessException(String msg, Throwable cause) { super(msg, cause); }
23
}
24

25
// ===== 泛型 =====
26
// 泛型类
27
public class Box<T> {
28
    private T content;
29
    public void put(T item) { content = item; }
30
    public T take() { return content; }
31
}
32

33
// 泛型方法
34
public static <T> T first(List<T> list) { return list.get(0); }
35
public static <T extends Comparable<T>> T max(T a, T b) { ... }
36

37
// 通配符（PECS）
38
List<? extends Number> producer;   // 只读
39
List<? super Integer> consumer;    // 只写
40
List<?> anything;                  // 只能读作 Object
41

42
// 类型擦除的限制
43
// ❌ new T()、T.class、new T[]、instanceof List<String>、静态字段用 T