Các Khái Niệm Nền Tảng Trong Lập Trình Java

1. Chuẩn Bị Môi Trường Phát Triển Java

Để có thể biên dịch và chạy các chương trình Java, bạn cần cài đặt Java Development Kit (JDK). JDK cung cấp các công cụ cần thiết như trình biên dịch Java (javac) và môi trường thực thi Java (JRE - Java Runtime Environment).

Thiết Lập Biến Môi Trường PATH

Biến môi trường PATH cho phép bạn thực thi các lệnh từ JDK (như javac và java) từ bất kỳ thư mục nào trong hệ thống, mà không cần phải chỉ định đường dẫn đầy đủ đến các công cụ này. Điều này giúp tăng cường tiện ích và hiệu quả khi làm việc với dòng lệnh.

2. Chương Trình Java Đầu Tiên

Dưới đây là một ví dụ đơn giản về chương trình Java hiển thị "Xin Chào Java" ra màn hình:

public class ChuongTrinhDauTien {
    public static void main(String[] args) {
        System.out.println("Xin Chào Java!");
    }
}

Để biên dịch và thực thi chương trình này, bạn cần làm theo các bước sau:

  1. Lưu mã trên vào một tệp có tên ChuongTrinhDauTien.java.
  2. Mở cửa sổ dòng lệnh (CMD hoặc Terminal).
  3. Di chuyển đến thư mục chứa tệp ChuongTrinhDauTien.java.
  4. Biên dịch: Sử dụng lệnh javac để biên dịch mã nguồn Java thành bytecode. Bytecode được lưu trong một tệp .class. 
    javac ChuongTrinhDauTien.java

    Sau khi biên dịch thành công, một tệp ChuongTrinhDauTien.class sẽ được tạo trong cùng thư mục.

  5. Thực thi: Sử dụng lệnh java để chạy tệp bytecode. Lưu ý không cần thêm phần mở rộng .class khi thực thi. 
    java ChuongTrinhDauTien

    Kết quả hiển thị trên màn hình sẽ là: Xin Chào Java!

3. Cú Pháp Cơ Bản Java

Chú Thích (Comments)

Chú thích được sử dụng để giải thích mã nguồn, giúp người đọc (bao gồm cả chính bạn trong tương lai) dễ dàng hiểu được mục đích của các phần mã. Trình biên dịch Java sẽ bỏ qua các chú thích.

  • Chú thích một dòng: Bắt đầu bằng //. 
    public class ViDuChuThich {
    public static void main(String[] args) {
        // Đây là một chú thích một dòng, giải thích câu lệnh tiếp theo
        System.out.println("Java rất thú vị!"); 
    }
}
  • Chú thích nhiều dòng: Bắt đầu bằng /* và kết thúc bằng */. 
    /*
 * Đây là một ví dụ về chú thích nhiều dòng.
 * Nó có thể bao phủ nhiều dòng mã
 * để cung cấp giải thích chi tiết hơn.
 */
public class ViDuChuThichNhieuDong {
    public static void main(String[] args) {
        System.out.println("Chào mừng đến với Java!");
    }
}
  • Chú thích tài liệu (Javadoc): Bắt đầu bằng /** và kết thúc bằng */. Được sử dụng để tạo tài liệu API tự động. 
    /**
 * Lớp này thể hiện một ví dụ đơn giản về chú thích Javadoc.
 * Nó được sử dụng để tạo tài liệu API.
 * @author Tác Giả Mẫu
 * @version 1.0
 */
public class ViDuJavadoc {
    /**
     * Phương thức chính để bắt đầu chương trình.
     * @param args Các đối số dòng lệnh.
     */
    public static void main(String[] args) {
        System.out.println("Học Javadoc!");
    }
}

Từ Khóa (Keywords)

Từ khóa là những từ có ý nghĩa đặc biệt đối với trình biên dịch Java và được dành riêng cho các mục đích cụ thể. Chúng không thể được sử dụng làm tên cho biến, phương thức, lớp, v.v.

  • Đặc điểm:
    • Tất cả các chữ cái của từ khóa đều là chữ thường.
    • Các trình soạn thảo mã thường hiển thị từ khóa với màu sắc đặc biệt để dễ nhận biết.
  • Ví dụ: public, class, static, void, int, if, else, for, while, new, true, false, null.

Giá Trị Hằng (Literals)

Giá trị hằng là cách biểu diễn trực tiếp các giá trị dữ liệu trong mã nguồn.

  • Số nguyên (Integer Literals): Các số không có phần thập phân.
    • Thập phân: 100
    • Nhị phân (bắt đầu bằng 0b): 0b1101 (tương đương 13)
    • Bát phân (bắt đầu bằng 0): 015 (tương đương 13)
    • Thập lục phân (bắt đầu bằng 0x): 0xD (tương đương 13)
  • Số thực (Floating-point Literals): Các số có phần thập phân.
    • 3.14 (kiểu double mặc định)
    • 2.5f (kiểu float, cần hậu tố f hoặc F)
  • Chuỗi (String Literals): Các ký tự được đặt trong dấu ngoặc kép " ".
    • "Chào thế giới!"
    • "Đây là một chuỗi."
  • Ký tự (Character Literals): Một ký tự duy nhất được đặt trong dấu ngoặc đơn ' '.
    • 'A'
    • '1'
    • '#'
    • Ký tự đặc biệt: '\n' (xuống dòng), '\t' (tab - căn chỉnh đầu dòng thành bội số của 8).
  • Boolean Literals: Biểu diễn giá trị đúng/sai.
    • true
    • false
  • Null Literal: Biểu diễn sự vắng mặt của một giá trị.
    • null (không thể in trực tiếp null như một giá trị chuỗi thông thường, nhưng có thể gán cho biến đối tượng và in biến đó).

Biến (Variables)

Biến là một vùng nhớ được đặt tên trong bộ nhớ máy tính để lưu trữ dữ liệu. Giá trị của biến có thể thay đổi trong quá trình thực thi chương trình.

KieuDuLieu tenBien = giaTriKhoiTao;
  • Mỗi biến chỉ có thể lưu trữ một giá trị tại một thời điểm.
  • Tên biến không được trùng lặp trong cùng một phạm vi.
  • Có thể khai báo nhiều biến cùng kiểu trên một dòng (ví dụ: int a, b, c = 10;).
  • Biến phải được gán giá trị trước khi sử dụng.
  • Mỗi biến có một phạm vi (scope) nhất định, xác định nơi có thể truy cập biến đó.
public class ViDuBien {
    public static void main(String[] args) {
        int tuoi = 30; // Khai báo và khởi tạo biến 'tuoi' kiểu int
        String ten = "Nguyễn Văn A"; // Biến 'ten' kiểu String
        double chieuCao = 1.75; // Biến 'chieuCao' kiểu double
        boolean dangHoc = true; // Biến 'dangHoc' kiểu boolean

        System.out.println("Tên: " + ten);
        System.out.println("Tuổi: " + tuoi);
        System.out.println("Chiều cao: " + chieuCao + "m");
        System.out.println("Đang học: " + dangHoc);

        tuoi = 31; // Gán lại giá trị cho biến 'tuoi'
        System.out.println("Tuổi mới: " + tuoi);
    }
}

4. Kiểu Dữ Liệu

Java là một ngôn ngữ có kiểu dữ liệu mạnh mẽ (strongly typed), nghĩa là mọi biến phải được khai báo với một kiểu dữ liệu cụ thể. Java phân biệt hai loại kiểu dữ liệu chính: kiểu nguyên thủy (primitive) và kiểu tham chiếu (reference).

Kiểu Dữ Liệu Nguyên Thủy (Primitive Data Types)

Đây là các kiểu dữ liệu cơ bản, không phải là đối tượng.

Loại Dữ Liệu Từ Khóa Khoảng Giá Trị Kích Thước (bytes)
Số nguyên byte -128 đến 127 1
short -32,768 đến 32,767 2
int (mặc định) -2,147,483,648 đến 2,147,483,647 4
long -9,223,372,036,854,775,808 đến 9,223,372,036,854,775,807 8
Số thực float Khoảng ±3.4e-38 đến ±3.4e+38 (xấp xỉ 7 chữ số thập phân) 4
double (mặc định) Khoảng ±4.9e-324 đến ±1.8e+308 (xấp xỉ 15 chữ số thập phân) 8
Ký tự char 0 đến 65,535 (ký tự Unicode) 2
Boolean boolean true hoặc false 1

Lưu ý:

  • Khi khai báo biến kiểu long, cần thêm hậu tố L (hoặc l) vào giá trị số: long soLon = 10000000000L;
  • Khi khai báo biến kiểu float, cần thêm hậu tố F (hoặc f) vào giá trị số: float giaTien = 19.99F;

5. Định Danh (Identifiers)

Định danh là tên được sử dụng để đặt cho các thành phần trong chương trình như lớp, phương thức, biến, v.v.

  • Quy tắc đặt tên:
    • Có thể chứa chữ cái (A-Z, a-z), chữ số (0-9), dấu gạch dưới (_) và ký hiệu đô la ($).
    • Không được bắt đầu bằng chữ số.
    • Không được sử dụng từ khóa của Java.
    • Phân biệt chữ hoa và chữ thường (ví dụ: tenBien và TenBien là hai biến khác nhau).
  • Quy ước đặt tên (Java Naming Conventions):
    • Kiểu lạc đà nhỏ (lowerCamelCase): Dùng cho tên biến và phương thức. Từ đầu tiên viết thường, các từ tiếp theo viết hoa chữ cái đầu. 
      String hoVaTen;
int soLuongSanPham;
void tinhTongGiaTri();
    • Kiểu lạc đà lớn (UpperCamelCase / PascalCase): Dùng cho tên lớp và giao diện. Mỗi từ đều viết hoa chữ cái đầu. 
      class SinhVien;
class QuanLyDonHang;
    • Chữ hoa toàn bộ với gạch dưới: Dùng cho các hằng số. 
      final int MAX_SIZE = 100;
final String APP_VERSION = "1.0.0";

6. Nhập Dữ Liệu Từ Bàn Phím (Scanner)

Lớp Scanner trong gói java.util cho phép đọc dữ liệu nhập từ bàn phím hoặc các nguồn khác.

  1. Import lớp Scanner: 
    import java.util.Scanner;
  2. Tạo đối tượng Scanner: 
    Scanner input = new Scanner(System.in);

    System.in đại diện cho luồng nhập liệu chuẩn (bàn phím).

  3. Đọc dữ liệu:
    • input.nextInt(): Đọc một số nguyên.
    • input.nextDouble(): Đọc một số thực.
    • input.next(): Đọc một từ (chuỗi không chứa khoảng trắng).
    • input.nextLine(): Đọc toàn bộ dòng (chuỗi có chứa khoảng trắng).
import java.util.Scanner;

public class NhapDuLieu {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Vui lòng nhập tên của bạn: ");
        String tenNguoiDung = input.nextLine();

        System.out.print("Vui lòng nhập tuổi của bạn: ");
        int tuoiNguoiDung = input.nextInt();

        System.out.println("Xin chào, " + tenNguoiDung + "! Bạn " + tuoiNguoiDung + " tuổi.");
        
        input.close(); // Đóng Scanner khi không còn sử dụng
    }
}

Ví dụ: Tổng hai số nguyên nhập từ bàn phím

import java.util.Scanner;

public class TinhTongHaiSo {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Nhập số nguyên thứ nhất: ");
        int soThuNhat = input.nextInt();

        System.out.print("Nhập số nguyên thứ hai: ");
        int soThuHai = input.nextInt();

        int tong = soThuNhat + soThuHai;
        System.out.println("Tổng của hai số là: " + tong);
        
        input.close();
    }
}

7. Tổng Quan về IntelliJ IDEA

IntelliJ IDEA là một Môi trường Phát triển Tích hợp (IDE) mạnh mẽ và phổ biến cho lập trình Java. Nó cung cấp nhiều tính năng giúp tăng năng suất phát triển.

Cấu trúc Dự án trong IDEA

  • Project (Dự án): Là container cấp cao nhất, chứa tất cả các mã nguồn, thư viện, tài nguyên và cấu hình.
  • Module (Module): Một dự án có thể chứa nhiều module. Mỗi module thường là một thành phần chức năng riêng biệt hoặc một ứng dụng con.
  • Package (Gói): Dùng để tổ chức các lớp (class) có liên quan. Các gói giúp tránh xung đột tên và quản lý mã nguồn tốt hơn.
  • Class (Lớp): Đơn vị cơ bản của chương trình Java, nơi chứa mã thực thi.

Các Phím Tắt Hữu Ích

  • psvm + Tab: Tự động tạo phương thức public static void main(String[] args).
  • sout + Tab: Tự động tạo câu lệnh System.out.println().

8. Toán Tử (Operators)

Toán tử là các ký hiệu đặc biệt dùng để thực hiện các phép toán trên các giá trị (literals) hoặc biến.

8.1. Toán Tử Số Học (Arithmetic Operators)

Toán Tử Mô Tả Ví Dụ
+ Cộng 5 + 3 kết quả là 8
- Trừ 10 - 4 kết quả là 6
* Nhân 6 * 2 kết quả là 12
/ Chia 10 / 3 kết quả là 3 (chia số nguyên)
% Chia lấy dư (Modulo) 10 % 3 kết quả là 1

Lưu ý về phép chia:

  • Khi cả hai toán hạng là số nguyên, phép chia sẽ trả về phần nguyên của kết quả. Ví dụ: 10 / 3 cho kết quả 3.
  • Để nhận được kết quả thập phân chính xác, ít nhất một trong các toán hạng phải là số thực. Ví dụ: 10.0 / 3 cho kết quả 3.333....
public class ToanTuSoHoc {
    public static void main(String[] args) {
        System.out.println("10 / 3 = " + (10 / 3));      // Kết quả: 3
        System.out.println("10.0 / 3 = " + (10.0 / 3));  // Kết quả: 3.3333333333333335
        System.out.println("10 % 3 = " + (10 % 3));      // Kết quả: 1
    }
}

Bài tập: Tách số có ba chữ số

Viết chương trình nhập vào một số nguyên có ba chữ số, sau đó tách nó thành hàng trăm, hàng chục và hàng đơn vị.

import java.util.Scanner;

public class TachSoBaChuSo {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Vui lòng nhập một số nguyên có ba chữ số: ");
        int soNguyen = input.nextInt(); // Ví dụ: 456

        int hangDonVi = soNguyen % 10;     // 456 % 10 = 6
        int hangChuc = (soNguyen / 10) % 10; // (456 / 10) = 45 -> 45 % 10 = 5
        int hangTram = soNguyen / 100;    // 456 / 100 = 4

        System.out.println("Số đã nhập: " + soNguyen);
        System.out.println("Chữ số hàng đơn vị: " + hangDonVi);
        System.out.println("Chữ số hàng chục: " + hangChuc);
        System.out.println("Chữ số hàng trăm: " + hangTram);
        
        input.close();
    }
}

8.2. Chuyển Đổi Kiểu Dữ Liệu và Toán Tử '+'

Chuyển Đổi Kiểu Dữ Liệu (Type Conversion)

Trong Java, khi các kiểu dữ liệu khác nhau tham gia vào một phép toán, sẽ có quá trình chuyển đổi kiểu dữ liệu xảy ra.

  • Chuyển đổi ngầm định (Implicit Conversion / Widening Conversion):

    Xảy ra tự động khi chuyển đổi từ kiểu dữ liệu có phạm vi nhỏ sang kiểu dữ liệu có phạm vi lớn hơn. Không có nguy cơ mất dữ liệu.

    Thứ tự chuyển đổi: byte → short → int → long → float → double.

    Quy tắc đặc biệt: Khi các toán hạng byte, short, char tham gia phép toán số học, chúng sẽ tự động được nâng cấp lên int trước khi thực hiện phép toán.

    public class ChuyenDoiNgamDinh {
    public static void main(String[] args) {
        int soNguyen = 10;
        double soThuc = 12.3;
        double ketQua = soNguyen + soThuc; // int tự động chuyển thành double
        System.out.println("Kết quả: " + ketQua); // Kết quả: 22.3

        byte giaTriByte1 = 10;
        byte giaTriByte2 = 20;
        // byte ketQuaByte = giaTriByte1 + giaTriByte2; // Lỗi biên dịch: int cannot be converted to byte
        int ketQuaInt = giaTriByte1 + giaTriByte2; // byte tự động chuyển thành int
        System.out.println("Kết quả int: " + ketQuaInt); // Kết quả int: 30
    }
}
  • Chuyển đổi tường minh (Explicit Conversion / Narrowing Conversion):

    Xảy ra khi chuyển đổi từ kiểu dữ liệu có phạm vi lớn sang kiểu dữ liệu có phạm vi nhỏ hơn. Cần chỉ định rõ ràng bằng cách đặt kiểu dữ liệu mục tiêu trong dấu ngoặc đơn (). Có nguy cơ mất dữ liệu nếu giá trị vượt quá phạm vi của kiểu dữ liệu mới.

    public class ChuyenDoiTuongMinh {
    public static void main(String[] args) {
        int soNguyenLon = 200;
        byte soNguyenNho = (byte) soNguyenLon; // Chuyển int sang byte
        System.out.println("Kết quả (200): " + soNguyenNho); // Kết quả: -56 (mất dữ liệu do byte max 127)

        double soThucLon = 3.14;
        int soNguyenTuThuc = (int) soThucLon; // Chuyển double sang int (mất phần thập phân)
        System.out.println("Kết quả (3.14): " + soNguyenTuThuc); // Kết quả: 3
    }
}

Toán Tử '+' với các kiểu dữ liệu khác nhau

  • Cộng số học: Khi cả hai toán hạng đều là số (bao gồm cả ký tự được chuyển sang giá trị ASCII). 
    System.out.println(10 + 20);     // 30
System.out.println(1 + 'a');    // 1 + 97 = 98 (giá trị ASCII của 'a' là 97)
  • Nối chuỗi: Khi có ít nhất một toán hạng là chuỗi, toán tử + sẽ hoạt động như toán tử nối chuỗi (string concatenation). Nó sẽ chuyển đổi các toán hạng không phải chuỗi thành chuỗi và nối chúng lại.

    Các phép toán + liên tiếp sẽ được thực hiện từ trái sang phải.

    System.out.println("Xin chào " + "thế giới"); // "Xin chào thế giới"
System.out.println("Số: " + 123);           // "Số: 123"
System.out.println(true + " là đúng");      // "true là đúng"
System.out.println(1 + 2 + "ABC" + 3 + 4);  // (1+2) -> 3 -> "3ABC" -> "3ABC3" -> "3ABC34"
// Kết quả: "3ABC34"

8.3. Toán Tử Tăng/Giảm (Increment/Decrement Operators)

Toán Tử Mô Tả Ví Dụ
++ Tăng giá trị của biến lên 1 a++ hoặc ++a
-- Giảm giá trị của biến đi 1 a-- hoặc --a

Phân biệt tiền tố và hậu tố:

  • Tiền tố (Prefix): ++a hoặc --a. Giá trị của biến được thay đổi TRƯỚC khi sử dụng trong biểu thức.
  • Hậu tố (Postfix): a++ hoặc a--. Giá trị của biến được sử dụng TRƯỚC khi thay đổi trong biểu thức.
public class ToanTuTangGiam {
    public static void main(String[] args) {
        int soA = 10;
        int soB = soA++; // soB = 10 (giá trị cũ của soA), sau đó soA tăng lên 11
        int soC = ++soA; // soA tăng lên 12, sau đó soC = 12 (giá trị mới của soA)

        System.out.println("soA: " + soA); // 12
        System.out.println("soB: " + soB); // 10
        System.out.println("soC: " + soC); // 12
    }
}

8.4. Toán Tử Gán (Assignment Operators)

Toán Tử Mô Tả Ví Dụ Tương Đương
= Gán giá trị x = 5;
+= Cộng và gán x += 3; x = x + 3;
-= Trừ và gán x -= 2; x = x - 2;
*= Nhân và gán x *= 4; x = x * 4;
/= Chia và gán x /= 2; x = x / 2;
%= Chia lấy dư và gán x %= 3; x = x % 3;

Lưu ý quan trọng: Các toán tử gán kết hợp (+=, -=, v.v.) tự động thực hiện ép kiểu ngầm định nếu cần thiết. Điều này có thể ngăn chặn lỗi biên dịch mà bạn gặp phải với phép cộng thông thường.

public class ToanTuGan {
    public static void main(String[] args) {
        int bienX = 10;
        bienX += 5; // Tương đương: bienX = (int)(bienX + 5);
        System.out.println("bienX sau +=: " + bienX); // 15

        short bienS = 1;
        // bienS = bienS + 1; // Lỗi biên dịch: int cannot be converted to short
        bienS += 1; // OK, tự động ép kiểu: bienS = (short)(bienS + 1);
        System.out.println("bienS sau +=: " + bienS); // 2
    }
}

8.5. Toán Tử Quan Hệ (Relational Operators / Comparison Operators)

Dùng để so sánh hai giá trị và trả về một giá trị boolean (true hoặc false).

Toán Tử Mô Tả Ví Dụ
== Bằng a == b
!= Không bằng a != b
> Lớn hơn a > b
< Nhỏ hơn a < b
>= Lớn hơn hoặc bằng a >= b
<= Nhỏ hơn hoặc bằng a <= b

8.6. Toán Tử Logic (Logical Operators)

Dùng để kết hợp hoặc nghịch đảo các biểu thức boolean.

Toán Tử Mô Tả Ví Dụ
&& AND logic (short-circuit) (A > 0) && (B < 10)
|| OR logic (short-circuit) (A == 5) || (B == 7)
! NOT logic !(A > B)
& AND logic (không short-circuit) (A > 0) & (B < 10)
| OR logic (không short-circuit) (A == 5) | (B == 7)

Short-circuiting (Ngắt mạch):

  • Với && (AND): Nếu biểu thức bên trái là false, biểu thức bên phải sẽ không được đánh giá, vì kết quả cuối cùng chắc chắn là false.
  • Với || (OR): Nếu biểu thức bên trái là true, biểu thức bên phải sẽ không được đánh giá, vì kết quả cuối cùng chắc chắn là true.
  • Các toán tử & và | (phi-short-circuit) luôn đánh giá cả hai biểu thức, bất kể giá trị của biểu thức đầu tiên.
public class ToanTuLogic {
    public static void main(String[] args) {
        int giaTriX = 10;
        int giaTriY = 10;

        // Ví dụ short-circuit &&
        boolean ketQuaAnd = (giaTriX++ < 5) && (giaTriY++ < 5); 
        // giaTriX++ < 5 là false, nên (giaTriY++ < 5) không được đánh giá
        System.out.println("Kết quả &&: " + ketQuaAnd); // false
        System.out.println("giaTriX: " + giaTriX);     // 11 (đã tăng)
        System.out.println("giaTriY: " + giaTriY);     // 10 (không tăng)

        giaTriX = 10; // Reset
        giaTriY = 10; // Reset
        // Ví dụ short-circuit ||
        boolean ketQuaOr = (giaTriX++ > 5) || (giaTriY++ < 5);
        // giaTriX++ > 5 là true, nên (giaTriY++ < 5) không được đánh giá
        System.out.println("Kết quả ||: " + ketQuaOr); // true
        System.out.println("giaTriX: " + giaTriX);     // 11 (đã tăng)
        System.out.println("giaTriY: " + giaTriY);     // 10 (không tăng)
    }
}

Bài tập: Số 6 may mắn

Nhập vào hai số nguyên. In ra true nếu một trong hai số là 6, hoặc nếu tổng của chúng chia hết cho 6. Ngược lại, in ra false.

import java.util.Scanner;

public class SoSauMayMan {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Nhập số thứ nhất: ");
        int soMot = input.nextInt();
        System.out.print("Nhập số thứ hai: ");
        int soHai = input.nextInt();

        boolean dieuKien = (soMot == 6) || (soHai == 6) || ((soMot + soHai) % 6 == 0);
        System.out.println("Kết quả: " + dieuKien);
        
        input.close();
    }
}

8.7. Toán Tử Ba Ngôi (Ternary Operator)

Là một cách viết ngắn gọn cho câu lệnh if-else đơn giản. Có cú pháp:

điều_kiện ? giá_trị_nếu_đúng : giá_trị_nếu_sai;
public class ToanTuBaNgoi {
    public static void main(String[] args) {
        int diem = 75;
        String ketQua = (diem >= 50) ? "Đậu" : "Rớt";
        System.out.println("Bạn đã: " + ketQua); // "Đậu"

        int soLonNhat = (10 > 20) ? 10 : 20;
        System.out.println("Số lớn nhất là: " + soLonNhat); // 20
    }
}

8.8. Thứ Tự Ưu Tiên của Toán Tử (Operator Precedence)

Trong một biểu thức phức tạp, các toán tử được đánh giá theo một thứ tự ưu tiên nhất định. Các toán tử có độ ưu tiên cao hơn sẽ được thực hiện trước. Có thể sử dụng dấu ngoặc đơn () để thay đổi thứ tự ưu tiên mặc định.

Ví dụ: *, /, % có độ ưu tiên cao hơn +, -.

int ketQua = 5 + 2 * 3; // Kết quả là 11 (2 * 3 = 6, sau đó 5 + 6 = 11)
int ketQuaKhac = (5 + 2) * 3; // Kết quả là 21 ((5 + 2) = 7, sau đó 7 * 3 = 21)

Thẻ: Java LậpTrìnhCơBản CúPhápJava KiểuDữLiệuJava ToánTửJava

Đăng vào ngày 30 tháng 7 lúc 02:10

Thẻ Phổ Biến

©2026 Thành phố Cuồng loạn