Xử lý ngoại lệ

static void tang3() {
    System.out.println("  tầng 3: bắt đầu");
    throw new IllegalStateException("hỏng ở đáy");
    // mọi dòng sau đây KHÔNG chạy — trình biên dịch còn báo "unreachable statement"
}

static void tang2() {
    System.out.println(" tầng 2: gọi tầng 3");
    tang3();
    System.out.println(" tầng 2: dòng này bị bỏ qua");
}

static void tang1() {
    try {
        tang2();
    } catch (IllegalStateException e) {
        System.out.println("tầng 1: bắt được → " + e.getMessage());
    }
}

tang1();
//  tầng 2: gọi tầng 3
//    tầng 3: bắt đầu
// tầng 1: bắt được → hỏng ở đáy

try {
    int[] a = new int[3];
    a[5] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Chỉ số sai: " + e.getMessage());
} finally {
    System.out.println("Luôn chạy");
}

// --- Nhiều catch: CỤ THỂ TRƯỚC, TỔNG QUÁT SAU ---
try {
    xuLyTep(duongDan);
} catch (FileNotFoundException e) {      // con của IOException
    System.out.println("Không thấy tệp");
} catch (IOException e) {                 // cha — phải đứng SAU
    System.out.println("Lỗi I/O khác");
}
// Đảo ngược thứ tự → error: exception FileNotFoundException has already been caught

// --- MULTI-CATCH (Java 7+): gộp khi xử lý giống nhau ---
try {
    xuLy();
} catch (IOException | SQLException e) {   // biến e ngầm là final
    log.error("Thao tác thất bại", e);
    throw new DichVuException("Không xử lý được", e);
}
// ⚠️ Các kiểu trong multi-catch không được có quan hệ cha-con với nhau

// ❌ CÁCH CŨ — dài dòng và VẪN CÒN BUG
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("data.txt"));
    System.out.println(br.readLine());
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (br != null) {
        try {
            br.close();          // close() cũng ném IOException → phải try lồng!
        } catch (IOException e) {
            // nếu cả readLine() và close() cùng lỗi, lỗi nào bị mất?
        }
    }
}

// ✅ TRY-WITH-RESOURCES (Java 7+) — ngắn hơn và ĐÚNG hơn
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    System.out.println(br.readLine());
} catch (IOException e) {
    e.printStackTrace();
}
// close() tự động gọi — kể cả khi có ngoại lệ, kể cả khi return

// Nhiều tài nguyên — ĐÓNG THEO THỨ TỰ NGƯỢC (cái tạo sau đóng trước)
try (
    Connection conn = DriverManager.getConnection(url, user, pass);
    PreparedStatement ps = conn.prepareStatement(sql);
    ResultSet rs = ps.executeQuery()
) {
    while (rs.next()) { ... }
}   // đóng: rs → ps → conn

// Java 9+: dùng biến effectively final đã khai báo trước
BufferedReader reader = new BufferedReader(...);
try (reader) {
    ...
}

public class DongHo implements AutoCloseable {
    private final String ten;
    private final long batDau = System.nanoTime();

    public DongHo(String ten) { this.ten = ten; }

    @Override
    public void close() {          // AutoCloseable.close() ném Exception;
        long ms = (System.nanoTime() - batDau) / 1_000_000;
        System.out.printf("%s: %dms%n", ten, ms);
    }                             // thu hẹp còn không ném gì là hợp lệ (chương 5)
}

try (var d = new DongHo("Nạp dữ liệu")) {
    napDuLieu();
}   // tự in thời gian, kể cả khi napDuLieu() ném lỗi

// throws — khai báo: "phương thức này CÓ THỂ ném IOException"
static String docTep(String duongDan) throws IOException {
    if (duongDan == null)
        throw new IllegalArgumentException("Đường dẫn không được null");
        // ↑ unchecked → KHÔNG cần khai báo trong throws

    return Files.readString(Path.of(duongDan));  // ném IOException — checked
}

// Người gọi có HAI lựa chọn với checked exception:

// ① BẮT và xử lý
static void cach1() {
    try {
        String nd = docTep("a.txt");
    } catch (IOException e) {
        System.out.println("Dùng giá trị mặc định");
    }
}

// ② KHAI BÁO tiếp, đẩy trách nhiệm lên người gọi mình
static void cach2() throws IOException {
    String nd = docTep("a.txt");
}

// ❌ Không làm gì cả → lỗi biên dịch
// static void cach3() { docTep("a.txt"); }
//   error: unreported exception IOException; must be caught or declared to be thrown

// Đây gọi là quy tắc "CATCH OR SPECIFY" — đặc trưng riêng của Java

// ① Lớp gốc cho toàn module — cho phép bắt gộp mọi lỗi của bạn
public class ThanhToanException extends RuntimeException {
    public ThanhToanException(String msg)                  { super(msg); }
    public ThanhToanException(String msg, Throwable nguyenNhan) {
        super(msg, nguyenNhan);      // ⭐ constructor NÀY rất quan trọng
    }
}

// ② Lỗi cụ thể — MANG THEO DỮ LIỆU, không chỉ chuỗi
public class KhongDuSoDuException extends ThanhToanException {
    private final long can;
    private final long co;

    public KhongDuSoDuException(long can, long co) {
        super("Cần %,dđ nhưng chỉ có %,dđ (thiếu %,dđ)"
                .formatted(can, co, can - co));
        this.can = can;
        this.co = co;
    }

    public long getThieu() { return can - co; }
}

public class TheHetHanException extends ThanhToanException {
    private final LocalDate ngayHetHan;
    public TheHetHanException(LocalDate ngay) {
        super("Thẻ hết hạn ngày " + ngay);
        this.ngayHetHan = ngay;
    }
    public LocalDate getNgayHetHan() { return ngayHetHan; }
}

// ③ Người gọi bắt ở nhiều mức chi tiết khác nhau
try {
    thanhToan(don);
} catch (KhongDuSoDuException e) {
    hienNutNapTien(e.getThieu());          // hành động cụ thể nhờ có dữ liệu
} catch (ThanhToanException e) {
    hienThongBaoChung(e.getMessage());     // lưới an toàn cho cả module
}

// ❌ VẤN ĐỀ 1: "throws lây lan" khắp mọi tầng
void tangDuoi()  throws IOException { ... }
void tangGiua()  throws IOException { tangDuoi(); }
void tangTren()  throws IOException { tangGiua(); }
// Tầng giao diện đâu quan tâm tới IOException — nó chỉ cần biết "thất bại"

// ❌ VẤN ĐỀ 2: dẫn tới NUỐT LỖI vì lười
try {
    xuLy();
} catch (IOException e) {
    // TODO: xử lý sau
}   // 💥 lỗi biến mất — đây là hậu quả TỆ NHẤT của checked exception

// ❌ VẤN ĐỀ 3: không dùng được với lambda (chương 10)
List<String> duongDan = ...;
duongDan.forEach(p -> Files.readString(Path.of(p)));
// ❌ error: unhandled exception type IOException
//    Consumer.accept() không khai báo throws → lambda không ném checked được

// ✅ GIẢI PHÁP: bọc thành unchecked ở biên
static String docAnToan(String p) {
    try {
        return Files.readString(Path.of(p));
    } catch (IOException e) {
        throw new UncheckedIOException(e);   // JDK có sẵn class này!
    }
}
duongDan.forEach(p -> System.out.println(docAnToan(p)));   // ✅

// ❌ SAI — mất hoàn toàn nguyên nhân gốc
try {
    conn.executeQuery(sql);
} catch (SQLException e) {
    throw new DichVuException("Không lấy được dữ liệu");
    // stack trace chỉ trỏ vào dòng này — không biết SQL nào hỏng, vì sao
}

// ✅ ĐÚNG — truyền nguyên nhân vào constructor
try {
    conn.executeQuery(sql);
} catch (SQLException e) {
    throw new DichVuException("Không lấy được dữ liệu người dùng", e);
}

// Hoặc dùng initCause() nếu exception không có constructor nhận cause
MyException ex = new MyException("lỗi");
ex.initCause(e);
throw ex;

Exception in thread "main" com.vidu.DichVuException: Không lấy được dữ liệu người dùng
	at com.vidu.NguoiDungService.tim(NguoiDungService.java:42)     ← ② lớp bọc
	at com.vidu.Main.main(Main.java:15)
Caused by: java.sql.SQLException: Table 'app.nguoi_dung' doesn't exist
	at com.mysql.cj.jdbc.StatementImpl.executeQuery(StatementImpl.java:1200)
	at com.vidu.NguoiDungService.tim(NguoiDungService.java:38)     ← ① nguyên nhân THẬT
	... 1 more

// ❌ ① NUỐT NGOẠI LỆ — tội nặng nhất
try { xuLy(); } catch (Exception e) { }
// Lỗi biến mất hoàn toàn. Sau này ai đó sẽ mất cả ngày để tìm ra vì sao
// dữ liệu bị thiếu. Nếu THỰC SỰ muốn bỏ qua, hãy ghi rõ LÝ DO:
try {
    tam.delete();
} catch (IOException e) {
    log.debug("Không xoá được tệp tạm, hệ điều hành sẽ tự dọn", e);
}

// ❌ ② printStackTrace() trong code production
catch (Exception e) { e.printStackTrace(); }
// Ghi ra System.err, không vào hệ thống log, không có ngữ cảnh,
// không có thời gian, không lọc được theo mức độ.
catch (Exception e) { log.error("Xử lý đơn {} thất bại", donId, e); }   // ✅

// ❌ ③ BẮT QUÁ RỘNG
try { xuLy(); } catch (Exception e) { }
// Nuốt luôn cả NullPointerException — che giấu bug thật của bạn
catch (IOException | SQLException e) { }    // ✅ nêu rõ loại

// ❌ ④ DÙNG NGOẠI LỆ THAY ĐIỀU KIỆN
try {
    while (true) System.out.println(a[i++]);
} catch (ArrayIndexOutOfBoundsException e) { }   // dùng lỗi làm điều kiện dừng!
for (int x : a) System.out.println(x);              // ✅ rõ ràng và nhanh hơn nhiều

// ❌ ⑤ NÉM Exception TRẦN
public void luu() throws Exception { ... }
// Buộc người gọi bắt Exception — mất mọi thông tin về loại lỗi
public void luu() throws IOException, SQLException { ... }   // ✅

// ❌ ⑥ GHI LOG RỒI NÉM LẠI Ở MỌI TẦNG
catch (Exception e) {
    log.error("lỗi", e);
    throw e;          // tầng nào cũng log → cùng một lỗi in ra 5 lần
}
// ✅ Chỉ log ở BIÊN — nơi lỗi dừng lại (handler HTTP, main, vòng lặp worker).
//    Tầng giữa: hoặc để nó bay, hoặc bọc thêm ngữ cảnh bằng chaining.

// ✅ ① Kiểm tra tham số đầu vào ở ĐẦU phương thức (fail fast)
public void chuyenTien(TaiKhoan tu, TaiKhoan den, long soTien) {
    Objects.requireNonNull(tu,  "Tài khoản nguồn không được null");
    Objects.requireNonNull(den, "Tài khoản đích không được null");
    if (soTien <= 0)
        throw new IllegalArgumentException("Số tiền phải dương: " + soTien);
    if (tu.equals(den))
        throw new IllegalArgumentException("Không thể chuyển cho chính mình");
    ...
}

// ✅ ② Thông điệp lỗi có ĐỦ NGỮ CẢNH để hành động
throw new IllegalArgumentException("Sai");                       // ❌ vô dụng
throw new IllegalArgumentException(
    "Tuổi phải trong [0, 150], nhận %d cho người dùng %s"
        .formatted(tuoi, maNguoiDung));                             // ✅

// ✅ ③ Dùng Optional thay vì ném ngoại lệ cho "không tìm thấy"
public Optional<NguoiDung> tim(String id) { ... }   // "không có" là bình thường
public NguoiDung bacBuoc(String id) {                   // "phải có" — không có là lỗi
    return tim(id).orElseThrow(() ->
        new NguoiDungKhongTonTai(id));
}

// ✅ ④ Khôi phục cờ ngắt khi bắt InterruptedException (chương 12)
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();   // ⚠️ BẮT BUỘC — nếu không, tín hiệu dừng bị mất
    throw new RuntimeException("Bị ngắt khi đang chờ", e);
}

// ✅ ⑤ Ghi tài liệu bằng @throws trong Javadoc
/**
 * Rút tiền khỏi tài khoản.
 * @param soTien số tiền, phải dương
 * @throws IllegalArgumentException nếu soTien <= 0
 * @throws KhongDuSoDuException nếu số dư không đủ
 */
public void rut(long soTien) { ... }