Biến, kiểu dữ liệu và toán tử

// Cú pháp: KIỂU tên = giá_trị;
int tuoi = 22;
String ten = "Việt Anh";
double diem = 8.75;
boolean dangHoc = true;

// Khai báo trước, gán sau
int soLuong;
soLuong = 10;

// Nhiều biến cùng kiểu trên một dòng — hợp lệ nhưng nên tránh
int a = 1, b = 2, c = 3;

// ❌ Không thể đổi kiểu — Java là ngôn ngữ định kiểu TĨNH và MẠNH
tuoi = "hai mươi hai";
// error: incompatible types: String cannot be converted to int

// ❌ Không thể dùng biến cục bộ chưa gán
int x;
System.out.println(x);
// error: variable x might not have been initialized

// Hậu tố BẮT BUỘC cho long và float
long danSo = 8_000_000_000L;   // L bắt buộc — vượt phạm vi int
float pi = 3.14f;               // f bắt buộc — mặc định số thực là double
double e = 2.718;              // d tuỳ chọn

// Dấu gạch dưới làm số dễ đọc (Java 7+) — trình biên dịch bỏ qua
int mot_trieu = 1_000_000;
long theTinDung = 1234_5678_9012_3456L;

// Các hệ cơ số
int thapPhan  = 255;
int nhiPhan   = 0b1111_1111;   // 255 (Java 7+)
int batPhan   = 0377;          // 255 — ⚠️ số 0 đứng đầu = hệ 8!
int thapLucPhan = 0xFF;        // 255

// Tra giới hạn — không cần học thuộc con số
System.out.println(Integer.MAX_VALUE);   // 2147483647
System.out.println(Integer.MIN_VALUE);   // -2147483648
System.out.println(Long.MAX_VALUE);      // 9223372036854775807
System.out.println(Double.MAX_VALUE);    // 1.7976931348623157E308

int max = Integer.MAX_VALUE;      // 2147483647
System.out.println(max + 1);        // -2147483648  ⚠️ quay vòng, KHÔNG báo lỗi

// Bug kinh điển: nhân hai int lớn rồi mới gán vào long
long mili = 1000 * 60 * 60 * 24 * 365;
System.out.println(mili);            // 1471228928  ❌ SAI!
// Phép nhân thực hiện ở kiểu int rồi TRÀN, sau đó mới ép sang long

// ✅ Sửa: ép một toán hạng sang long NGAY TỪ ĐẦU
long dung = 1000L * 60 * 60 * 24 * 365;
System.out.println(dung);            // 31536000000  ✅

// ✅ Muốn được BÁO LỖI khi tràn: dùng Math.*Exact (Java 8+)
try {
    int r = Math.addExact(max, 1);
} catch (ArithmeticException e) {
    System.out.println(e.getMessage());  // integer overflow
}
// Còn có: subtractExact, multiplyExact, negateExact, toIntExact

System.out.println(7 / 2);        // 3    ⚠️ không phải 3.5
System.out.println(7 % 2);        // 1
System.out.println(7.0 / 2);      // 3.5  — một toán hạng là double là đủ
System.out.println((double) 7 / 2); // 3.5  — ép kiểu trước khi chia
System.out.println((double) (7 / 2)); // 3.0  ❌ ép SAU khi đã cắt — quá muộn

// Chia số âm: CẮT VỀ 0, không phải làm tròn xuống
System.out.println(-7 / 2);       // -3   (Python cho -4!)
System.out.println(-7 % 2);       // -1   (Python cho 1!)

// Muốn hành vi làm tròn xuống như Python:
System.out.println(Math.floorDiv(-7, 2));  // -4
System.out.println(Math.floorMod(-7, 2));  //  1

// Chia cho 0: hai hành vi HOÀN TOÀN khác nhau
System.out.println(1 / 0);        // ArithmeticException: / by zero
System.out.println(1.0 / 0);      // Infinity  — không ném lỗi!
System.out.println(0.0 / 0);      // NaN

System.out.println(0.1 + 0.2);            // 0.30000000000000004
System.out.println(0.1 + 0.2 == 0.3);      // false  ⚠️
System.out.println(1.03 - 0.42);           // 0.6100000000000001

// Vì sao? 0.1 trong hệ nhị phân là số vô hạn tuần hoàn,
// giống như 1/3 = 0.333... trong hệ thập phân. 64 bit không đủ chứa.

// So sánh double đúng cách: dùng ngưỡng sai số
double a = 0.1 + 0.2, b = 0.3;
System.out.println(Math.abs(a - b) < 1e-9);  // true ✅

import java.math.BigDecimal;
import java.math.RoundingMode;

// ❌ TUYỆT ĐỐI KHÔNG dùng double cho tiền
double gia1 = 0.1, gia2 = 0.2;
System.out.println(gia1 + gia2);         // 0.30000000000000004 đ ???

// ✅ CÁCH 1: BigDecimal — chính xác tuyệt đối, dùng cho tài chính
BigDecimal x = new BigDecimal("0.1");   // ⚠️ PHẢI truyền String!
BigDecimal y = new BigDecimal("0.2");
System.out.println(x.add(y));            // 0.3  ✅ chính xác

// ⚠️ Truyền double vào constructor là sai — nó nhận cả sai số
System.out.println(new BigDecimal(0.1));
// 0.1000000000000000055511151231257827021181583404541015625

// BigDecimal dùng METHOD, không dùng toán tử
BigDecimal gia = new BigDecimal("1500000");
BigDecimal sl  = new BigDecimal("3");
BigDecimal vat = new BigDecimal("0.08");

BigDecimal tong = gia.multiply(sl);
BigDecimal thue = tong.multiply(vat).setScale(0, RoundingMode.HALF_UP);
System.out.println(tong.add(thue));    // 4860000

// ⚠️ So sánh BigDecimal: dùng compareTo, KHÔNG dùng equals
BigDecimal m = new BigDecimal("1.0");
BigDecimal n = new BigDecimal("1.00");
System.out.println(m.equals(n));         // false — khác số chữ số thập phân!
System.out.println(m.compareTo(n) == 0); // true  ✅

// ✅ CÁCH 2: long tính bằng đơn vị nhỏ nhất (đồng, xu)
long giaDong = 1_500_000L;      // nhanh hơn BigDecimal nhiều lần
long tongDong = giaDong * 3;      // hợp với VND vì không có đơn vị nhỏ hơn đồng

// --- Nguyên thủy: sao chép GIÁ TRỊ ---
int a = 10;
int b = a;      // b nhận bản sao của 10
b = 99;
System.out.println(a);   // 10  — a không đổi

// --- Tham chiếu: sao chép ĐỊA CHỈ ---
int[] x = {1, 2, 3};
int[] y = x;   // y trỏ vào CÙNG mảng, không tạo mảng mới
y[0] = 99;
System.out.println(x[0]);  // 99  ⚠️ x cũng thấy thay đổi!

// Muốn bản sao thật:
int[] z = x.clone();
z[0] = 1;
System.out.println(x[0]);  // 99 — x không bị ảnh hưởng ✅

import java.util.List;
import java.util.ArrayList;

// ❌ Không hợp lệ — generic chỉ nhận kiểu tham chiếu
// List<int> ds = new ArrayList<>();

// ✅ Dùng wrapper
List<Integer> ds = new ArrayList<>();

// AUTOBOXING — int tự chuyển thành Integer
ds.add(42);                 // thực chất: ds.add(Integer.valueOf(42))

// UNBOXING — Integer tự chuyển về int
int x = ds.get(0);          // thực chất: ds.get(0).intValue()

// Wrapper còn mang theo nhiều tiện ích tĩnh
System.out.println(Integer.parseInt("123"));      // 123 (int)
System.out.println(Integer.valueOf("123"));      // 123 (Integer)
System.out.println(Integer.toBinaryString(10));  // 1010
System.out.println(Integer.max(3, 7));         // 7
System.out.println(Double.parseDouble("3.14"));    // 3.14
System.out.println(Character.isDigit('7'));      // true
System.out.println(Boolean.parseBoolean("true"));  // true

String s = "Xin chào";
s.toUpperCase();                    // ⚠️ trả về chuỗi MỚI, s không đổi
System.out.println(s);              // "Xin chào"

s = s.toUpperCase();                // ✅ phải gán lại
System.out.println(s);              // "XIN CHÀO"

// Mọi method của String đều trả về chuỗi mới:
String t = "  Java  ";
System.out.println(t.trim());              // "Java"
System.out.println(t.strip());             // "Java" (Java 11+, hiểu Unicode)
System.out.println(t.replace("a", "@"));   // "  J@v@  "
System.out.println(t.isBlank());           // false (Java 11+)
System.out.println("ab".repeat(3));        // "ababab" (Java 11+)
System.out.println(String.join(", ", "a", "b", "c"));  // "a, b, c"
System.out.println("a,b,c".split(",").length);         // 3

String a = "Java";              // vào String pool
String b = "Java";              // tái dùng object trong pool
System.out.println(a == b);       // true   — cùng object

String c = new String("Java");  // ép tạo object MỚI ngoài pool
System.out.println(a == c);       // false  — khác object
System.out.println(a.equals(c));  // true   ✅ so nội dung

System.out.println(a == c.intern()); // true — intern() đưa vào/lấy từ pool

// Ghép hằng số: trình biên dịch tính sẵn → vào pool
String d = "Ja" + "va";
System.out.println(a == d);       // true — javac gộp thành "Java" lúc biên dịch

// Ghép với BIẾN: tính lúc chạy → object mới, không vào pool
String phan = "Ja";
String e = phan + "va";
System.out.println(a == e);       // false  ⚠️

// Trừ khi biến là final — lúc đó javac coi nó là hằng
final String phanF = "Ja";
String f = phanF + "va";
System.out.println(a == f);       // true

// ❌ CHẬM — mỗi vòng lặp tạo một String mới, copy toàn bộ nội dung cũ
String s = "";
for (int i = 0; i < 100_000; i++) {
    s += i;       // độ phức tạp O(n²) — với n=100k mất vài giây
}

// ✅ NHANH — một bộ đệm ký tự, chỉ nới rộng khi đầy
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100_000; i++) {
    sb.append(i);   // O(n) tổng cộng — mất vài mili giây
}
String ketQua = sb.toString();

// StringBuilder cho phép nối chuỗi phương thức
String bao = new StringBuilder()
        .append("Tên: ").append("An")
        .append(" | Tuổi: ").append(22)
        .reverse()                 // còn có insert, delete, replace, setCharAt
        .toString();

// ❌ Cách cũ — khó đọc, dễ sai
String jsonCu = "{\n" +
        "  \"ten\": \"Việt Anh\",\n" +
        "  \"tuoi\": 22\n" +
        "}";

// ✅ Text block — ba dấu nháy kép, Java 15+
String json = """
        {
          "ten": "Việt Anh",
          "tuoi": 22
        }""";

// Không cần escape dấu nháy kép. Thụt lề chung tự bị cắt bỏ:
// Java lấy dòng thụt ÍT NHẤT làm mốc và cắt phần thừa của mọi dòng.

String sql = """
        SELECT id, ho_ten, diem
        FROM   sinh_vien
        WHERE  lop = ? AND diem >= ?
        ORDER  BY diem DESC
        """;

// Dấu \ ở cuối dòng: nối dòng, không xuống dòng
String motDong = """
        Đây là một câu \
        rất dài viết trên nhiều dòng.""";
// → "Đây là một câu rất dài viết trên nhiều dòng."

// Kết hợp formatted() để chèn giá trị
String thu = """
        Kính gửi %s,
        Đơn hàng #%d của bạn đã được xác nhận.
        """.formatted("anh Việt", 1042);

// MỞ RỘNG (widening) — tự động, không mất dữ liệu
// byte → short → int → long → float → double
int i = 100;
long l = i;        // tự động
double d = l;      // tự động

// THU HẸP (narrowing) — PHẢI khai báo, CÓ THỂ mất dữ liệu
double pi = 3.99;
int nguyen = (int) pi;         // 3  — CẮT phần thập phân, không làm tròn
System.out.println(Math.round(pi)); // 4  — muốn làm tròn thì dùng Math.round

int lon = 300;
byte nho = (byte) lon;         // 44 ⚠️ mất dữ liệu âm thầm (300 % 256 = 44)

// ⚠️ Bẫy: mất chính xác khi long → float/double dù là "mở rộng"
long lonNhat = Long.MAX_VALUE;    // 9223372036854775807
float f = lonNhat;
System.out.println((long) f);      // 9223372036854775807 → nhưng float chỉ có 7 chữ số!

// Nâng kiểu tự động trong biểu thức
byte b1 = 10, b2 = 20;
// byte tong = b1 + b2;    // ❌ error: b1 + b2 cho ra int!
byte tong = (byte) (b1 + b2);   // ✅ phải ép lại
// Quy tắc: mọi phép toán số học nâng byte/short/char lên int trước khi tính

// char ↔ int
char ch = 'A';
int ma = ch;                      // 65
char ke = (char) (ch + 1);       // 'B'
System.out.println('A' + 1);        // 66  ⚠️ in ra SỐ, không phải 'B'
System.out.println("A" + 1);        // "A1" — String + số thì nối chuỗi

// Chuyển đổi qua String
String s = String.valueOf(42);      // "42" — an toàn cả với null
int n = Integer.parseInt("42");     // 42  — ném NumberFormatException nếu sai

// --- var (Java 10+): trình biên dịch tự suy ra kiểu ---
var ten = "Việt Anh";                 // String
var tuoi = 22;                          // int
var ds = new ArrayList<String>();      // ArrayList<String>
var map = new HashMap<String, List<Integer>>();  // ⭐ tiết kiệm thật sự

// ⚠️ var KHÔNG phải kiểu động — kiểu vẫn cố định lúc biên dịch
var x = 10;
// x = "chuỗi";   // ❌ error: incompatible types

// var KHÔNG dùng được ở:
// var a;                        ❌ không có giá trị khởi tạo → không suy ra được
// var b = null;                 ❌ null không có kiểu
// class C { var f = 1; }        ❌ chỉ dùng cho biến CỤC BỘ
// void m(var p) { }             ❌ không dùng cho tham số method

// --- final: gán đúng MỘT lần ---
final int MAX = 100;
// MAX = 200;   // ❌ error: cannot assign a value to final variable

// ⚠️ final chỉ khoá THAM CHIẾU, không khoá NỘI DUNG object
final List<String> danhSach = new ArrayList<>();
danhSach.add("a");           // ✅ được — sửa nội dung
// danhSach = new ArrayList<>();  // ❌ không được — gán tham chiếu khác

// Hằng số thật sự ở cấp class
public static final double THUE_SUAT = 0.08;
public static final List<String> MAU = List.of("đỏ", "xanh");
// List.of() tạo list BẤT BIẾN — add() sẽ ném UnsupportedOperationException

// Kết hợp: final var
final var ketQua = tinhToan();

int i = 5;
System.out.println(i++);   // 5  — in giá trị CŨ rồi mới tăng
System.out.println(i);     // 6

int j = 5;
System.out.println(++j);   // 6  — tăng TRƯỚC rồi in

// ⚠️ Bẫy: gán ghép tự ép kiểu ngầm — không báo lỗi mất dữ liệu
byte b = 10;
// b = b + 5;      // ❌ error: int không gán vào byte được
b += 5;             // ✅ chạy được — vì thực chất là b = (byte)(b + 5)

int n = 10;
n += 0.5;           // chạy được! thực chất n = (int)(n + 0.5) = 10
System.out.println(n);     // 10 — mất dữ liệu âm thầm ⚠️

// ⭐ Đoản mạch — kỹ thuật phòng NullPointerException quan trọng nhất
String s = null;
if (s != null && s.length() > 0) {   // ✅ an toàn: vế phải không chạy
    ...
}
if (s != null & s.length() > 0) {    // ❌ NullPointerException — & chạy cả hai vế
    ...
}

// ⚠️ Khác Python/JS: điều kiện PHẢI là boolean
int n = 0;
// if (n) { }        // ❌ error: int cannot be converted to boolean
if (n != 0) { }         // ✅ phải so sánh tường minh
// Java KHÔNG có khái niệm truthy/falsy — đây là điểm cộng về rõ ràng

// Toán tử ba ngôi
int tuoi = 20;
String loai = tuoi >= 18 ? "người lớn" : "trẻ em";

// Lồng nhau được nhưng khó đọc — cân nhắc switch (chương 3)
String xepLoai = diem >= 9 ? "Giỏi"
                 : diem >= 7 ? "Khá"
                 : diem >= 5 ? "Trung bình" : "Yếu";