Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Java CoreJunior17 phút đọc

Java cơ bản: Hello World, biên dịch, ba loại lỗi và bài tập đầu tiên

Ôn 11 thẻ
Trong bài này

Cụm bài Java cơ bản: 1. JVM và JDK · 2. Hello World và ba loại lỗi · 3. Biến và kiểu dữ liệu · 4. Toán tử và rẽ nhánh · 5. Vòng lặp và hàm · 6. Mảng và chuỗi · 7. Console và file text · 8. Byte stream và serialization

Bài này viết và chạy chương trình Java đầu tiên, phân biệt ba loại lỗi, rồi làm bộ bài tập chỉ dùng lệnh in và biểu thức. Đọc xong, bạn tự biên dịch bằng javac, chạy bằng java, và nhận ra ba bẫy kinh điển: chia nguyên, tràn số, sai số số thực. Nên đọc trước bài về JVM và JDK; bài tiếp theo là biến và kiểu dữ liệu.

Sơ đồ tóm tắt:

flowchart LR
  SRC["Greeting.java"] -->|javac| BC["Greeting.class"]
  BC -->|"java Greeting"| JVM[JVM chạy main]
  SRC -.->|javac bắt| E1[Lỗi biên dịch]
  JVM -.->|exception| E2[Lỗi runtime]
  JVM -.->|"im lặng, kết quả sai"| E3[Lỗi logic]
  E3 --> X["7 / 2 == 3, tràn int"]

1. Hello World và cú pháp tối thiểu

Ý chính: chương trình Java nhỏ nhất là một class có hàm main. Ta biên dịch nó thành bytecode bằng javac rồi chạy bằng java.

public class Greeting {
    public static void main(String[] args) {
        // In một dòng rồi xuống dòng
        System.out.println("Xin chào backend!");
        /* print không xuống dòng */
        System.out.print("Hai cộng ba = ");
        System.out.println(2 + 3);
    }
}
  • public class Greeting: một file có tối đa một class public, và tên file phải trùng tên class đó (Greeting.java).
  • public static void main(String[] args): điểm bắt đầu chương trình. Phải là static vì JVM gọi nó khi chưa có object nào được tạo.
  • print in liền, println in xong thì xuống dòng. Chuỗi đặt trong "...", mỗi câu lệnh kết thúc bằng ;.
  • Comment: // cho một dòng, /* ... */ cho nhiều dòng, /** ... */ là Javadoc.
  • Toán tử số học + - * / %. Bẫy đầu tiên: hai số nguyên chia nhau thì phần lẻ bị cắt bỏ: 7 / 2 == 3. Chỉ cần một vế là số thực thì kết quả là số thực: 7.0 / 2 == 3.5.

Tự biên dịch và chạy bằng dòng lệnh một lần để thấy việc IDE đang làm hộ. Bytecode là mã trung gian mà JVM (máy ảo Java) hiểu, không phải mã máy của CPU.

mkdir -p ~/code/java-core && cd ~/code/java-core   # đường dẫn không dấu, không khoảng trắng cho đỡ rắc rối
javac Greeting.java        # sinh ra Greeting.class (bytecode)
java Greeting              # chạy: truyền TÊN CLASS, không có đuôi .class
java Greeting.java         # Java 11+: biên dịch trong bộ nhớ rồi chạy luôn, không sinh file .class
javap -c Greeting          # xem bytecode mà javac sinh ra

Ba loại lỗi

Ý chính: lỗi càng phát hiện muộn càng đắt; lỗi logic không bao giờ tự báo nên chỉ test mới bắt được.

Loại Khi nào phát hiện Ví dụ
Lỗi cú pháp (compile error) Lúc javac biên dịch Thiếu ;, gõ sai tên biến
Lỗi runtime (exception) Lúc chạy 1 / 0 ném ArithmeticException, truy cập null ném NullPointerException
Lỗi logic Không có báo lỗi nào, chỉ ra kết quả sai Dùng / của số nguyên khi tính trung bình

Exception là đối tượng lỗi mà chương trình “ném” ra khi gặp tình huống không xử lý được lúc chạy. Cách phòng lỗi logic là viết unit test và kiểm tra cả các trường hợp biên.

Bài tập

Đề đã được viết lại ngắn gọn theo cách của mình. Code đã chạy thử trên JDK 21.

Nhóm 1: chỉ dùng lệnh in và biểu thức (buổi Intro)

Đề nhóm này yêu cầu không khai báo biến, không dùng vòng lặp, chỉ in kết quả của biểu thức.

1.1. In ba dòng chào mừng (về Java, về khoa học máy tính, về lập trình): ba lệnh System.out.println.

1.2. In chữ JAVA cỡ lớn trên 4 dòng, mỗi chữ cái được vẽ bằng chính ký tự của nó (J, A, V, A đứng cạnh nhau). Chỉ dùng lệnh in.

1.3. In bảng a, a^2, a^3 với a = 1, 2, 3, 4.

Lời giải 1.2–1.3: chữ JAVA cỡ lớn, text block và printf
System.out.println("   J    A     V     V    A");
System.out.println("   J   A A     V   V    A A");
System.out.println("J  J  AAAAA     V V    AAAAA");
System.out.println(" J J A     A     V    A     A");

Output:

   J    A     V     V    A
   J   A A     V   V    A A
J  J  AAAAA     V V    AAAAA
 J J A     A     V    A     A

Bài 1.2 không khó về logic; cái khó là canh cột. Vẽ hình trên giấy kẻ ô (hoặc editor dùng font monospace), đếm số dấu cách trước từng ký tự rồi mới gõ code. Chữ “A” rộng dần 1 ô mỗi dòng, chữ “V” hẹp dần, nên chỉ cần kiểm tra vị trí hai cạnh.

Senior sẽ làm gọn hơn bằng text block (Java 15+, chuỗi nhiều dòng trong """): hình vẽ trong code trông y như output, không phải escape gì. Java tự bỏ phần thụt lề chung, tính theo dòng thụt ít nhất (kể cả dòng chứa dấu """ đóng):

System.out.print("""
       J    A     V     V    A
       J   A A     V   V    A A
    J  J  AAAAA     V V    AAAAA
     J J A     A     V    A     A
    """);

Bài 1.3:

System.out.printf("%-6s%-6s%-6s%n", "a", "a^2", "a^3");
System.out.printf("%-6d%-6d%-6d%n", 1, 1 * 1, 1 * 1 * 1);
System.out.printf("%-6d%-6d%-6d%n", 2, 2 * 2, 2 * 2 * 2);
System.out.printf("%-6d%-6d%-6d%n", 3, 3 * 3, 3 * 3 * 3);
System.out.printf("%-6d%-6d%-6d%n", 4, 4 * 4, 4 * 4 * 4);
a     a^2   a^3
1     1     1
2     4     8
3     9     27
4     16    64

%-6d nghĩa là căn trái trong 6 ô; để printf canh cột thay vì đếm dấu cách bằng tay. Đề cấm biến và vòng lặp nên phải lặp lại 4 lệnh; ngoài đời sẽ viết for (int a = 1; a <= 4; a++) với một lệnh printf. Không dùng Math.pow(a, 2) cho số nguyên: nó trả về double (in ra 4.0) và chậm hơn phép nhân.

1.4–1.5. Chu vi và diện tích hình tròn (r = 5,5 cm) và hình chữ nhật (4,5 × 7,9 cm).

1.6. In kết quả của bốn biểu thức: (a) (9,5 × 4,5 − 2,5 × 3) / (45,5 − 3,5), (b) 1 + 2 + … + 9, (c) 1 + 2 + … + 1 000 000, (d) 4 × (1 − 1/3 + 1/5 − 1/7 + 1/9 − 1/11 + 1/13).

Hai bài này gặp đủ ba bẫy số: 4.5 * 7.9 in ra 35.550000000000004, (d) gõ bằng số nguyên thì ra 4, và (c) tính bằng int thì ra số âm.

Lời giải 1.4–1.6: Math.PI, chuỗi Leibniz và công thức Gauss
System.out.println("Chu vi tròn: " + 2 * Math.PI * 5.5);        // 34.557...
System.out.println("Diện tích tròn: " + Math.PI * 5.5 * 5.5);   // 95.033...
System.out.println("Chu vi CN: " + 2 * (4.5 + 7.9));            // 24.8
System.out.printf("Diện tích CN: %.2f%n", 4.5 * 7.9);           // 35.55

Dùng Math.PI thay cho 3.14. In thẳng 4.5 * 7.9 sẽ ra 35.550000000000004, vì số thực nhị phân không biểu diễn chính xác được 0,1. Muốn hiển thị đẹp thì dùng %.2f.

System.out.println((9.5 * 4.5 - 2.5 * 3) / (45.5 - 3.5));   // (a) 0.8392857142857143
System.out.println(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9);       // (b) 45
System.out.println(4 * (1.0 - 1.0 / 3 + 1.0 / 5 - 1.0 / 7
        + 1.0 / 9 - 1.0 / 11 + 1.0 / 13));                   // (d) 3.2837384837384844

(a) và (b) chỉ là gõ đúng thứ tự ưu tiên: nhân làm trước trừ, mẫu số phải đặt trong ngoặc. Biểu thức (d) là 7 số hạng đầu của chuỗi Leibniz: π/4 = 1 − 1/3 + 1/5 − 1/7 + ….

Kết quả 3,28 còn xa 3,14159 vì chuỗi này hội tụ rất chậm: thêm số hạng −1/15 thì ra 3,017, và cần hàng triệu số hạng mới đúng được 6 chữ số. Bài cho thấy máy tính tính xấp xỉ π bằng cách cộng dồn; code thật thì cứ dùng Math.PI.

Với (c), không được dùng vòng lặp thì dùng công thức Gauss n(n+1)/2:

System.out.println(1_000_000L * (1_000_000L + 1) / 2); // 500000500000
System.out.println(1_000_000 * (1_000_000 + 1) / 2);   // -363189984 do tràn int!

Đây là bài học về tràn số (overflow: kết quả vượt giới hạn của kiểu): nhân hai int cho ra int, và kết quả bị quay vòng mà không báo lỗi gì. Chỉ cần một toán hạng là long thì cả phép tính được làm bằng long.

1.7. Vận động viên chạy 14 km trong 45 phút 30 giây, tính tốc độ theo dặm/giờ (1 dặm = 1,6 km).

1.8. Chạy 24 dặm trong 1 giờ 40 phút 35 giây, tính km/giờ.

1.9. Dự báo dân số 5 năm tới. Giả định cứ 7 giây có một ca sinh, 13 giây có một người mất, 45 giây có một người nhập cư; dân số hiện tại 312 032 486; một năm 365 ngày.

Lời giải 1.7–1.9: đổi đơn vị tốc độ và dự báo dân số
System.out.println((14 / 1.6) / ((45 * 60 + 30) / 3600.0)); // 1.7: ≈ 11.54 mph
System.out.println((24 * 1.6) / ((1 * 3600 + 40 * 60 + 35) / 3600.0)); // 1.8: ≈ 22.91 km/h

Chú ý 3600.0: nếu viết 3600, phép chia giây cho 3600 sẽ là chia nguyên và ra 0 hoặc 1.

// số giây một năm = 365 * 24 * 60 * 60 = 31_536_000
System.out.println(312_032_486L + 31_536_000L * 1 / 7 - 31_536_000L * 1 / 13 + 31_536_000L * 1 / 45);
System.out.println(312_032_486L + 31_536_000L * 2 / 7 - 31_536_000L * 2 / 13 + 31_536_000L * 2 / 45);
// ... lặp lại với 3, 4, 5 năm. Kết quả năm 1 là 314812582, năm 5 là 325932970

Mỗi năm tính từ tổng số giây. Nếu lấy kết quả một năm rồi nhân 5 thì sai số do chia nguyên sẽ cộng dồn.

1.10. Giải hệ 2×2 bằng quy tắc Cramer. Với hệ ax + by = e, cx + dy = f, khi ad − bc ≠ 0 thì x = (ed − bf)/(ad − bc) và y = (af − ec)/(ad − bc). Đề cho hệ:

3.4x + 50.2y = 44.5
2.1x + 0.55y = 5.9
Lời giải 1.10: thay số, kiểm tra ngược và cách senior làm

Tức là a = 3,4, b = 50,2, c = 2,1, d = 0,55, e = 44,5, f = 5,9. Định thức ad − bc = 1,87 − 105,42 = −103,55 khác 0 nên hệ có đúng một nghiệm. Thay số vào công thức:

System.out.println("x = " + (44.5 * 0.55 - 50.2 * 5.9) / (3.4 * 0.55 - 50.2 * 2.1)); // 2.623901496861419
System.out.println("y = " + (3.4 * 5.9 - 44.5 * 2.1) / (3.4 * 0.55 - 50.2 * 2.1));   // 0.7087397392563978

Kiểm tra bằng cách thay ngược lại: 3,4 · 2,6239 + 50,2 · 0,7087 ≈ 44,5 và 2,1 · 2,6239 + 0,55 · 0,7087 ≈ 5,9. Đề in hệ số là .55; Java cũng chấp nhận literal .55, nhưng 0.55 dễ đọc hơn.

Để chắc công thức đã gõ đúng, thử trước với một hệ có nghiệm nguyên, ví dụ 2x + 3y = 8, 5x − y = 3 (nghiệm x = 1, y = 2):

System.out.println("x = " + (8.0 * -1 - 3 * 3) / (2 * -1 - 3 * 5));  // 1.0
System.out.println("y = " + (2.0 * 3 - 5 * 8) / (2 * -1 - 3 * 5));   // 2.0

Senior sẽ làm thêm:

  • In bằng printf("%.4f") thay vì 16 chữ số thập phân.
  • Kiểm tra định thức bằng ngưỡng (Math.abs(det) < 1e-9) chứ không so == 0, vì với double một định thức “bằng 0” về toán học thường ra số rất nhỏ như 1e-17.
  • Với hệ lớn hơn thì dùng khử Gauss hoặc thư viện (Apache Commons Math), vì quy tắc Cramer phải tính n + 1 định thức, quá tốn khi n lớn.

Ghi nhớ

  • Giải thích được vì sao main phải là public static void main(String[] args).
  • Biết javac và java nhận gì, và vì sao java Greeting.class báo lỗi.
  • Phân biệt được ba loại lỗi và vì sao lỗi logic nguy hiểm nhất.
  • Đoán đúng kết quả của 7 / 2, 1.0 / 0 và 1_000_000 * 1_000_001, và biết cách sửa.
  • Biết vì sao không so hai double bằng ==.

Câu hỏi phỏng vấn

Junior

Vì sao main phải là public static void main(String[] args)?

JVM gọi main khi chưa có object nào nên nó phải static, và phải public để JVM gọi được từ ngoài class.

Kiểu trả về là void vì chương trình báo mã thoát qua System.exit(code) chứ không qua giá trị trả về. args là tham số dòng lệnh. Từ Java 25, chương trình nhỏ được phép viết void main() (không static, không tham số); JVM tự tạo object rồi gọi, nhưng code production vẫn dùng dạng đầy đủ.

Lỗi biên dịch, lỗi runtime và lỗi logic khác nhau thế nào? Loại nào nguy hiểm nhất?

Khác nhau ở lúc phát hiện: lúc biên dịch, lúc chạy, hoặc không bao giờ. Lỗi logic nguy hiểm nhất vì không báo gì.

Lỗi biên dịch bị javac bắt (thiếu ;, sai kiểu), chương trình chưa chạy được. Lỗi runtime xảy ra lúc chạy dưới dạng exception (ArithmeticException khi chia nguyên cho 0, NullPointerException). Lỗi logic vẫn chạy nhưng ra kết quả sai. Cách phòng là unit test với các trường hợp biên và code review.

Vì sao 7 / 2 ra 3 trong Java? Muốn ra 3.5 thì viết thế nào?

Hai toán hạng đều là int nên là chia nguyên; cho một vế là số thực: 7.0 / 2 hoặc (double) a / b.

Phần lẻ bị cắt về phía 0, nên -7 / 2 == -3. Viết 7 / 2.0 cũng được. Viết (double) (a / b) là sai, vì phép chia nguyên đã xảy ra trước khi ép kiểu.

javac và java khác nhau thế nào? Vì sao java Greeting.class báo lỗi?

javac biên dịch .java thành bytecode .class; java khởi động JVM và chạy class theo tên, nên không nhận đường dẫn .class.

java là launcher: chạy class có main. Nó nhận tên class (hoặc từ Java 11 là một file .java đơn lẻ), nên java Greeting.class bị hiểu là class class trong package Greeting và báo không tìm thấy.

Mid

Vì sao 1_000_000 * (1_000_000 + 1) / 2 ra số âm? Sửa thế nào?

Phép nhân làm bằng int 32 bit nên tràn và quay vòng âm; cho một toán hạng là long (1_000_000L).

Kết quả (khoảng 10¹²) vượt Integer.MAX_VALUE rồi quay vòng thành số âm, không có exception nào. Có một toán hạng long thì cả biểu thức tính bằng long. Nếu muốn lỗi lộ ra thay vì sai âm thầm thì dùng Math.multiplyExact, nó ném ArithmeticException khi tràn.

Vì sao không nên so sánh hai double bằng ==?

Số thực nhị phân không biểu diễn chính xác phần lớn số thập phân, nên so bằng ngưỡng: Math.abs(a - b) < 1e-9.

0.1 + 0.2 == 0.3 là false và 4.5 * 7.9 ra 35.550000000000004. Cùng một công thức có thể lệch ở chữ số cuối tuỳ thứ tự tính. Với số lớn dùng ngưỡng tương đối. Với tiền thì dùng BigDecimal hoặc số nguyên theo đơn vị nhỏ nhất, không dùng double.

Senior

Khi nào bạn chạy thẳng java Hello.java, và vì sao không dùng cách đó cho service production?

Dùng cho script nhỏ và thử nhanh; production cần bước build, quản lý dependency và artifact có phiên bản.

Source-file mode (Java 11+) biên dịch trong bộ nhớ rồi chạy luôn, tiện cho script nhỏ, thử nhanh một API, hay file có shebang #!/usr/bin/java --source 21. Production thì không: mỗi lần khởi động lại phải biên dịch, không có bước build để chạy test và kiểm tra, không quản lý dependency (Maven/Gradle), không đóng gói thành JAR hay image có phiên bản. Service thật cần build lặp lại được, artifact cố định và có thể tối ưu khởi động (CDS, jlink).

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
runtime exception /ˈrʌntaɪm/ lỗi xảy ra lúc chạy “Dividing an int by zero throws a runtime exception.”
compiler /kəmˈpaɪlər/ trình biên dịch “javac is the compiler; the JVM never sees the .java file.”
text block chuỗi nhiều dòng """ (Java 15+) “I keep the SQL in a text block so it reads the same as in the database console.”
syntax error /ˈsɪntæks/ lỗi cú pháp “A syntax error stops javac, so the program never runs.”
integer division /ˈɪntɪdʒər dɪˈvɪʒn/ phép chia nguyên “Integer division truncates, so I cast one operand to double first.”
integer overflow /ˈoʊvərfloʊ/ tràn số nguyên “The sum overflowed int, so I switched the accumulator to long.”
entry point /ˈentri pɔɪnt/ điểm bắt đầu chương trình “main is the entry point the JVM calls first.”
format specifier /ˈfɔːrmæt ˈspesɪfaɪər/ ký hiệu định dạng trong printf “%-6d is a format specifier for a left-aligned integer six characters wide.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.