Switch-Case Trong Java: Cách Viết Code Gọn Hơn Với yield

##1. Giới thiệu switch case trong java

Trong lập trình Java, khi cần thực hiện nhiều nhánh điều kiện dựa trên giá trị của một biến, chúng ta thường nghĩ đến `if-else`. Tuy nhiên, nếu có quá nhiều điều kiện, việc sử dụng `if-else` có thể khiến mã nguồn trở nên dài dòng và khó đọc. Đây là lúc `switch-case` phát huy tác dụng.

### 1.1. **Switch-case là gì?**

`switch-case` là một cấu trúc điều kiện trong Java giúp kiểm tra giá trị của một biến và thực hiện các đoạn mã khác nhau tùy theo từng trường hợp (`case`).

Ví dụ, nếu bạn cần kiểm tra giá trị của một biến `day` để xác định hôm nay là thứ mấy, thay vì sử dụng nhiều câu lệnh `if-else`, bạn có thể sử dụng `switch-case` để viết mã ngắn gọn và dễ hiểu hơn.

###1.2. **Khi nào nên dùng switch-case?**

Bạn nên sử dụng `switch-case` thay vì `if-else` trong các trường hợp sau:

✔ Khi có nhiều điều kiện cần kiểm tra trên cùng một biến.

✔ Khi giá trị so sánh là các số nguyên (`int`), ký tự (`char`), chuỗi (`String` từ Java 7) hoặc `enum`.

✔ Khi cần mã nguồn ngắn gọn, dễ đọc và có thể mở rộng dễ dàng.
Ví dụ đơn giản:
```java
int day = 3;
switch (day) {
    case 1:
        System.out.println("Chủ nhật");
        break;
    case 2:
        System.out.println("Thứ hai");
        break;
    case 3:
        System.out.println("Thứ ba");
        break;
    default:
        System.out.println("Ngày không hợp lệ");
}

```

## **2. Cú pháp của switch-case trong Java**

`switch-case` là một cấu trúc điều kiện trong Java giúp kiểm tra giá trị của một biến và thực thi các khối lệnh tương ứng với từng trường hợp (`case`). Bắt đầu từ **Java 12**, `switch` đã được cải tiến thành **Switch Expression**, giúp viết mã gọn hơn và cho phép trả về giá trị với `yield`.

### 2.1. Cú pháp cơ bản của switch-case (Java < 12)

Trong Java trước phiên bản 12, `switch` chỉ được sử dụng như một **câu lệnh (statement)**, không thể trả về giá trị.

### **Cú pháp truyền thống:**

```java
switch (biểu_thức) {
    case giá_trị_1:
        // Khối lệnh thực thi nếu biểu_thức == giá_trị_1
        break;
    case giá_trị_2:
        // Khối lệnh thực thi nếu biểu_thức == giá_trị_2
        break;
    ...
    default:
        // Khối lệnh mặc định nếu không có case nào khớp
}

```

✅ **Lưu ý:**

- **`break`** giúp thoát khỏi `switch`, nếu không có `break`, chương trình sẽ tiếp tục chạy các `case` tiếp theo (fall-through).
- **`default`** là tùy chọn nhưng nên có để xử lý trường hợp không khớp với bất kỳ `case` nào.

### **2.2. Switch Expression với `yield` (Java 12+)**

Bắt đầu từ Java 12, `switch` có thể hoạt động như một **biểu thức (expression)** và trả về giá trị bằng từ khóa `yield`.

####**Cú pháp mới với `yield`:**

```java
java
CopyEdit
String kết_quả = switch (biểu_thức) {
    case giá_trị_1 -> "Giá trị 1";
    case giá_trị_2 -> "Giá trị 2";
    default -> {
        // Khối lệnh logic trước khi trả về giá trị
        yield "Giá trị mặc định";
    }
};

```
#### **Ví dụ 1: Switch truyền thống với `break` (Java < 12)**

```java
int day = 3;
String dayType;

switch (day) {
    case 1:
    case 7:
        dayType = "Cuối tuần";
        break;
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
        dayType = "Ngày trong tuần";
        break;
    default:
        dayType = "Không hợp lệ";
}

System.out.println(dayType);

```

📌 **Nhược điểm:** Cần khai báo biến `dayType` bên ngoài và sử dụng nhiều `break`.

---

#### **Ví dụ 2: Switch Expression với `yield` (Java 12+)**

```java
int day = 3;
String dayType = switch (day) {
    case 1, 7 -> "Cuối tuần";
    case 2, 3, 4, 5, 6 -> "Ngày trong tuần";
    default -> "Không hợp lệ";
};

System.out.println(dayType);

```

📌 **Ưu điểm:**

✔ Không cần `break`.

✔ Ngắn gọn và dễ đọc hơn.

---

#### **Ví dụ 3: Sử dụng `yield` trong Switch Expression**

Khi `case` cần thực hiện nhiều lệnh, ta dùng `{}` và `yield`.

```java
int score = 85;

String grade = switch (score / 10) {
    case 10, 9 -> "A";
    case 8 -> "B";
    case 7 -> "C";
    case 6 -> "D";
    default -> {
        String message = "Không đạt, điểm: " + score;
        yield message; // Trả về giá trị từ khối lệnh
    }
};

System.out.println(grade);

```

📌 **Tại sao cần `yield`?**

- Khi `case` có nhiều câu lệnh, ta cần `{}` để bao bọc.
- `yield` giúp trả về giá trị sau khi thực hiện logic xử lý.

✅ **Ưu điểm của Switch Expression với `yield`**:

- **Không cần `break`**, tránh lỗi fall-through.
- **Trả về giá trị trực tiếp** từ `switch`.
- **Hỗ trợ nhiều câu lệnh trong `case`** bằng `{}` và `yield`.

## **3. So sánh `switch` truyền thống và `switch` với `yield`**

| Đặc điểm | `switch` truyền thống (Java < 12) | Switch Expression với `yield` (Java 12+) |
| --- | --- | --- |
| Kiểu switch | Statement (Câu lệnh) | Expression (Biểu thức) |
| Cần `break` không? | ✅ Có | ❌ Không cần |
| Trả về giá trị? | ❌ Không | ✅ Có |
| Viết nhiều dòng trong `case` | Dùng `{}` nhưng không thể trả về giá trị | Dùng `{}` với `yield` để trả về giá trị |

## **4. Kết luận**

✅ **Dùng `switch-case` truyền thống nếu bạn đang sử dụng Java cũ (< 12).**

✅ **Dùng Switch Expression với `yield` nếu bạn đang dùng Java 12+ để viết code gọn hơn, dễ đọc hơn.**

✅ **Nếu `case` cần thực hiện nhiều lệnh, hãy dùng `{}` và `yield` để đảm bảo `switch` trả về giá trị đúng cách.**

---

🔹 **Bạn đang sử dụng phiên bản Java nào?** Nếu chưa dùng Java 12+, bạn có thể nâng cấp để tận dụng `yield` trong `switch-case`. 🚀

Hẹn gặp lại, pái pai🚀🚀🚀

Switch-Case Trong Java: Cách Viết Code Gọn Hơn Với yield

Trung Phan

Latest Posts

Upcasting và Downcasting: Hướng dẫn từ A đến Z cho lập trình viên Java

GitHub Copilot là gì? Khám phá các tính năng nổi bật của GitHub Copilot trong lập trình

Switch-Case Trong Java: Cách Viết Code Gọn Hơn Với yield