1. Lệnh Rẽ Nhánh switch
1.1 Giới thiệu về lệnh switch
Lệnh switch cung cấp một cách hiệu quả để thực hiện các hành động khác nhau dựa trên giá trị của một biến hoặc biểu thức. Nó được sử dụng khi bạn có nhiều điều kiện rẽ nhánh dựa trên cùng một giá trị.
Cú pháp:
switch (bieuThuc) {
case giaTri1:
khoiLenh1;
break;
case giaTri2:
khoiLenh2;
break;
// ... các trường hợp khác
default:
khoiLenhMacDinh;
break;
}
Luồng thực thi:
- Đầu tiên, giá trị của
bieuThucđược tính toán. - Sau đó, giá trị này được so sánh tuần tự với từng
giaTritrong các khốicase. - Nếu tìm thấy một
casecó giá trị khớp,khoiLenhtương ứng sẽ được thực thi. Quá trình thực thi sẽ dừng khi gặp từ khóabreak. - Nếu không có
casenào khớp với giá trị củabieuThuc,khoiLenhMacDinhtrong phầndefaultsẽ được thực thi, và sau đó chương trình tiếp tục sau khốiswitch.
1.2 Ví dụ về switch: Kế hoạch rèn luyện
Yêu cầu: Nhập vào một số nguyên đại diện cho ngày trong tuần (từ 1 đến 7), và hiển thị hoạt động rèn luyện tương ứng cho ngày đó.
- Thứ Hai: Chạy bộ
- Thứ Ba: Bơi lội
- Thứ Tư: Đi bộ nhanh
- Thứ Năm: Đạp xe năng động
- Thứ Sáu: Quyền Anh
- Thứ Bảy: Leo núi
- Chủ Nhật: Thưởng thức bữa ăn ngon
Mã minh họa:
import java.util.Scanner;
public class KeHoachRenLuyen {
public static void main(String[] args) {
Scanner inputScanner = new Scanner(System.in);
System.out.print("Vui lòng nhập số ngày trong tuần (1-7): ");
int ngayTrongTuan = inputScanner.nextInt();
switch (ngayTrongTuan) {
case 1:
System.out.println("Thứ Hai: Chạy bộ");
break;
case 2:
System.out.println("Thứ Ba: Bơi lội");
break;
case 3:
System.out.println("Thứ Tư: Đi bộ nhanh");
break;
case 4:
System.out.println("Thứ Năm: Đạp xe năng động");
break;
case 5:
System.out.println("Thứ Sáu: Quyền Anh");
break;
case 6:
System.out.println("Thứ Bảy: Leo núi");
break;
case 7:
System.out.println("Chủ Nhật: Thưởng thức bữa ăn ngon");
break;
default:
System.out.println("Dữ liệu nhập không hợp lệ.");
break;
}
inputScanner.close();
}
}
1.3 Hiện tượng "Case Fall-through" trong switch
Tổng quan: Nếu một khối case trong lệnh switch bỏ qua từ khóa break, chương trình sẽ tiếp tục thực thi các khối case tiếp theo mà không kiểm tra điều kiện, cho đến khi gặp break hoặc kết thúc khối switch. Hiện tượng này được gọi là "case fall-through".
Yêu cầu: Nhập vào một số nguyên đại diện cho ngày trong tuần, và xuất ra liệu đó là "Ngày làm việc" hay "Ngày nghỉ cuối tuần". (Thứ 2-6 là ngày làm việc, Thứ 7-CN là ngày nghỉ).
Mã minh họa:
import java.util.Scanner;
public class PhanLoaiNgay {
public static void main(String[] args) {
Scanner inputScanner = new Scanner(System.in);
System.out.print("Vui lòng nhập số ngày trong tuần (1-7): ");
int ngay = inputScanner.nextInt();
switch (ngay) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("Đây là ngày làm việc.");
break;
case 6:
case 7:
System.out.println("Đây là ngày nghỉ cuối tuần.");
break;
default:
System.out.println("Giá trị nhập không hợp lệ.");
break;
}
inputScanner.close();
}
}
2. Vòng lặp for
2.1 Giới thiệu về vòng lặp for
Vòng lặp cho phép một đoạn mã được thực thi lặp đi lặp lại miễn là một điều kiện nhất định còn đúng. Đoạn mã được lặp lại này được gọi là thân vòng lặp. Cần có cơ chế để thay đổi điều kiện lặp thành false để kết thúc vòng lặp, nếu không sẽ dẫn đến vòng lặp vô hạn.
Cú pháp vòng lặp for:
for (khoiKhoiTao; dieuKienLap; khoiCapNhat) {
lenhTrongThanVongLap;
}
Giải thích cú pháp:
khoiKhoiTao: Được thực thi một lần duy nhất khi vòng lặp bắt đầu, dùng để thiết lập trạng thái ban đầu của biến điều khiển vòng lặp.dieuKienLap: Một biểu thức boolean được kiểm tra trước mỗi lần lặp. Nếutrue, thân vòng lặp được thực thi. Nếufalse, vòng lặp kết thúc.khoiCapNhat: Được thực thi sau mỗi lần thân vòng lặp hoàn thành, thường dùng để thay đổi giá trị của biến điều khiển vòng lặp.lenhTrongThanVongLap: Các câu lệnh sẽ được thực thi lặp đi lặp lại.
Luồng thực thi:
- Thực thi
khoiKhoiTao. - Đánh giá
dieuKienLap.- Nếu là
false, vòng lặp kết thúc. - Nếu là
true, tiếp tục thực thi.
- Nếu là
- Thực thi
lenhTrongThanVongLap. - Thực thi
khoiCapNhat. - Quay lại bước 2.
2.2 Ví dụ về vòng lặp for: In số từ 1 đến 5 và từ 5 đến 1
Yêu cầu: In ra các số từ 1 đến 5 và từ 5 đến 1 trên bảng điều khiển.
Mã minh họa:
public class VongLapForCoBan {
public static void main(String[] args) {
System.out.println("In số từ 1 đến 5:");
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
System.out.println("----------");
System.out.println("In số từ 5 đến 1:");
for (int i = 5; i >= 1; i--) {
System.out.println(i);
}
}
}
2.3 Ví dụ về vòng lặp for: Tính tổng các số từ 1 đến 5
Yêu cầu: Tính tổng các số nguyên từ 1 đến 5 và hiển thị kết quả trên bảng điều khiển.
Mã minh họa:
public class TongDaySo {
public static void main(String[] args) {
// Biến để lưu trữ tổng cuối cùng, khởi tạo bằng 0
int tongCacSo = 0;
// Vòng lặp từ 1 đến 5
for (int soHienTai = 1; soHienTai <= 5; soHienTai++) {
// Cộng số hiện tại vào tổng
tongCacSo += soHienTai;
/*
Giải thích:
Lần 1: tongCacSo = 0 + 1 = 1;
Lần 2: tongCacSo = 1 + 2 = 3;
Lần 3: tongCacSo = 3 + 3 = 6;
Lần 4: tongCacSo = 6 + 4 = 10;
Lần 5: tongCacSo = 10 + 5 = 15;
*/
}
// In ra kết quả tổng
System.out.println("Tổng các số từ 1 đến 5 là: " + tongCacSo);
}
}
Lưu ý quan trọng: Nếu bạn cần tính tổng hoặc đếm trong vòng lặp, biến tích lũy (ví dụ: tongCacSo) phải được khai báo và khởi tạo bên ngoài vòng lặp.
2.4 Ví dụ về vòng lặp for: Tính tổng các số chẵn từ 1 đến 100
Yêu cầu: Tính tổng các số chẵn trong phạm vi từ 1 đến 100 và in kết quả ra bảng điều khiển.
Mã minh họa:
public class TongSoChan {
public static void main(String[] args) {
// Khởi tạo biến tổng
int tongSoChan = 0;
// Duyệt qua các số từ 1 đến 100
for (int num = 1; num <= 100; num++) {
// Kiểm tra xem số có phải là số chẵn không
if (num % 2 == 0) {
tongSoChan += num; // Cộng số chẵn vào tổng
}
}
// In ra tổng các số chẵn
System.out.println("Tổng các số chẵn từ 1 đến 100 là: " + tongSoChan);
}
}
2.5 Ví dụ về vòng lặp for: Tìm Số Armstrong
Yêu cầu: In ra tất cả các "Số Armstrong" (hay còn gọi là số Narcissus) có ba chữ số ra bảng điều khiển.
Giải thích: Số Armstrong là một số nguyên dương có n chữ số mà tổng lũy thừa bậc n của các chữ số của nó bằng chính số đó. Với bài toán này, chúng ta tìm số Armstrong có ba chữ số, tức là tổng lập phương của các chữ số bằng chính số đó.
Ví dụ: 153 là một số Armstrong vì 13 + 53 + 33 = 1 + 125 + 27 = 153.
Cách tiếp cận:
- Duyệt qua tất cả các số có ba chữ số (từ 100 đến 999).
- Với mỗi số, tách riêng từng chữ số (hàng đơn vị, hàng chục, hàng trăm).
- Kiểm tra xem tổng lập phương của các chữ số có bằng số ban đầu hay không.
Mã minh họa:
public class TimSoArmstrong {
public static void main(String[] args) {
System.out.println("Các số Armstrong có ba chữ số:");
// Duyệt qua tất cả các số có ba chữ số
for (int soCanKiemTra = 100; soCanKiemTra <= 999; soCanKiemTra++) {
// Tách từng chữ số
int chuSoHangDonVi = soCanKiemTra % 10;
int chuSoHangChuc = (soCanKiemTra / 10) % 10;
int chuSoHangTram = soCanKiemTra / 100;
// Tính tổng lập phương của các chữ số và so sánh với số ban đầu
int tongLapPhuong = (chuSoHangDonVi * chuSoHangDonVi * chuSoHangDonVi) +
(chuSoHangChuc * chuSoHangChuc * chuSoHangChuc) +
(chuSoHangTram * chuSoHangTram * chuSoHangTram);
if (tongLapPhuong == soCanKiemTra) {
System.out.println(soCanKiemTra);
}
}
}
}
2.6 Ví dụ về vòng lặp for: In 2 Số Armstrong trên mỗi dòng (với đếm)
Yêu cầu: In ra tất cả các Số Armstrong có ba chữ số, mỗi dòng in 2 số.
Mã minh họa:
public class InSoArmstrongTheoDong {
public static void main(String[] args) {
// Biến đếm số lượng số Armstrong đã in
int demSoArmstrong = 0;
for (int num = 100; num <= 999; num++) {
int donVi = num % 10;
int chuc = (num / 10) % 10;
int tram = num / 100;
int tongLapPhuong = (int) (Math.pow(donVi, 3) + Math.pow(chuc, 3) + Math.pow(tram, 3));
if (tongLapPhuong == num) {
System.out.print(num + "\t"); // In số và một tab, không xuống dòng
demSoArmstrong++; // Tăng biến đếm
// Nếu đã in 2 số, thì xuống dòng
if (demSoArmstrong % 2 == 0) {
System.out.println();
}
}
}
// Đảm bảo xuống dòng cuối cùng nếu tổng số không chẵn
if (demSoArmstrong % 2 != 0) {
System.out.println();
}
}
}
Lưu ý quan trọng: Khi yêu cầu có liên quan đến việc "đếm" hoặc "thống kê", hãy nghĩ ngay đến việc sử dụng một biến đếm (counter variable) và đặt nó bên ngoài vòng lặp.
3. Vòng lặp while
3.1 Giới thiệu về vòng lặp while
Vòng lặp while liên tục thực thi một khối lệnh miễn là một điều kiện được chỉ định còn đúng.
Cú pháp đầy đủ của vòng lặp while:
khoiKhoiTao;
while (dieuKienLap) {
lenhTrongThanVongLap;
khoiCapNhat;
}
Luồng thực thi vòng lặp while:
- Thực thi
khoiKhoiTao. - Đánh giá
dieuKienLap.- Nếu là
false, vòng lặp kết thúc. - Nếu là
true, tiếp tục thực thi.
- Nếu là
- Thực thi
lenhTrongThanVongLap. - Thực thi
khoiCapNhat. - Quay lại bước 2.
Mã minh họa:
public class VongLapWhileCoBan {
public static void main(String[] args) {
System.out.println("Sử dụng vòng lặp for:");
for (int i = 0; i < 5; i++) {
System.out.println("Chào Thế Giới!");
}
System.out.println("----------");
System.out.println("Sử dụng vòng lặp while:");
int dem = 0;
while (dem < 5) {
System.out.println("Chào Thế Giới!");
dem++;
}
}
}
3.2 Ví dụ về vòng lặp while: Bài toán núi Everest
Yêu cầu: Đỉnh núi cao nhất thế giới là Everest (khoảng 8848.86 mét, tương đương 8848860 milimét). Giả sử bạn có một tờ giấy đủ lớn với độ dày 0.1 milimét. Hỏi bạn cần gấp tờ giấy này bao nhiêu lần để đạt đến chiều cao của núi Everest?
Mã minh họa:
public class BaiToanEverest {
public static void main(String[] args) {
// Biến đếm số lần gấp giấy
int soLanGap = 0;
// Độ dày ban đầu của tờ giấy (milimét)
double doDayHienTai = 0.1;
// Chiều cao của núi Everest (milimét)
double chieuCaoEverest = 8848860; // 8848.86 mét = 8848860 mm
// Vòng lặp tiếp tục miễn là độ dày giấy nhỏ hơn hoặc bằng chiều cao Everest
while (doDayHienTai <= chieuCaoEverest) {
doDayHienTai *= 2; // Gấp giấy, độ dày tăng gấp đôi
soLanGap++; // Tăng số lần gấp
}
// In ra số lần gấp cần thiết
System.out.println("Cần gấp tờ giấy " + soLanGap + " lần để đạt chiều cao Everest.");
}
}
4. Chi tiết về các vòng lặp
4.1 Vòng lặp do-while
Vòng lặp do-while tương tự như while, nhưng nó đảm bảo rằng khối lệnh bên trong vòng lặp được thực thi ít nhất một lần trước khi điều kiện được kiểm tra.
Cú pháp đầy đủ:
khoiKhoiTao;
do {
lenhTrongThanVongLap;
khoiCapNhat;
} while (dieuKienLap);
Luồng thực thi:
- Thực thi
khoiKhoiTao. - Thực thi
lenhTrongThanVongLap. - Thực thi
khoiCapNhat. - Đánh giá
dieuKienLap.- Nếu là
false, vòng lặp kết thúc. - Nếu là
true, quay lại bước 2.
- Nếu là
Mã minh họa:
public class VongLapDoWhile {
public static void main(String[] args) {
System.out.println("Sử dụng vòng lặp for:");
for (int i = 0; i < 3; i++) {
System.out.println("Do-While Test");
}
System.out.println("----------");
System.out.println("Sử dụng vòng lặp do-while:");
int count = 0;
do {
System.out.println("Do-While Test");
count++;
} while (count < 3);
}
}
4.2 Sự khác biệt giữa ba loại vòng lặp
forvàwhile: Cả hai đều kiểm tra điều kiện trước khi thực thi thân vòng lặp (pre-test loops). Nếu điều kiện ban đầu làfalse, thân vòng lặp sẽ không bao giờ được thực thi.do-while: Thực thi thân vòng lặp ít nhất một lần, sau đó mới kiểm tra điều kiện (post-test loop). Nếu điều kiện ban đầu làfalse, thân vòng lặp vẫn được thực thi một lần.
Sự khác biệt giữa for và while về phạm vi biến:
- Biến điều khiển được khai báo trong phần khởi tạo của vòng lặp
for(ví dụ:int i=1) chỉ có phạm vi trong vòng lặpforđó. Sau khi vòng lặp kết thúc, biến đó không thể truy cập được nữa. - Biến điều khiển của vòng lặp
while(nếu được khai báo bên ngoài vòng lặp) vẫn có thể được sử dụng sau khi vòng lặpwhilekết thúc.
4.3 Vòng lặp vô hạn
Vòng lặp vô hạn (infinite loop) là một vòng lặp không bao giờ kết thúc vì điều kiện của nó luôn đúng.
Các định dạng phổ biến của vòng lặp vô hạn:
// Vòng lặp for vô hạn
for (;;) {
// ...
}
// Vòng lặp while vô hạn
while (true) {
// ...
}
// Vòng lặp do-while vô hạn
do {
// ...
} while (true);
Ứng dụng: Vòng lặp vô hạn thường được dùng trong các trường hợp cần chương trình chạy liên tục cho đến khi gặp một điều kiện ngoại lệ (ví dụ: người dùng nhập lệnh thoát, lỗi hệ thống) hoặc trong các hệ thống nhúng, máy chủ cần hoạt động 24/7. Ví dụ điển hình là các menu tương tác hoặc vòng lặp chờ nhập liệu của người dùng.
4.4 Các lệnh điều khiển luồng
Hai lệnh điều khiển luồng quan trọng trong các cấu trúc lặp là break và continue.
break: Dùng để thoát hoàn toàn khỏi cấu trúc vòng lặp hoặc lệnhswitchgần nhất mà nó nằm trong. Chương trình sẽ tiếp tục thực thi các câu lệnh sau vòng lặp/switch.continue: Dùng để bỏ qua phần còn lại của lần lặp hiện tại trong vòng lặp và chuyển sang lần lặp tiếp theo.
Lưu ý: Lệnh continue chỉ có thể được sử dụng bên trong các vòng lặp.
Ví dụ về continue: Mô phỏng thang máy
Yêu cầu: Mô phỏng thang máy đi từ tầng 1 đến tầng 24, nhưng không dừng ở tầng 4 (thường do mê tín).
public class DemoContinue {
public static void main(String[] args) {
for (int tang = 1; tang <= 24; tang++) {
if (tang == 4) {
continue; // Bỏ qua tầng 4, không thực hiện lệnh bên dưới
}
System.out.println("Thang máy đến tầng " + tang + ".");
}
}
}
Ví dụ về break: Mô phỏng quá trình làm việc và nghỉ hưu
Yêu cầu: Một người làm việc từ tuổi 20 đến tuổi 80, nhưng nghỉ hưu ở tuổi 60.
public class DemoBreak {
public static void main(String[] args) {
for (int tuoi = 20; tuoi <= 80; tuoi++) {
if (tuoi == 60) {
System.out.println("Chúc mừng, bạn đã nghỉ hưu ở tuổi " + tuoi + "!");
break; // Dừng toàn bộ vòng lặp
}
System.out.println("Ở tuổi " + tuoi + ", bạn đang đi làm.");
}
}
}
Ví dụ: Menu tương tác với break và nhãn vòng lặp
Yêu cầu: Chương trình cho phép người dùng liên tục tra cứu kế hoạch rèn luyện theo ngày trong tuần, cho đến khi người dùng nhập 0 để thoát chương trình.
import java.util.Scanner;
public class MenuKiemTraKeHoach {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// Sử dụng nhãn 'vongLapChinh' để thoát khỏi vòng lặp ngoài khi cần
vongLapChinh:
while (true) {
System.out.println("\n------------------------------------");
System.out.println("Vui lòng nhập số ngày trong tuần (1-7) để xem kế hoạch:");
System.out.println("Nhập 0 để thoát chương trình.");
System.out.print("Lựa chọn của bạn: ");
int ngayDuocChon = sc.nextInt();
switch (ngayDuocChon) {
case 0:
System.out.println("Cảm ơn bạn đã sử dụng chương trình!");
break vongLapChinh; // Thoát khỏi vòng lặp chính
case 1:
System.out.println("Kế hoạch Thứ Hai: Chạy bộ");
break;
case 2:
System.out.println("Kế hoạch Thứ Ba: Bơi lội");
break;
case 3:
System.out.println("Kế hoạch Thứ Tư: Đi bộ nhanh");
break;
case 4:
System.out.println("Kế hoạch Thứ Năm: Đạp xe năng động");
break;
case 5:
System.out.println("Kế hoạch Thứ Sáu: Quyền Anh");
break;
case 6:
System.out.println("Kế hoạch Thứ Bảy: Leo núi");
break;
case 7:
System.out.println("Kế hoạch Chủ Nhật: Thưởng thức bữa ăn ngon");
break;
default:
System.out.println("Ngày không hợp lệ. Vui lòng nhập số từ 0 đến 7.");
break;
}
}
sc.close();
}
}
5. Lớp Random
5.1 Tạo số ngẫu nhiên với lớp Random
Tổng quan: Lớp Random, tương tự như Scanner, là một API do Java cung cấp, chứa các chức năng để tạo ra số ngẫu nhiên.
Các bước sử dụng:
- Import package:
import java.util.Random;Lệnh
importphải được đặt phía trên định nghĩa lớp. - Tạo đối tượng:
Random ngauNhienGenerator = new Random();Trong đó
ngauNhienGeneratorlà tên biến, bạn có thể thay đổi tùy ý. - Tạo số ngẫu nhiên:
int soNgauNhien = ngauNhienGenerator.nextInt(10);Phương thức
nextInt(10)sẽ tạo ra một số nguyên ngẫu nhiên trong phạm vi từ 0 (bao gồm) đến 10 (không bao gồm), tức là từ 0 đến 9. Nếu bạn truyền 20, nó sẽ tạo số từ 0 đến 19.
Yêu cầu: Tạo và in ra 10 số ngẫu nhiên trong phạm vi từ 1 đến 10.
Mã minh họa:
import java.util.Random;
public class TaoSoNgauNhien {
public static void main(String[] args) {
// 1. Tạo đối tượng Random
Random randomObj = new Random();
System.out.println("10 số ngẫu nhiên từ 1 đến 10:");
for (int i = 0; i < 10; i++) {
// 2. Lấy số ngẫu nhiên trong khoảng [0, 9] và cộng 1 để được [1, 10]
int soNgauNhien = randomObj.nextInt(10) + 1;
System.out.println(soNgauNhien);
}
}
}
5.3 Thực hành với Random: Trò chơi đoán số
Yêu cầu: Chương trình tự động tạo một số bí mật trong khoảng từ 1 đến 100. Người chơi sẽ đoán số đó. Dựa vào kết quả đoán, chương trình sẽ đưa ra gợi ý:
- Nếu số đoán lớn hơn số bí mật: "Số bạn đoán quá lớn!"
- Nếu số đoán nhỏ hơn số bí mật: "Số bạn đoán quá nhỏ!"
- Nếu số đoán bằng số bí mật: "Chúc mừng! Bạn đã đoán đúng!"
Cách tiếp cận:
- Khởi tạo đối tượng
RandomvàScanner. - Sử dụng
Randomđể tạo một số nguyên ngẫu nhiên từ 1 đến 100, đó là số bí mật cần đoán. - Sử dụng vòng lặp vô hạn (
while(true)) để cho phép người chơi đoán nhiều lần. - Trong mỗi lần lặp, đọc số mà người dùng nhập từ bàn phím.
- So sánh số người dùng đoán với số bí mật và in ra gợi ý tương ứng.
- Nếu người chơi đoán đúng, in thông báo chúc mừng và sử dụng
breakđể thoát vòng lặp.
Mã minh họa:
import java.util.Scanner;
import java.util.Random;
public class TroChoiDoanSo {
public static void main(String[] args) {
// 1. Tạo đối tượng Random để sinh số bí mật
Random randomGenerator = new Random();
// 2. Tạo đối tượng Scanner để đọc dữ liệu từ người dùng
Scanner inputScanner = new Scanner(System.in);
// 3. Sinh số bí mật trong khoảng [1, 100]
int soBiMat = randomGenerator.nextInt(100) + 1;
System.out.println("Một số bí mật từ 1 đến 100 đã được tạo. Hãy đoán!");
// 4. Bắt đầu vòng lặp đoán số
while (true) {
System.out.print("Nhập số bạn đoán: ");
int soDoanCuaBan = inputScanner.nextInt();
// 5. So sánh số đoán với số bí mật và đưa ra gợi ý
if (soDoanCuaBan > soBiMat) {
System.out.println("Số bạn đoán quá lớn!");
} else if (soDoanCuaBan < soBiMat) {
System.out.println("Số bạn đoán quá nhỏ!");
} else {
// 6. Đoán đúng, in thông báo và thoát vòng lặp
System.out.println("Chúc mừng! Bạn đã đoán đúng số bí mật là " + soBiMat + ".");
break;
}
}
System.out.println("Cảm ơn bạn đã tham gia trò chơi.");
inputScanner.close();
}
}