🥤 Nguyên Liệu Cơ Bản - Primitive Types

Chào mừng đến với bài học về Primitive Types - các nguyên liệu cơ bản trong Café Âu!

🎯 Món Ăn Hôm Nay

Tưởng tượng bạn làm barista trong quán café:

• Cà phê = 250ml (số nguyên)
• Sữa = 100.5ml (số thập phân)
• Loại đồ uống = 'L' (ký tự: Latte)
• Còn hàng = true/false (đúng/sai)

Đó chính là Primitive Types - nguyên liệu cơ bản để pha chế!

☕ Primitive Types Là Gì?

Primitive Types = Các loại nguyên liệu cơ bản (8 loại trong Java)

Java có 8 loại nguyên liệu:

Loại	Ẩn Dụ Café	Kích Thước	Ví Dụ
byte	Muỗng đường (nhỏ)	8-bit	-128 → 127
short	Cốc shot (nhỏ)	16-bit	-32,768 → 32,767
int	Cốc trung (vừa)	32-bit	-2 tỷ → 2 tỷ
long	Bình lớn (to)	64-bit	-9 triệu tỷ → 9 triệu tỷ
float	Đo lường đơn (6-7 số)	32-bit	3.14f
double	Đo lường kép (15 số)	64-bit	3.14159265
char	Mã đồ uống (1 ký tự)	16-bit	'L', 'C', 'E'
boolean	Còn hàng? (true/false)	1-bit	true, false

☕ Ẩn Dụ Café:

• byte/short/int/long = Các cốc khác kích thước
• float/double = Đo lường chính xác ml
• char = Mã đơn giản (L=Latte, C=Cappuccino)
• boolean = Trạng thái có/không

👨‍🍳 Câu Chuyện Trong Quán

Sáng nay, quán café cần chuẩn bị nguyên liệu:

Tình huống 1: Khai báo nguyên liệu cơ bản

// Số lượng nguyên (int)
int soLyLatte = 50;
int soLyEspresso = 30;

// Dung tích chính xác (double)
double dungTichCaPhe = 250.5;  // ml
double dungTichSua = 100.75;   // ml

// Loại đồ uống (char)
char maMon = 'L';  // L = Latte

// Còn hàng? (boolean)
boolean conCaPhe = true;
boolean conSua = false;

System.out.println("☕ Số ly Latte: " + soLyLatte);
System.out.println("🥛 Dung tích sữa: " + dungTichSua + "ml");
System.out.println("📝 Mã món: " + maMon);
System.out.println("✅ Còn cà phê: " + conCaPhe);

Tình huống 2: Tính toán công thức

int lyCanPha = 10;
double caPheMotLy = 18.5;  // gram
double suaMotLy = 100.0;   // ml

double tongCaPhe = lyCanPha * caPheMotLy;
double tongSua = lyCanPha * suaMotLy;

System.out.printf("Cần %.1fg cà phê và %.0fml sữa\n", tongCaPhe, tongSua);

🎉 Kết quả: Java giúp quản lý nguyên liệu chính xác!

📝 Công Thức Nấu (Code Examples)

Ví Dụ 1: Số Nguyên - int, long

public class QuanCafe {
    public static void main(String[] args) {
        // int: Số lượng đồ uống (đủ dùng)
        int soLyHomNay = 150;
        int giaMotLy = 50000;  // VND

        int doanhThu = soLyHomNay * giaMotLy;
        System.out.println("💰 Doanh thu: " + doanhThu + " VND");

        // long: Số lớn (doanh thu cả năm)
        long soLyCaNam = 50000L;
        long doanhThuNam = soLyCaNam * giaMotLy;

        System.out.println("📊 Doanh thu năm: " + doanhThuNam + " VND");
    }
}

Output:

💰 Doanh thu: 7500000 VND
📊 Doanh thu năm: 2500000000 VND

Ví Dụ 2: Số Thập Phân - double, float

public class CongThucCafe {
    public static void main(String[] args) {
        // double: Đo lường chính xác
        double dungTichCoc = 250.0;      // ml
        double tyLeCaPhe = 0.074;        // 7.4% (18.5g/250ml)
        double tyLeSua = 0.4;            // 40% (100ml/250ml)

        double luongCaPhe = dungTichCoc * tyLeCaPhe;
        double luongSua = dungTichCoc * tyLeSua;

        System.out.printf("☕ Công thức 1 ly Latte (%.0fml):\n", dungTichCoc);
        System.out.printf("   - Cà phê: %.1fg\n", luongCaPhe);
        System.out.printf("   - Sữa: %.0fml\n", luongSua);

        // float: Ít chính xác hơn (thêm 'f')
        float nhietDo = 85.5f;  // độ C
        System.out.printf("🌡️  Nhiệt độ nước: %.1f°C\n", nhietDo);
    }
}

Output:

☕ Công thức 1 ly Latte (250ml):
   - Cà phê: 18.5g
   - Sữa: 100ml
🌡️  Nhiệt độ nước: 85.5°C

Ví Dụ 3: Ký Tự - char

public class MaDoUong {
    public static void main(String[] args) {
        // Mã đồ uống
        char latte = 'L';
        char cappuccino = 'C';
        char espresso = 'E';

        System.out.println("📋 MÃ ĐỒ UỐNG:");
        System.out.println("☕ Latte: " + latte);
        System.out.println("☕ Cappuccino: " + cappuccino);
        System.out.println("☕ Espresso: " + espresso);

        // Chuyển đổi char → int (mã Unicode)
        int maASCII = latte;
        System.out.println("\n🔢 Mã Unicode của 'L': " + maASCII);
    }
}

Output:

📋 MÃ ĐỒ UỐNG:
☕ Latte: L
☕ Cappuccino: C
☕ Espresso: E

🔢 Mã Unicode của 'L': 76

Ví Dụ 4: Boolean - true/false

public class KiemTraKho {
    public static void main(String[] args) {
        int tonKhoCaPhe = 500;   // gram
        int tonKhoSua = 0;       // ml

        // Kiểm tra còn hàng
        boolean conCaPhe = tonKhoCaPhe > 100;
        boolean conSua = tonKhoSua > 100;
        boolean coPhaLatte = conCaPhe && conSua;

        System.out.println("📦 KIỂM TRA KHO:");
        System.out.println("☕ Còn cà phê: " + conCaPhe);
        System.out.println("🥛 Còn sữa: " + conSua);
        System.out.println("✅ Có thể pha Latte: " + coPhaLatte);

        if (coPhaLatte) {
            System.out.println("→ Sẵn sàng phục vụ!");
        } else {
            System.out.println("→ Cần bổ sung nguyên liệu!");
        }
    }
}

Output:

📦 KIỂM TRA KHO:
☕ Còn cà phê: true
🥛 Còn sữa: false
✅ Có thể pha Latte: false
→ Cần bổ sung nguyên liệu!

Ví Dụ 5: Chuyển Đổi Kiểu - Type Casting

public class ChuyenDoiKieu {
    public static void main(String[] args) {
        // Tự động (Widening): Cốc nhỏ → Cốc lớn
        int soLy = 50;
        long soLyDai = soLy;  // int → long (tự động)

        double gia = 45000;
        System.out.println("💰 Giá: " + gia);

        // Ép kiểu (Narrowing): Cốc lớn → Cốc nhỏ
        double tongTien = 152750.99;
        int tienLamTron = (int) tongTien;  // Mất phần thập phân!

        System.out.println("🧾 Tổng tiền chính xác: " + tongTien + " VND");
        System.out.println("🧾 Làm tròn: " + tienLamTron + " VND");

        // Chia số nguyên → thập phân
        int a = 5;
        int b = 2;

        double ketQua1 = a / b;           // 2.0 (chia int)
        double ketQua2 = (double) a / b;  // 2.5 (chia double)

        System.out.println("\n🔢 5 / 2 (int): " + ketQua1);
        System.out.println("🔢 5 / 2 (double): " + ketQua2);
    }
}

Output:

💰 Giá: 45000.0
🧾 Tổng tiền chính xác: 152750.99 VND
🧾 Làm tròn: 152750 VND

🔢 5 / 2 (int): 2.0
🔢 5 / 2 (double): 2.5

🔥 Thực Hành Trong Quán

Bài Tập 1: Tính Toán Nguyên Liệu

public class TinhNguyenLieu {
    public static void main(String[] args) {
        int soKhach = 25;

        // Nguyên liệu cho 1 ly
        double caPheMotLy = 18.5;     // gram
        double suaMotLy = 100.0;      // ml
        double duongMotLy = 2.0;      // muỗng

        // Tính tổng
        double tongCaPhe = soKhach * caPheMotLy;
        double tongSua = soKhach * suaMotLy;
        double tongDuong = soKhach * duongMotLy;

        System.out.println("📋 NGUYÊN LIỆU CHO " + soKhach + " LY LATTE:\n");
        System.out.printf("☕ Cà phê: %.1fg\n", tongCaPhe);
        System.out.printf("🥛 Sữa: %.0fml\n", tongSua);
        System.out.printf("🍬 Đường: %.0f muỗng\n", tongDuong);
    }
}

Bài Tập 2: Kiểm Tra Tồn Kho

public class KiemTraTonKho {
    public static void main(String[] args) {
        // Tồn kho hiện tại
        int caPhe = 1500;    // gram
        int sua = 3000;      // ml
        int duong = 50;      // muỗng

        // Nhu cầu cho 30 ly
        int soLy = 30;
        int canCaPhe = (int)(soLy * 18.5);
        int canSua = (int)(soLy * 100.0);
        int canDuong = soLy * 2;

        // Kiểm tra
        boolean duCaPhe = caPhe >= canCaPhe;
        boolean duSua = sua >= canSua;
        boolean duDuong = duong >= canDuong;
        boolean coPhaLatte = duCaPhe && duSua && duDuong;

        System.out.println("🛒 CẦN CHO " + soLy + " LY:");
        System.out.printf("☕ Cà phê: %dg (còn %dg) %s\n",
            canCaPhe, caPhe, duCaPhe ? "✅" : "❌");
        System.out.printf("🥛 Sữa: %dml (còn %dml) %s\n",
            canSua, sua, duSua ? "✅" : "❌");
        System.out.printf("🍬 Đường: %d muỗng (còn %d) %s\n",
            canDuong, duong, duDuong ? "✅" : "❌");

        System.out.println("\n" + (coPhaLatte ?
            "✅ Đủ nguyên liệu!" : "❌ Thiếu nguyên liệu!"));
    }
}

Bài Tập 3: Tính Hóa Đơn

public class TinhHoaDon {
    public static void main(String[] args) {
        // Giá đồ uống
        int giaLatte = 50000;
        int giaCappuccino = 45000;
        int giaEspresso = 40000;

        // Đơn hàng
        int soLyLatte = 2;
        int soLyCappuccino = 1;
        int soLyEspresso = 3;

        // Tính tiền
        int tienLatte = giaLatte * soLyLatte;
        int tienCappuccino = giaCappuccino * soLyCappuccino;
        int tienEspresso = giaEspresso * soLyEspresso;
        int tongTien = tienLatte + tienCappuccino + tienEspresso;

        // Giảm giá 10%
        double phanTramGiam = 0.1;
        double soTienGiam = tongTien * phanTramGiam;
        double thanhToan = tongTien - soTienGiam;

        System.out.println("🧾 HÓA ĐƠN:\n");
        System.out.printf("Latte x%d: %,d VND\n", soLyLatte, tienLatte);
        System.out.printf("Cappuccino x%d: %,d VND\n", soLyCappuccino, tienCappuccino);
        System.out.printf("Espresso x%d: %,d VND\n", soLyEspresso, tienEspresso);
        System.out.println("━━━━━━━━━━━━━━━━━━━━");
        System.out.printf("Tổng: %,d VND\n", tongTien);
        System.out.printf("Giảm 10%%: -%.0f VND\n", soTienGiam);
        System.out.println("━━━━━━━━━━━━━━━━━━━━");
        System.out.printf("THANH TOÁN: %,.0f VND\n", thanhToan);
    }
}

⚠️ Những Lỗi Barista Thường Gặp

Lỗi 1: Quên Hậu Tố Cho long và float

// ❌ SAI: Thiếu 'L' cho long
long soLon = 9000000000;  // Lỗi! Vượt int

// ✅ ĐÚNG: Thêm 'L'
long soLon = 9000000000L;

// ❌ SAI: Thiếu 'f' cho float
float gia = 45.5;  // Lỗi! Mặc định là double

// ✅ ĐÚNG: Thêm 'f'
float gia = 45.5f;

Lỗi 2: Chia Số Nguyên

// ❌ SAI: Chia int/int = int (mất phần thập phân)
int a = 5;
int b = 2;
double ketQua = a / b;  // 2.0, không phải 2.5!

// ✅ ĐÚNG: Ép kiểu trước khi chia
double ketQua = (double) a / b;  // 2.5

Lỗi 3: Overflow - Tràn Số

// ❌ SAI: Vượt giới hạn byte (-128 → 127)
byte soNho = 200;  // Lỗi biên dịch!

// ✅ ĐÚNG: Dùng int
int so = 200;

// Overflow khi tính toán
byte a = 100;
byte b = 50;
byte tong = (byte)(a + b);  // 150 OK, nhưng cẩn thận!

Lỗi 4: So Sánh double

// ❌ SAI: So sánh trực tiếp
double a = 0.1 + 0.2;
double b = 0.3;
if (a == b) {  // false! (0.30000000000000004 ≠ 0.3)
    System.out.println("Bằng nhau");
}

// ✅ ĐÚNG: So sánh với epsilon
double epsilon = 0.0001;
if (Math.abs(a - b) < epsilon) {
    System.out.println("Xấp xỉ bằng nhau");
}

💡 Bí Quyết Của Barista

1. int là mặc định cho số nguyên: Dùng cho hầu hết trường hợp
2. double là mặc định cho số thực: Chính xác hơn float
3. Thêm L/f khi cần: 123L (long), 3.14f (float)
4. Ép kiểu khi chia: (double) a / b để giữ phần thập phân
5. Không dùng == cho double: Dùng Math.abs(a - b) < epsilon

🎓 Bạn Đã Học Được

• ✅ 8 primitive types = 8 loại nguyên liệu cơ bản
• ✅ int/long = Số nguyên (cốc nhỏ/lớn)
• ✅ double/float = Số thập phân (đo lường chính xác)
• ✅ char = Ký tự đơn ('L', 'C')
• ✅ boolean = true/false (có/không)
• ✅ Type casting = Chuyển đổi kiểu dữ liệu

☕ Món Tiếp Theo

Đã biết nguyên liệu cơ bản! Giờ học cách tính toán công thức:

👉 Tính Toán Công Thức - Operators

---

💡 Lời Khuyên Cuối: Primitive types giống nguyên liệu café - hiểu rõ từng loại thì pha chế mới chuẩn! Thực hành nhiều để trở thành barista chuyên nghiệp!