Class, object và đóng gói

public class SinhVien {

    // --- TRƯỜNG (field) — dữ liệu của mỗi object ---
    private String maSo;
    private String hoTen;
    private double diem;

    // --- CONSTRUCTOR — chạy khi tạo object ---
    public SinhVien(String maSo, String hoTen, double diem) {
        this.maSo = maSo;
        this.hoTen = hoTen;
        this.diem = diem;
    }

    // --- PHƯƠNG THỨC — hành vi ---
    public String xepLoai() {
        return switch ((int) diem / 1) {
            case 10, 9 -> "Giỏi";
            case 8, 7 -> "Khá";
            case 6, 5 -> "Trung bình";
            default   -> "Yếu";
        };
    }

    // --- GETTER — cho phép đọc trường private ---
    public String getHoTen() { return hoTen; }
    public double getDiem()  { return diem; }
}

public class Main {
    public static void main(String[] args) {
        // new gọi constructor và cấp phát bộ nhớ trên heap
        SinhVien sv1 = new SinhVien("SV001", "Nguyễn Việt Anh", 8.5);
        SinhVien sv2 = new SinhVien("SV002", "Trần Bình", 9.2);

        // Hai object ĐỘC LẬP — mỗi cái có vùng nhớ riêng
        System.out.println(sv1.getHoTen() + ": " + sv1.xepLoai());
        System.out.println(sv2.getHoTen() + ": " + sv2.xepLoai());

        // Mảng object — mỗi phần tử là một tham chiếu
        SinhVien[] lop = new SinhVien[3];
        System.out.println(lop[0]);        // null — chưa tạo object nào!
        lop[0] = sv1;
        // lop[1].getHoTen();          // 💥 NullPointerException
    }
}

public class MacDinh {
    // TRƯỜNG — được JVM tự khởi tạo giá trị mặc định
    int      a;    // 0
    long     b;    // 0L
    double   c;    // 0.0
    boolean  d;    // false
    char     e;    // '' (ký tự rỗng)
    String   f;    // null   ⚠️
    int[]    g;    // null   ⚠️

    void thuNghiem() {
        int cucBo;
        // System.out.println(cucBo);
        //   ❌ error: variable cucBo might not have been initialized
    }
}

public class SanPham {
    private final String ma;
    private final String ten;
    private long gia;
    private int soLuong;

    // ① Constructor đầy đủ — nơi ĐẶT MỌI KIỂM TRA HỢP LỆ
    public SanPham(String ma, String ten, long gia, int soLuong) {
        if (ma == null || ma.isBlank())
            throw new IllegalArgumentException("Mã sản phẩm không được rỗng");
        if (gia < 0)
            throw new IllegalArgumentException("Giá không được âm: " + gia);

        this.ma = ma;
        this.ten = ten;
        this.gia = gia;
        this.soLuong = soLuong;
    }

    // ② Constructor rút gọn — GỌI LẠI constructor đầy đủ bằng this(...)
    public SanPham(String ma, String ten, long gia) {
        this(ma, ten, gia, 0);      // ⚠️ PHẢI là câu lệnh ĐẦU TIÊN
    }

    // ③ Constructor sao chép
    public SanPham(SanPham khac) {
        this(khac.ma, khac.ten, khac.gia, khac.soLuong);
    }
}

public class TaiKhoan {
    private String chuSoHuu;
    private long soDu;

    // ① Phân biệt trường và tham số cùng tên — công dụng phổ biến nhất
    public TaiKhoan(String chuSoHuu, long soDu) {
        this.chuSoHuu = chuSoHuu;   // this.x = TRƯỜNG, x = THAM SỐ
        this.soDu = soDu;
        // Nếu viết `chuSoHuu = chuSoHuu;` → gán tham số cho chính nó, trường vẫn null!
    }

    // ② Gọi constructor khác — phải là câu lệnh đầu tiên
    public TaiKhoan(String chuSoHuu) {
        this(chuSoHuu, 0);
    }

    // ③ Trả về chính object — cho phép nối chuỗi phương thức (fluent API)
    public TaiKhoan nap(long tien) {
        this.soDu += tien;
        return this;
    }
    public TaiKhoan rut(long tien) {
        if (tien > soDu) throw new IllegalStateException("Không đủ số dư");
        this.soDu -= tien;
        return this;
    }

    // ④ Truyền chính mình cho object khác
    public void dangKy(NganHang nh) {
        nh.them(this);
    }
}

// Nhờ ③ ta viết được:
new TaiKhoan("An").nap(1_000_000).rut(200_000).nap(50_000);

// Cấu trúc: [mức truy cập] [static] [final] KIỂU_TRẢ_VỀ tên(tham số) { }
public static int cong(int a, int b) {
    return a + b;
}

// --- NẠP CHỒNG (overload): cùng tên, KHÁC danh sách tham số ---
static int    cong(int a, int b)            { return a + b; }
static double cong(double a, double b)      { return a + b; }
static int    cong(int a, int b, int c)     { return a + b + c; }
static String cong(String a, String b)      { return a + b; }

// ❌ KHÔNG nạp chồng được nếu chỉ khác KIỂU TRẢ VỀ
// static double cong(int a, int b) { }
//   error: method cong(int,int) is already defined

// --- VARARGS: số lượng tham số tuỳ ý ---
static int tong(int... so) {       // so thực chất là int[]
    int t = 0;
    for (int x : so) t += x;
    return t;
}
tong();                // 0
tong(1, 2, 3);         // 6
tong(new int[]{1, 2});  // 3 — truyền thẳng mảng cũng được

// ⚠️ Quy tắc varargs: PHẢI là tham số CUỐI CÙNG, và chỉ có MỘT
static void ghiLog(String mucDo, String... thongDiep) { }   // ✅
// static void sai(String... a, int b) { }                    // ❌

public class TaiKhoan {
    private long soDu;              // chỉ class này
              int maNoiBo;           // cả package (mặc định)
    protected String loaiTaiKhoan;    // + class con ở package khác
    public String chuSoHuu;          // mọi nơi

    private void tinhLai() { }      // chi tiết cài đặt
    public long getSoDu() { return soDu; }   // API công khai
}

// Class cũng có mức truy cập (chỉ public hoặc package-private)
public class CongKhai { }     // dùng được từ package khác
class NoiBo { }              // chỉ trong package này

// ❌ CÁCH SAI 1: trường public — ai cũng phá được trạng thái
class TaiKhoanSai {
    public long soDu;
}
TaiKhoanSai tk = new TaiKhoanSai();
tk.soDu = -999_999;      // không ai ngăn được

// ❌ CÁCH SAI 2: private + getter/setter cho MỌI trường
//    → về bản chất vẫn là public, chỉ dài dòng hơn
class TaiKhoanVoNghia {
    private long soDu;
    public long getSoDu()            { return soDu; }
    public void setSoDu(long s)      { this.soDu = s; }   // vẫn đặt được -999999
}

// ✅ ĐÚNG: che trạng thái, mở HÀNH VI có ý nghĩa nghiệp vụ
public class TaiKhoan {
    private long soDu;
    private final List<String> lichSu = new ArrayList<>();

    public long getSoDu() { return soDu; }      // chỉ đọc, không có setter

    public void nap(long tien) {
        if (tien <= 0)
            throw new IllegalArgumentException("Số tiền nạp phải dương");
        soDu += tien;
        lichSu.add("Nạp " + tien);
    }

    public void rut(long tien) {
        if (tien <= 0)
            throw new IllegalArgumentException("Số tiền rút phải dương");
        if (tien > soDu)
            throw new IllegalStateException(
                "Không đủ số dư: cần %d, có %d".formatted(tien, soDu));
        soDu -= tien;
        lichSu.add("Rút " + tien);
    }
}

public class SinhVien {
    // TRƯỜNG TĨNH — chỉ có MỘT bản, chia sẻ cho mọi object
    private static int soLuongDaTao = 0;
    public static final String TRUONG = "Đại học ABC";   // hằng số

    // TRƯỜNG INSTANCE — mỗi object một bản riêng
    private final String maSo;

    public SinhVien(String maSo) {
        this.maSo = maSo;
        soLuongDaTao++;              // tăng biến đếm CHUNG
    }

    // PHƯƠNG THỨC TĨNH — gọi qua tên CLASS, không cần object
    public static int getSoLuongDaTao() {
        return soLuongDaTao;
        // return maSo;   // ❌ không truy cập được thành viên instance!
        // this.x         // ❌ không có `this` trong ngữ cảnh tĩnh
    }

    // PHƯƠNG THỨC INSTANCE — truy cập được CẢ HAI loại
    public String moTa() {
        return maSo + " @ " + TRUONG;   // ✅
    }
}

// Dùng:
new SinhVien("SV001");
new SinhVien("SV002");
System.out.println(SinhVien.getSoLuongDaTao());   // 2 — qua tên CLASS ✅
System.out.println(SinhVien.TRUONG);

public class ThuTu {
    static int a = in("1. trường tĩnh");

    static {                                    // KHỐI TĨNH
        in("2. khối tĩnh");
    }

    int b = in("3. trường instance");

    {                                            // KHỐI KHỞI TẠO INSTANCE
        in("4. khối instance");
    }

    public ThuTu() {
        in("5. constructor");
    }

    static int in(String s) { System.out.println(s); return 0; }

    public static void main(String[] args) {
        in("--- new lần 1 ---");
        new ThuTu();
        in("--- new lần 2 ---");
        new ThuTu();
    }
}

/* Kết quả:
1. trường tĩnh          ← chỉ MỘT LẦN, khi class được nạp
2. khối tĩnh            ← chỉ MỘT LẦN
--- new lần 1 ---
3. trường instance      ← mỗi lần new
4. khối instance        ← mỗi lần new
5. constructor          ← mỗi lần new
--- new lần 2 ---
3. trường instance
4. khối instance
5. constructor
*/

public class SanPham {
    private final String ma, ten;
    private final long gia;

    @Override
    public String toString() {
        return "SanPham{ma='%s', ten='%s', gia=%,d}".formatted(ma, ten, gia);
    }
}

SanPham sp = new SanPham("SP01", "Laptop", 25_000_000);
System.out.println(sp);          // println tự gọi toString()
System.out.println("Đã mua: " + sp);   // nối chuỗi cũng vậy

// Không override → dùng bản mặc định của Object, gần như vô dụng:
// com.vidu.SanPham@1b6d3586   (tên class @ mã băm dạng hex)

import java.util.Objects;

public class SanPham {
    private final String ma;
    private final String ten;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                  // tối ưu: cùng object
        if (!(o instanceof SanPham khac)) return false;  // Java 16+: gán luôn
        return Objects.equals(ma, khac.ma);           // so theo KHOÁ nghiệp vụ
    }

    @Override
    public int hashCode() {
        return Objects.hash(ma);      // PHẢI dùng đúng những trường như equals
    }
}

public void viDu() {
    SanPham a = new SanPham("SP01", "Laptop");   // object #1 trên heap
    SanPham b = new SanPham("SP02", "Chuột");    // object #2

    a = b;      // object #1 KHÔNG còn tham chiếu nào → thành "rác"
                // GC sẽ thu hồi vào lúc nào đó — bạn không kiểm soát khi nào

    b = null;   // object #2 vẫn sống vì `a` còn trỏ vào nó

}   // hết phương thức → `a` biến mất → object #2 cũng thành rác