Method trong Java: if, vòng lặp và tính giảm giá đơn hàng

Method trong Java là gì và dùng thế nào? Học if/else, for, while, switch và cách tách method qua bài toán tính tổng đơn và giảm giá 10% của quán cà phê.

Method trong Java là một đoạn code có tên, nhận đầu vào (gọi là tham số) và trả về một kết quả, để bạn gọi lại nhiều lần thay vì chép code. Cùng với if để rẽ nhánh và for, while để lặp, ba thứ này đủ để tính tổng tiền một đơn hàng và áp dụng giảm giá.

Ở bài trước, bạn đã biết lưu một đơn của quán Mộc (quán cà phê tình huống minh họa mà mình dùng xuyên suốt loạt bài) vào các biến, và biết vì sao tiền đồng nên dùng long. Nhưng chương trình vẫn chạy một mạch từ trên xuống dưới. Quán có quy tắc "đơn từ 100.000 đồng trở lên được giảm 10%", mà một chương trình chỉ biết làm theo thứ tự thì chưa tự quyết định được. Bài này mình dạy chương trình ra quyết định, lặp lại việc, và gom việc thành các method.

Làm sao để chương trình quyết định có giảm giá hay không?

Bằng câu lệnh if. Bạn đặt một điều kiện đúng/sai trong ngoặc, và đoạn code trong cặp ngoặc nhọn chỉ chạy khi điều kiện đúng.

Mình thử viết cách đơn giản nhất cho ba đơn. Đơn của Lan là 2 cà phê sữa và 1 bánh mì que. Đơn của Mai là 3 trà đào và 1 cà phê sữa. Đơn của Bảo là 2 cà phê sữa và 2 bánh mì que. Mình viết hết trong main, đơn nào cũng làm đúng ba việc: tính tổng, xét giảm giá, in kết quả.

TinhDonThuCong.java
public class TinhDonThuCong {
    public static void main(String[] args) {
        // Đơn của Lan: 2 cà phê sữa (35000) + 1 bánh mì que (15000)
        long tong1 = 2 * 35000 + 1 * 15000;
        long giam1 = 0;
        if (tong1 > 100000) {
            giam1 = tong1 / 10;
        }
        System.out.println("Lan : tổng " + tong1 + ", giảm " + giam1 + ", trả " + (tong1 - giam1));

        // Đơn của Mai: 3 trà đào (45000) + 1 cà phê sữa (35000)
        long tong2 = 3 * 45000 + 1 * 35000;
        long giam2 = 0;
        if (tong2 > 100000) {
            giam2 = tong2 / 10;
        }
        System.out.println("Mai : tổng " + tong2 + ", giảm " + giam2 + ", trả " + (tong2 - giam2));

        // Đơn của Bảo: 2 cà phê sữa (35000) + 2 bánh mì que (15000)
        long tong3 = 2 * 35000 + 2 * 15000;
        long giam3 = 0;
        if (tong3 > 100000) {
            giam3 = tong3 / 10;
        }
        System.out.println("Bảo : tổng " + tong3 + ", giảm " + giam3 + ", trả " + (tong3 - giam3));
    }
}
Chạy
java -Dstdout.encoding=UTF-8 TinhDonThuCong.java
Kết quả
Lan : tổng 85000, giảm 0, trả 85000
Mai : tổng 170000, giảm 17000, trả 153000
Bảo : tổng 100000, giảm 0, trả 100000

Đơn của Lan 85.000 đồng nên chưa được giảm, đúng. Đơn của Mai 170.000 đồng được giảm 17.000, cũng đúng. Còn Bảo thì sai: đơn của Bảo đúng 100.000 đồng, mà quy tắc là "từ 100.000 trở lên", nghĩa là phải được giảm 10.000. Chương trình không giảm gì cho anh ấy.

Lỗi nằm ở dấu > trong if (tong3 > 100000). Dấu > nghĩa là "lớn hơn", loại đúng con số 100.000 ra ngoài. Câu trong yêu cầu "từ ... trở lên" phải dịch thành >=. Đây là loại lỗi ranh giới mà ai cũng mắc vài lần, và test thông thường rất dễ bỏ sót vì bạn thường thử số 50.000 hay 200.000 chứ ít khi thử đúng 100.000.

Có một chuyện nữa mà bạn để ý: đoạn long giam = 0; if (...) {...}; println(...) bị chép ba lần, chỉ đổi số hiệu 1, 2, 3. Mình sửa > thành >= thì phải sửa ở ba chỗ. Quên một chỗ là có hai đơn bị tính theo hai luật khác nhau. Quán thêm đơn thứ tư thì chép lần thứ tư, nên mình cần một cách khác. Nhưng trước đó, còn chuyện đơn có nhiều dòng món cần xử lý đã.

Vòng lặp giúp tính tổng nhiều dòng món thế nào?

Một đơn thật có thể có hai, năm, hay mười dòng món. Dòng 2 * 35000 + 1 * 15000 ở trên viết cứng số dòng, nên nó không dùng được cho đơn khác. Cách chung hơn là lưu số lượng và đơn giá của từng dòng vào hai mảng, rồi dùng vòng lặp for đi qua từng dòng để cộng lại. Mảng là một dãy nhiều giá trị cùng kiểu, đánh số từ 0.

Hai mảng chạy song song (phần tử thứ i của mảng này khớp với phần tử thứ i của mảng kia) là cách làm tạm. Khi học class ở bài sau, mình sẽ thay chúng bằng một đối tượng đơn hàng đàng hoàng.

Đoạn cộng tiền bằng for
int[] soLuong = {2, 1};
long[] donGia = {35000, 15000};

long tong = 0;
for (int i = 0; i < soLuong.length; i++) {
    tong += soLuong[i] * donGia[i];
}

Dòng for có ba phần ngăn bằng dấu chấm phẩy. int i = 0 chạy một lần ở đầu để đặt bộ đếm. i < soLuong.length được kiểm tra trước mỗi vòng, đúng thì chạy tiếp. i++ chạy sau mỗi vòng để tăng bộ đếm. Trong ví dụ này soLuong.length là 2, nên i lần lượt là 0 và 1, và tong ra 85.000.

Điều bạn dễ vấp ở đây là điều kiện dừng. Mình cố tình viết <= thay cho < để xem chuyện gì xảy ra:

LoiVongLap.java
public class LoiVongLap {
    public static void main(String[] args) {
        int[] soLuong = {2, 1};
        long[] gia = {35000, 15000};

        long tong = 0;
        for (int i = 0; i <= soLuong.length; i++) {
            tong += soLuong[i] * gia[i];
        }
        System.out.println("Tổng: " + tong);
    }
}
Kết quả của java -Dstdout.encoding=UTF-8 LoiVongLap.java
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2
	at LoiVongLap.main(LoiVongLap.java:8)

Mảng có hai phần tử nên chỉ có chỉ số 0 và 1. Với <=, vòng thứ ba có i = 2, và Java dừng chương trình ngay với ArrayIndexOutOfBoundsException. Thông báo nói khá đủ: "Index 2 out of bounds for length 2" nghĩa là bạn đòi phần tử số 2 trong một mảng dài 2, còn dòng at LoiVongLap.main(LoiVongLap.java:8) chỉ đúng dòng số 8 trong file. Đây cũng là lần đầu bạn gặp một stack trace, tức dấu vết cho biết lỗi xảy ra ở đâu; bài về debug sẽ dạy cách đọc kỹ hơn.

Mình thấy cách Java xử lý khá dễ chịu so với vài ngôn ngữ khác: nó dừng và nói thẳng vị trí, chứ không âm thầm đọc ra một giá trị rác. Nhưng thế cũng đồng nghĩa là lỗi <= này sẽ làm sập chương trình khi chạy thật nếu bạn không thử đủ trường hợp.

Java còn hai kiểu lặp nữa mà bạn sẽ gặp thường xuyên. Kiểu thứ nhất là for mở rộng (for-each), dùng khi bạn chỉ cần đi qua từng phần tử mà không quan tâm chỉ số: for (long tong : danhSachTong) đọc là "với mỗi tong trong danh sách". Nó tránh hẳn lỗi <= ở trên vì bạn không tự quản lý bộ đếm. Kiểu thứ hai là while, dùng khi bạn không biết trước sẽ lặp bao nhiêu lần. Mình dùng nó ở phần sau để trả lời câu hỏi "khách thiếu mấy món nữa thì được giảm giá".

Method là gì, và vì sao nên tách code ra method?

Bây giờ quay lại chuyện chép code ba lần. Method (phương thức, hay còn gọi là hàm) giải quyết đúng việc này: bạn đặt tên cho một đoạn code, khai báo nó nhận gì và trả gì, rồi gọi bằng tên ở bất cứ đâu. Mỗi method nên làm đúng một việc. Với quán Mộc, mình cần hai việc: cộng tiền các dòng món, và tính số tiền được giảm.

Mình xem nhanh cách Java chạy một lệnh gọi method, vì hiểu cái này giúp bạn bớt rối ở phần sau. Mỗi lần gọi, Java tạo một vùng nhớ riêng chứa các tham số và biến của lần gọi đó. Gọi xong thì vùng nhớ ấy bị bỏ đi. Các vùng nhớ xếp chồng lên nhau, cái gọi sau nằm trên cùng:

Các vùng nhớ khi chạy main gọi tinhGiamGia(170000)
  Trên cùng   tinhGiamGia   tongTien = 170000        <- đang chạy, trả về 17000 rồi biến mất
              main          tong = 170000, giam = ?  <- chờ kết quả
  Dưới cùng   (khởi động chương trình)

Khi tinhGiamGia trả kết quả, vùng nhớ của nó biến mất và main nhận được 17000. tongTien trong method và tong trong main là hai biến khác nhau, chỉ tình cờ giữ cùng giá trị.

Đây là bản viết lại, với đầy đủ file TinhDon.java. Mình để quy tắc giảm giá thành hai hằng số ở đầu file (static final nghĩa là giá trị không đổi được; viết hoa là quy ước), để khi quán đổi luật thì chỉ sửa một chỗ.

TinhDon.java
public class TinhDon {
    // Quy tắc của quán: đơn từ 100.000 đồng trở lên được giảm 10%.
    static final long NGUONG_GIAM_GIA = 100_000;
    static final int PHAN_TRAM_GIAM = 10;

    // Cộng tiền của từng dòng món: số lượng nhân đơn giá.
    static long tinhTongTien(int[] soLuong, long[] donGia) {
        long tong = 0;
        for (int i = 0; i < soLuong.length; i++) {
            tong += soLuong[i] * donGia[i];
        }
        return tong;
    }

    // Số tiền được giảm. Phần lẻ dưới 1 đồng bị bỏ (cắt xuống), nghĩa là khách được giảm ít hơn một chút.
    static long tinhGiamGia(long tongTien) {
        if (tongTien >= NGUONG_GIAM_GIA) {
            return tongTien * PHAN_TRAM_GIAM / 100;
        }
        return 0;
    }

    // Hai method cùng tên, khác tham số (overload): phần trăm giảm do người gọi chọn.
    static long tinhGiamGia(long tongTien, int phanTram) {
        if (tongTien >= NGUONG_GIAM_GIA) {
            return tongTien * phanTram / 100;
        }
        return 0;
    }

    // Khách còn thiếu mấy món rẻ (giá giaMon) nữa thì được giảm giá?
    static int soMonConThieu(long tongTien, long giaMon) {
        int dem = 0;
        while (tongTien < NGUONG_GIAM_GIA) {
            tongTien += giaMon;
            dem++;
        }
        return dem;
    }

    // Đơn đã DONE hoặc CANCELLED thì không đổi trạng thái nữa.
    static boolean choPhepDoiTrangThai(String trangThaiHienTai) {
        return switch (trangThaiHienTai) {
            case "DONE", "CANCELLED" -> false;
            case "NEW", "PAID" -> true;
            default -> throw new IllegalArgumentException("Trạng thái lạ: " + trangThaiHienTai);
        };
    }

    public static void main(String[] args) {
        String[] khach = {"Lan", "Mai", "Bảo"};
        // Mỗi phần tử của soLuong và donGia là một dòng món; ba đơn dùng ba cặp mảng.
        int[][] soLuongCacDon = {{2, 1}, {3, 1}, {2, 2}};
        long[][] donGiaCacDon = {{35000, 15000}, {45000, 35000}, {35000, 15000}};

        for (int i = 0; i < khach.length; i++) {
            long tong = tinhTongTien(soLuongCacDon[i], donGiaCacDon[i]);
            long giam = tinhGiamGia(tong);
            System.out.println(khach[i] + ": tổng " + tong + ", giảm " + giam + ", trả " + (tong - giam));
        }

        System.out.println();
        System.out.println("Ranh giới của quy tắc giảm giá:");
        long[] thu = {99_999, 100_000, 100_001};
        for (long tong : thu) {
            System.out.println("  " + tong + " -> giảm " + tinhGiamGia(tong));
        }
        System.out.println("  Giảm 15% cho 200000 -> " + tinhGiamGia(200_000, 15));

        System.out.println();
        long tongCuaLan = tinhTongTien(soLuongCacDon[0], donGiaCacDon[0]);
        System.out.println("Lan đang có " + tongCuaLan + ", cần thêm " + soMonConThieu(tongCuaLan, 15_000)
                + " bánh mì que nữa để được giảm");

        System.out.println();
        for (String tt : new String[]{"NEW", "PAID", "DONE", "CANCELLED"}) {
            System.out.println("Đơn đang " + tt + " -> đổi được? " + choPhepDoiTrangThai(tt));
        }
    }
}
Kết quả của java -Dstdout.encoding=UTF-8 TinhDon.java
Lan: tổng 85000, giảm 0, trả 85000
Mai: tổng 170000, giảm 17000, trả 153000
Bảo: tổng 100000, giảm 10000, trả 90000

Ranh giới của quy tắc giảm giá:
  99999 -> giảm 0
  100000 -> giảm 10000
  100001 -> giảm 10000
  Giảm 15% cho 200000 -> 30000

Lan đang có 85000, cần thêm 1 bánh mì que nữa để được giảm

Đơn đang NEW -> đổi được? true
Đơn đang PAID -> đổi được? true
Đơn đang DONE -> đổi được? false
Đơn đang CANCELLED -> đổi được? false

Dòng ba của kết quả cho thấy Bảo giờ được giảm 10.000 và trả 90.000, vì tinhGiamGia dùng >=. Quy tắc nằm đúng một chỗ, nên sửa lỗi ranh giới chỉ cần sửa một lần, và ba đơn tự đúng theo. Phần "Ranh giới" in ba con số quanh mốc 100.000: 99.999 không được giảm, 100.000 và 100.001 đều được. Mình chọn đúng ba số này vì lỗi > ở trên chỉ lộ ra ở con số đứng sát mốc, nên nó là chỗ nên thử đầu tiên.

Mình giải thích các mảnh ghép trong file. Phần đầu mỗi method gọi là chữ ký: static long tinhGiamGia(long tongTien) đọc là "method tên tinhGiamGia, nhận một long tên tongTien, trả về một long". Chữ static tạm thời bạn cứ viết, vì mình chưa có class nào để tạo đối tượng; bài về class sẽ giải thích nó. Lệnh return trả kết quả về nơi gọi và kết thúc method ngay tại đó, vì vậy trong tinhGiamGia không cần else: nếu điều kiện đúng, method đã trả về, và dòng return 0 chỉ chạy khi điều kiện sai. Method không trả gì thì khai báo kiểu void, như main.

Hai method tinhGiamGia có cùng tên nhưng khác danh sách tham số, và Java chọn đúng method dựa vào số lượng và kiểu tham số khi gọi. Cách này gọi là overload. Mình để ví dụ ở đây cho bạn thấy, và theo mình bạn không cần lạm dụng; trong code thật nhiều người thích đặt tên khác nhau cho dễ đọc.

Method soMonConThieu dùng while: chừng nào tongTien còn dưới ngưỡng thì cộng thêm một món và đếm. Lan có 85.000, cộng thêm 15.000 thì được 100.000, vòng dừng, kết quả 1. Nếu giaMon bằng 0 thì vòng lặp không bao giờ dừng, vì tổng không bao giờ tăng. Bất cứ khi nào bạn viết while, hãy tự hỏi điều gì làm điều kiện cuối cùng sai đi.

Method cuối dùng switch.

Nó gọn hơn một chuỗi if / else if khi bạn so một giá trị với nhiều lựa chọn. Cú pháp case "DONE", "CANCELLED" -> false gộp hai lựa chọn có cùng kết quả, và nhánh default bắt mọi giá trị còn lại: ở đây mình ném ra một ngoại lệ, vì một trạng thái lạ là lỗi chương trình và không nên bị lờ đi. Trạng thái hiện đang là chuỗi chữ, nên gõ sai "Done" thay vì "DONE" là sai. Bài về enum sẽ thay chuỗi bằng một kiểu chặt chẽ hơn. Bạn có thể xem thêm cú pháp trong phần luồng điều khiển của Oracle.

Truyền tham số vào method: nó có sửa được biến của mình không?

Đây là câu hỏi nhỏ nhưng hay vào phỏng vấn. Khi bạn đưa một biến vào method, method nhận một bản sao giá trị của biến đó, nên sửa tham số bên trong không làm đổi biến bên ngoài. Java gọi cách này là truyền theo giá trị. Mình kiểm chứng:

TruyenGiaTri.java
public class TruyenGiaTri {
    static void tangGia(long gia) {
        gia = gia + 5000;
        System.out.println("  trong method: gia = " + gia);
    }

    static void tangGiaMangDonGia(long[] gia) {
        gia[0] = gia[0] + 5000;
        System.out.println("  trong method: gia[0] = " + gia[0]);
    }

    public static void main(String[] args) {
        long giaCaPheSua = 35000;
        tangGia(giaCaPheSua);
        System.out.println("Sau khi gọi: giaCaPheSua = " + giaCaPheSua);

        long[] bangGia = {35000, 15000};
        tangGiaMangDonGia(bangGia);
        System.out.println("Sau khi gọi: bangGia[0] = " + bangGia[0]);
    }
}
Kết quả của java -Dstdout.encoding=UTF-8 TruyenGiaTri.java
  trong method: gia = 40000
Sau khi gọi: giaCaPheSua = 35000
  trong method: gia[0] = 40000
Sau khi gọi: bangGia[0] = 40000

Với số, mọi thứ như mình nói: trong method giá lên 40.000, nhưng bên ngoài vẫn 35.000. Với mảng thì khác: phần tử bị đổi thật.

Lý do là biến mảng không chứa cả dãy số mà chỉ chứa một địa chỉ trỏ tới dãy số nằm ở chỗ khác. Method vẫn nhận một bản sao, nhưng là bản sao của địa chỉ, nên cả hai bản cùng trỏ vào một mảng và sửa phần tử qua bản nào cũng thấy. Vậy nên câu trả lời đúng cho "Java truyền theo giá trị hay theo tham chiếu" là: luôn truyền theo giá trị, và với đối tượng thì giá trị được truyền là địa chỉ. Tài liệu của Oracle mô tả đúng như vậy.

Hệ quả thực tế cho bạn: một method nhận mảng hay (sau này) danh sách có thể sửa dữ liệu của người gọi mà người gọi không hay biết. Nếu method chỉ cần đọc, hãy chỉ đọc, và ghi tên method cho rõ nó làm gì.

Hỏi phỏng vấn thế nào?

Phần này ở cấp nhập môn, nên nhà tuyển dụng thường hỏi để kiểm tra bạn hiểu nền, không phải thuộc cú pháp. Câu hay gặp nhất là "Java truyền tham số theo giá trị hay theo tham chiếu?", mà bạn đã có câu trả lời ở trên; bạn nên kèm ví dụ số và ví dụ mảng như mình, vì người hỏi muốn xem bạn có biết sự khác nhau thật không. Bạn có thể xem cách trả lời đầy đủ ở mục phỏng vấn.

Hai câu khác cũng đáng chuẩn bị. Một là "Bạn kiểm tra thế nào để chắc quy tắc giảm giá từ 100.000 đồng chạy đúng?", và câu trả lời mong đợi là thử các giá trị sát mốc, như 99.999, 100.000, 100.001 ở trên. Hai là "Method overload là gì và khác override ra sao?"; bài về kế thừa sẽ nói tới override.

Bước tiếp theo là gì?

Chương trình đã biết quyết định, biết lặp, và đã được tách thành các method nhỏ. Nhưng bạn có thể thấy nó đang lớn lên: một file hơn 70 dòng, vài hằng số, vài method, và mỗi bài mình thêm vào. Chẳng bao lâu nữa bạn sẽ muốn chia thành nhiều file, thêm thư viện của người khác (đọc JSON chẳng hạn), và chạy test. Gõ java TinhDon.java rồi tự tay quản lý từng file thì không đi xa được. Việc đó cần một công cụ dựng và quản lý dự án, và đó là Maven, nội dung của bài kế tiếp trong series Học Java từ đầu cho người làm backend.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.