Java cơ bản #7: kế thừa, đa hình, lớp trừu tượng, interface và sealed

class NhanVien {
    protected final String hoTen;        // protected: lớp con truy cập được
    protected final long luongCoBan;
 
    NhanVien(String hoTen, long luongCoBan) {
        this.hoTen = hoTen;
        this.luongCoBan = luongCoBan;
    }
 
    long tinhLuong() {
        return luongCoBan;
    }
 
    String moTa() {
        return hoTen + " — lương " + String.format("%,d", tinhLuong());
    }
}
 
class QuanLy extends NhanVien {
    private final long phuCap;
 
    QuanLy(String hoTen, long luongCoBan, long phuCap) {
        super(hoTen, luongCoBan);        // gọi constructor lớp cha — bắt buộc khi cha không có constructor rỗng
        this.phuCap = phuCap;
    }
 
    @Override
    long tinhLuong() {                   // ghi đè: thay hành vi của cha
        return super.tinhLuong() + phuCap;   // super.xxx(): gọi bản của lớp cha
    }
}
 
class NhanVienKinhDoanh extends NhanVien {
    private final long doanhSo;
 
    NhanVienKinhDoanh(String hoTen, long luongCoBan, long doanhSo) {
        super(hoTen, luongCoBan);
        this.doanhSo = doanhSo;
    }
 
    @Override
    long tinhLuong() {
        return luongCoBan + doanhSo * 5 / 100;   // hoa hồng 5%
    }
}
 
void main() {
    NhanVien[] ds = {
        new NhanVien("An", 12_000_000),
        new QuanLy("Bình", 20_000_000, 5_000_000),
        new NhanVienKinhDoanh("Chi", 10_000_000, 200_000_000),
    };
    long tongQuy = 0;
    for (NhanVien nv : ds) {
        IO.println(nv.moTa());           // mỗi đối tượng tự gọi đúng tinhLuong() của nó
        tongQuy += nv.tinhLuong();
    }
    IO.println("Tổng quỹ lương: " + String.format("%,d", tongQuy));
}

class DongVat {
    String keu() { return "..."; }
}
class Cho extends DongVat {
    @Override String keu() { return "Gâu gâu"; }
    void giuNha() { IO.println("Chó đang giữ nhà"); }
}
class Meo extends DongVat {
    @Override String keu() { return "Meo meo"; }
}
 
void main() {
    DongVat d = new Cho();       // biến kiểu cha, đối tượng kiểu con — hợp lệ (upcasting)
    IO.println(d.keu());         // Gâu gâu — theo đối tượng thật
    // d.giuNha();               → lỗi biên dịch: kiểu khai báo DongVat không có giuNha
 
    if (d instanceof Cho c) {    // kiểm tra kiểu + ép kiểu trong một bước (pattern matching, Java 16+)
        c.giuNha();
    }
}

abstract class Hinh {
    private final String ten;
    Hinh(String ten) { this.ten = ten; }
 
    abstract double dienTich();          // lớp con phải cài đặt
    abstract double chuVi();
 
    String moTa() {                      // phương thức thường dùng phương thức trừu tượng
        return "%s: diện tích %.2f, chu vi %.2f".formatted(ten, dienTich(), chuVi());
    }
}
 
class HinhTron extends Hinh {
    private final double r;
    HinhTron(double r) { super("Hình tròn"); this.r = r; }
    @Override double dienTich() { return Math.PI * r * r; }
    @Override double chuVi() { return 2 * Math.PI * r; }
}
 
class HinhChuNhat extends Hinh {
    private final double dai, rong;
    HinhChuNhat(double dai, double rong) { super("Hình chữ nhật"); this.dai = dai; this.rong = rong; }
    @Override double dienTich() { return dai * rong; }
    @Override double chuVi() { return 2 * (dai + rong); }
}
 
void main() {
    Hinh[] cacHinh = { new HinhTron(2), new HinhChuNhat(3, 4) };
    for (Hinh h : cacHinh) IO.println(h.moTa());
    // new Hinh("x") → lỗi biên dịch: Hinh is abstract; cannot be instantiated
}

interface ThanhToan {
    boolean thanhToan(long soTien);              // ngầm public abstract
 
    default String bienLai(long soTien) {         // default method: có sẵn thân, lớp cài đặt dùng luôn hoặc ghi đè
        return "Đã thanh toán " + String.format("%,d", soTien) + "đ qua " + ten();
    }
 
    String ten();
}
 
interface HoanTien {
    void hoanTien(long soTien);
}
 
class TheTinDung implements ThanhToan, HoanTien {
    private long hanMuc;
    TheTinDung(long hanMuc) { this.hanMuc = hanMuc; }
 
    @Override public boolean thanhToan(long soTien) {
        if (soTien > hanMuc) return false;
        hanMuc -= soTien;
        return true;
    }
    @Override public void hoanTien(long soTien) { hanMuc += soTien; }
    @Override public String ten() { return "thẻ tín dụng"; }
}
 
class ViDienTu implements ThanhToan {
    private long soDu;
    ViDienTu(long soDu) { this.soDu = soDu; }
 
    @Override public boolean thanhToan(long soTien) {
        if (soTien > soDu) return false;
        soDu -= soTien;
        return true;
    }
    @Override public String ten() { return "ví điện tử"; }
}
 
// Phương thức chỉ phụ thuộc vào interface, không biết cũng không cần biết lớp cụ thể
void datHang(ThanhToan pt, long tongTien) {
    IO.println(pt.thanhToan(tongTien) ? pt.bienLai(tongTien) : "Thanh toán thất bại bằng " + pt.ten());
}
 
void main() {
    datHang(new TheTinDung(5_000_000), 1_200_000);
    datHang(new ViDienTu(500_000), 1_200_000);
    datHang(new ViDienTu(2_000_000), 1_200_000);
}

interface PhepToan {
    int tinh(int a, int b);
}
 
void main() {
    PhepToan cong = (a, b) -> a + b;
    PhepToan luyThua = (a, b) -> (int) Math.pow(a, b);
    IO.println(cong.tinh(3, 4) + " " + luyThua.tinh(2, 10));
}

sealed interface HinhThuc permits The, Vi, TienMat {}
record The(String soThe, boolean quocTe) implements HinhThuc {}
record Vi(String nhaCungCap) implements HinhThuc {}
record TienMat() implements HinhThuc {}
 
long phi(HinhThuc ht, long soTien) {
    return switch (ht) {                                     // không cần default: trình biên dịch biết chỉ có 3 loại
        case The t when t.quocTe() -> soTien * 3 / 100;     // điều kiện phụ với when
        case The t -> soTien / 100;
        case Vi v -> v.nhaCungCap().equals("MoMo") ? 0 : 2_000;
        case TienMat tm -> 0;
    };
}
 
void main() {
    HinhThuc[] ds = { new The("4111", true), new The("9704", false), new Vi("MoMo"), new TienMat() };
    for (HinhThuc ht : ds) IO.println(ht + " → phí " + phi(ht, 1_000_000));
}

interface ThongBao {
    void gui(String noiDung);
}
class Email implements ThongBao {
    public void gui(String noiDung) { IO.println("[Email] " + noiDung); }
}
class Sms implements ThongBao {
    public void gui(String noiDung) { IO.println("[SMS] " + noiDung); }
}
 
// DonHangService CÓ MỘT ThongBao, thay vì KẾ THỪA từ EmailService
class DonHangService {
    private final ThongBao thongBao;
    DonHangService(ThongBao thongBao) { this.thongBao = thongBao; }   // "tiêm" phụ thuộc qua constructor
 
    void xacNhan(int maDon) {
        // ... lưu đơn hàng ...
        thongBao.gui("Đơn #" + maDon + " đã được xác nhận");
    }
}
 
void main() {
    new DonHangService(new Email()).xacNhan(101);
    new DonHangService(new Sms()).xacNhan(102);     // đổi cách gửi không cần sửa DonHangService
}