Kế thừa, đa hình và interface

// LỚP CHA (superclass / base class)
public class NhanVien {
    protected final String hoTen;    // protected → class con dùng được
    protected long luongCoBan;

    public NhanVien(String hoTen, long luongCoBan) {
        this.hoTen = hoTen;
        this.luongCoBan = luongCoBan;
    }

    public long tinhLuong() {
        return luongCoBan;
    }

    @Override
    public String toString() {
        return "%s — %,dđ".formatted(hoTen, tinhLuong());
    }
}

// LỚP CON (subclass) — kế thừa MỌI thành viên không private
public class QuanLy extends NhanVien {
    private final int soNhanVienQuanLy;

    public QuanLy(String hoTen, long luongCoBan, int soNhanVien) {
        super(hoTen, luongCoBan);       // ⚠️ PHẢI là câu lệnh đầu tiên
        this.soNhanVienQuanLy = soNhanVien;
    }

    @Override
    public long tinhLuong() {
        return super.tinhLuong() + soNhanVienQuanLy * 500_000L;
        //     ↑ gọi bản của lớp cha rồi cộng thêm
    }
}

public class LapTrinhVien extends NhanVien {
    private final String ngonNgu;

    public LapTrinhVien(String hoTen, long luong, String ngonNgu) {
        super(hoTen, luong);
        this.ngonNgu = ngonNgu;
    }

    @Override
    public long tinhLuong() {
        return super.tinhLuong() + (ngonNgu.equals("Java") ? 3_000_000L : 0);
    }
}

class A {
    A() { System.out.println("A()"); }
}
class B extends A {
    B() {
        // super();   ← javac TỰ THÊM nếu bạn không viết
        System.out.println("B()");
    }
}
class C extends B {
    C() { System.out.println("C()"); }
}

new C();
// A()      ← lớp cha chạy TRƯỚC, luôn luôn
// B()
// C()

class Cha {
    void chao()           { System.out.println("Cha.chao()"); }
    void chao(String t)  { System.out.println("Cha.chao(String) — OVERLOAD"); }
}

class Con extends Cha {
    @Override
    void chao()           { System.out.println("Con.chao() — OVERRIDE"); }
}

Cha obj = new Con();     // kiểu KHAI BÁO = Cha, kiểu THỰC TẾ = Con
obj.chao();               // "Con.chao()"  ← OVERRIDE: theo kiểu THỰC TẾ
obj.chao("xin chào");    // "Cha.chao(String)" ← OVERLOAD: theo kiểu KHAI BÁO

List<NhanVien> congTy = List.of(
    new NhanVien("An", 10_000_000),
    new QuanLy("Bình", 20_000_000, 5),
    new LapTrinhVien("Chi", 15_000_000, "Java")
);

long tong = 0;
for (NhanVien nv : congTy) {
    System.out.println(nv);        // gọi toString() ĐÚNG của từng loại
    tong += nv.tinhLuong();       // gọi tinhLuong() ĐÚNG của từng loại
}
System.out.printf("Tổng quỹ lương: %,dđ%n", tong);

// An — 10,000,000đ
// Bình — 22,500,000đ      ← QuanLy.tinhLuong()
// Chi — 18,000,000đ       ← LapTrinhVien.tinhLuong()
// Tổng quỹ lương: 50,500,000đ

// UPCASTING — lên lớp cha: TỰ ĐỘNG, luôn an toàn
NhanVien nv = new QuanLy("Bình", 20_000_000, 5);

// DOWNCASTING — xuống lớp con: PHẢI khai báo, có thể thất bại
QuanLy ql = (QuanLy) nv;              // ✅ vì thực tế nó LÀ QuanLy

NhanVien nv2 = new LapTrinhVien("Chi", 15_000_000, "Java");
// QuanLy ql2 = (QuanLy) nv2;
//   💥 ClassCastException: LapTrinhVien cannot be cast to QuanLy

// ✅ Kiểm tra trước khi ép — cách cũ
if (nv2 instanceof QuanLy) {
    QuanLy q = (QuanLy) nv2;
    ...
}

// ✅ Java 16+: pattern matching — gộp kiểm tra và ép kiểu
if (nv2 instanceof QuanLy q) {
    System.out.println(q.getSoNhanVienQuanLy());   // q đã sẵn kiểu QuanLy
}

// Kết hợp điều kiện — q dùng được ngay trong cùng biểu thức
if (nv2 instanceof QuanLy q && q.getSoNhanVienQuanLy() > 3) { ... }

// Java 21: pattern matching trong switch
String loai = switch (nv2) {
    case QuanLy q       -> "Quản lý " + q.getSoNhanVienQuanLy() + " người";
    case LapTrinhVien l -> "Lập trình " + l.getNgonNgu();
    default             -> "Nhân viên thường";
};

public abstract class HinhHoc {
    private final String ten;        // abstract class CÓ trạng thái

    protected HinhHoc(String ten) {   // CÓ constructor (cho lớp con gọi)
        this.ten = ten;
    }

    // PHƯƠNG THỨC TRỪU TƯỢNG — không có thân, lớp con BẮT BUỘC cài đặt
    public abstract double dienTich();
    public abstract double chuVi();

    // PHƯƠNG THỨC THƯỜNG — dùng chung, lớp con kế thừa nguyên vẹn
    public String moTa() {
        return "%s: diện tích %.2f, chu vi %.2f"
                .formatted(ten, dienTich(), chuVi());
        //                   ↑ gọi method trừu tượng — đa hình hoạt động
    }

    public String getTen() { return ten; }
}

public class HinhTron extends HinhHoc {
    private final double banKinh;

    public HinhTron(double banKinh) {
        super("Hình tròn");
        if (banKinh <= 0)
            throw new IllegalArgumentException("Bán kính phải dương");
        this.banKinh = banKinh;
    }

    @Override public double dienTich() { return Math.PI * banKinh * banKinh; }
    @Override public double chuVi()    { return 2 * Math.PI * banKinh; }
}

// ❌ Không tạo instance của abstract class được
// HinhHoc h = new HinhHoc("X");
//   error: HinhHoc is abstract; cannot be instantiated

// ✅ Nhưng DÙNG được làm kiểu — đó chính là mục đích
List<HinhHoc> ds = List.of(new HinhTron(3), new HinhChuNhat(2, 4));
ds.forEach(h -> System.out.println(h.moTa()));

public interface CoTheBay {

    // ① HẰNG SỐ — ngầm định public static final
    int DO_CAO_TOI_DA = 10_000;

    // ② PHƯƠNG THỨC TRỪU TƯỢNG — ngầm định public abstract
    void bay();
    int doCaoToiDa();

    // ③ DEFAULT METHOD (Java 8+) — có thân, lớp cài đặt kế thừa được
    default String moTaBay() {
        return "Bay ở độ cao tối đa " + doCaoToiDa() + "m";
    }

    // ④ STATIC METHOD (Java 8+) — tiện ích, gọi qua tên interface
    static boolean hopLe(int doCao) {
        return doCao > 0 && doCao <= DO_CAO_TOI_DA;
    }

    // ⑤ PRIVATE METHOD (Java 9+) — dùng chung cho các default method
    private String dinhDang(int d) {
        return "%,dm".formatted(d);
    }
}

// Một class cài đặt NHIỀU interface
public class Chim implements CoTheBay, CoTheHot {
    @Override public void bay()        { System.out.println("Vỗ cánh"); }
    @Override public int doCaoToiDa()  { return 3000; }
    @Override public void hot()        { System.out.println("Chích chích"); }
}

// Vừa extends vừa implements — extends đứng trước
public class MayBay extends PhuongTien implements CoTheBay { ... }

// ❌ CÁCH CŨ — 50+ dòng cho một lớp chỉ chứa 3 giá trị
public final class DiemCu {
    private final int x, y;
    public DiemCu(int x, int y) { this.x = x; this.y = y; }
    public int getX() { return x; }
    public int getY() { return y; }
    @Override public boolean equals(Object o) { /* 8 dòng */ }
    @Override public int hashCode()          { return Objects.hash(x, y); }
    @Override public String toString()      { /* 3 dòng */ }
}

// ✅ RECORD — MỘT dòng, tương đương hoàn toàn
public record Diem(int x, int y) { }

// Java tự sinh:
//   - trường private final x, y
//   - constructor Diem(int x, int y)
//   - accessor x() và y()   ⚠️ KHÔNG phải getX()/getY()
//   - equals(), hashCode() dựa trên MỌI thành phần
//   - toString(): "Diem[x=1, y=2]"

Diem d = new Diem(1, 2);
System.out.println(d.x());                   // 1
System.out.println(d);                       // Diem[x=1, y=2]
System.out.println(d.equals(new Diem(1, 2)));  // true ✅

public record SanPham(String ma, String ten, long gia) {

    // ① COMPACT CONSTRUCTOR — kiểm tra hợp lệ, không cần viết lại gán
    public SanPham {
        Objects.requireNonNull(ma, "Mã không được null");
        if (gia < 0)
            throw new IllegalArgumentException("Giá không được âm: " + gia);
        ten = ten.trim();       // chuẩn hoá được — gán tự động xảy ra SAU khối này
    }

    // ② Constructor phụ
    public SanPham(String ma, String ten) {
        this(ma, ten, 0);
    }

    // ③ Phương thức bổ sung
    public long giaSauThue() { return Math.round(gia * 1.08); }

    // ④ Override accessor nếu cần (hiếm)
    @Override
    public String ten() { return ten.toUpperCase(); }

    // ⑤ Thành viên static — được phép
    public static SanPham mienPhi(String ma, String ten) {
        return new SanPham(ma, ten, 0);
    }
}

// Record cài đặt được interface
public record Tien(long soTien) implements Comparable<Tien> {
    @Override
    public int compareTo(Tien khac) { return Long.compare(soTien, khac.soTien); }
}

// Chỉ ba class này được phép kế thừa HinhHoc
public sealed interface HinhHoc
        permits HinhTron, HinhChuNhat, TamGiac { }

public record HinhTron(double banKinh)          implements HinhHoc { }
public record HinhChuNhat(double dai, double rong) implements HinhHoc { }
public record TamGiac(double a, double b, double c) implements HinhHoc { }

// ⭐ switch KHÔNG cần default — trình biên dịch biết đủ mọi trường hợp
static double dienTich(HinhHoc h) {
    return switch (h) {
        case HinhTron t     -> Math.PI * t.banKinh() * t.banKinh();
        case HinhChuNhat cn -> cn.dai() * cn.rong();
        case TamGiac tg     -> {
            double p = (tg.a() + tg.b() + tg.c()) / 2;
            yield Math.sqrt(p * (p-tg.a()) * (p-tg.b()) * (p-tg.c()));
        }
    };
}
// Thêm record HinhVuong implements HinhHoc → switch trên BÁO LỖI BIÊN DỊCH ✅

// RECORD PATTERN (Java 21) — bung thành phần ngay trong case
static double dienTichGon(HinhHoc h) {
    return switch (h) {
        case HinhTron(double r)             -> Math.PI * r * r;
        case HinhChuNhat(double d, double r) -> d * r;
        case TamGiac(double a, double b, double c) -> {
            double p = (a + b + c) / 2;
            yield Math.sqrt(p * (p-a) * (p-b) * (p-c));
        }
    };
}

// ① Dạng đơn giản nhất
public enum TrangThai { MOI, DANG_XU_LY, HOAN_THANH, HUY }

// ② Enum CÓ TRƯỜNG, CONSTRUCTOR, PHƯƠNG THỨC — đây mới là sức mạnh thật
public enum HanhTinh {
    THUY_TINH(3.303e+23, 2.4397e6),
    TRAI_DAT (5.976e+24, 6.37814e6),
    SAO_HOA  (6.421e+23, 3.3972e6);      // ⚠️ dấu chấm phẩy khi có thêm thành viên

    private final double khoiLuong;      // kg
    private final double banKinh;        // m

    HanhTinh(double khoiLuong, double banKinh) {   // constructor ngầm private
        this.khoiLuong = khoiLuong;
        this.banKinh = banKinh;
    }

    public double trongLucBeMat() {
        return 6.67300E-11 * khoiLuong / (banKinh * banKinh);
    }
}

System.out.printf("%.2f m/s²%n", HanhTinh.TRAI_DAT.trongLucBeMat());  // 9.80

// ③ Mỗi hằng số OVERRIDE riêng — "constant-specific body"
public enum PhepToan {
    CONG("+") { public double tinh(double a, double b) { return a + b; } },
    TRU ("-") { public double tinh(double a, double b) { return a - b; } },
    NHAN("×") { public double tinh(double a, double b) { return a * b; } },
    CHIA("÷") {
        public double tinh(double a, double b) {
            if (b == 0) throw new ArithmeticException("Chia cho 0");
            return a / b;
        }
    };

    private final String kyHieu;
    PhepToan(String kyHieu) { this.kyHieu = kyHieu; }

    public abstract double tinh(double a, double b);
    @Override public String toString() { return kyHieu; }
}

for (PhepToan p : PhepToan.values()) {
    System.out.printf("6 %s 2 = %.1f%n", p, p.tinh(6, 2));
}

TrangThai t = TrangThai.DANG_XU_LY;

t.name();                        // "DANG_XU_LY" — tên hằng số
t.ordinal();                     // 1 — vị trí (⚠️ đừng lưu vào database!)
TrangThai.values();             // mảng mọi hằng số
TrangThai.valueOf("HUY");       // tra từ chuỗi (ném IllegalArgumentException nếu sai)
t.compareTo(TrangThai.HUY);     // so theo ordinal

// ✅ enum so sánh bằng == được (khác mọi object khác!)
if (t == TrangThai.DANG_XU_LY) { ... }   // an toàn: mỗi hằng số là singleton
// equals() cũng đúng, nhưng == ngắn hơn và an toàn với null

// Collection chuyên dụng cho enum — nhanh hơn HashMap/HashSet nhiều
EnumMap<TrangThai, Integer> dem = new EnumMap<>(TrangThai.class);
EnumSet<TrangThai> dangHoatDong =
    EnumSet.of(TrangThai.MOI, TrangThai.DANG_XU_LY);

public class DanhSachLienKet<T> {
    private Node<T> dau;
    private int kichThuoc;

    // ① STATIC NESTED — không cần tham chiếu tới DanhSachLienKet
    private static class Node<T> {
        T giaTri;
        Node<T> ke;
        Node(T giaTri) { this.giaTri = giaTri; }
    }

    // ② INNER — cần đọc `dau` và `kichThuoc` của instance ngoài
    public class MyIterator implements Iterator<T> {
        private Node<T> hienTai = dau;      // truy cập trực tiếp trường ngoài
        @Override public boolean hasNext() { return hienTai != null; }
        @Override public T next() {
            T v = hienTai.giaTri; hienTai = hienTai.ke; return v;
        }
    }

    // ③ ANONYMOUS — cài đặt tại chỗ, dùng một lần
    public Comparator<T> soSanhNguoc(Comparator<T> goc) {
        return new Comparator<T>() {
            @Override
            public int compare(T a, T b) { return goc.compare(b, a); }
        };
        // ✅ Java 8+: lambda gọn hơn hẳn
        // return (a, b) -> goc.compare(b, a);
    }
}

// Tạo instance:
DanhSachLienKet<String> ds = new DanhSachLienKet<>();
DanhSachLienKet<String>.MyIterator it = ds.new MyIterator();  // cú pháp lạ của inner class

// final class — không ai kế thừa được
public final class Tien { ... }
// String, Integer, LocalDate đều là final — vì tính bất biến của chúng
// sẽ bị phá nếu ai đó kế thừa và override method

// final method — lớp con không override được
public class DichVu {
    public final void chay() {      // khung xử lý cố định (template method)
        chuanBi();
        xuLy();                      // ← chỉ bước này cho lớp con tuỳ biến
        donDep();
    }
    protected abstract void xuLy();
    private void chuanBi() { }
    private void donDep()  { }
}

// ❌ Ví dụ kinh điển từ sách "Effective Java"
public class DemPhanTu<E> extends ArrayList<E> {
    private int soLanThem = 0;

    @Override
    public boolean add(E e) {
        soLanThem++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        soLanThem += c.size();
        return super.addAll(c);
    }
}

DemPhanTu<String> d = new DemPhanTu<>();
d.addAll(List.of("a", "b", "c"));
System.out.println(d.soLanThem);    // 6 ⚠️ đáng lẽ là 3!

// Nguyên nhân: ArrayList.addAll() bên trong GỌI add() cho từng phần tử.
// Mà add() đã bị override → đếm hai lần.
// Bạn không thể biết điều này nếu không đọc mã nguồn của ArrayList —
// và nó có thể thay đổi ở phiên bản Java sau!


// ✅ COMPOSITION — bọc thay vì kế thừa
public class DemPhanTu<E> {
    private final List<E> benTrong = new ArrayList<>();
    private int soLanThem = 0;

    public boolean them(E e) {
        soLanThem++;
        return benTrong.add(e);
    }
    public boolean themTatCa(Collection<? extends E> c) {
        soLanThem += c.size();
        return benTrong.addAll(c);
    }
    public int getSoLanThem() { return soLanThem; }
}
// Chỉ mở ra API bạn kiểm soát; không phụ thuộc chi tiết cài đặt của ArrayList