Bài 11. Những Phép Toán Cơ Bản Trong Java | Tự Học Java Căn Bản

Published on
Thuộc danh mục: Học Java Căn Bản|Đăng bởi: Lê Thanh Giang||8 min read
Facebook share iconLinkedIn share iconTwitter share iconPinterest share iconTumblr share icon
Bài 11. Các Phép Toán Cơ Bản Trong Java | Tự Học Java Căn Bản

Trong Java, các phép toán cơ bản là những phép toán cơ bản mà bạn sẽ sử dụng để thực hiện các tính toán trong các chương trình. Java cung cấp nhiều loại phép toán để làm việc với các giá trị số, chuỗi, và các đối tượng khác. Trong bài viết này, chúng ta sẽ tìm hiểu về các loại phép toán cơ bản trong Java, bao gồm:

  • Phép toán số học (Arithmetic operators)
  • Phép toán so sánh (Relational operators)
  • Phép toán logic (Logical operators)
  • Phép toán gán (Assignment operators)
  • Phép toán tăng giảm (Increment and Decrement operators)
  • Phép toán bitwise (Bitwise operators)

Phép Toán Số Học (Arithmetic Operators)

Phép toán số học là các phép toán thực hiện các phép tính cơ bản như cộng, trừ, nhân, chia, và lấy phần dư. Trong Java, các phép toán số học sử dụng các ký hiệu sau:

Phép toánKý hiệuMô tả
Cộng+Cộng hai số với nhau
Trừ-Trừ hai số
Nhân*Nhân hai số
Chia/Chia hai số
Lấy phần dư%Lấy phần dư khi chia

Ví dụ:

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        System.out.println("Cộng: " + (a + b));  // 10 + 5 = 15
        System.out.println("Trừ: " + (a - b));   // 10 - 5 = 5
        System.out.println("Nhân: " + (a * b));  // 10 * 5 = 50
        System.out.println("Chia: " + (a / b));  // 10 / 5 = 2
        System.out.println("Lấy phần dư: " + (a % b));  // 10 % 5 = 0
    }
}

Kết quả khi chạy chương trình trên sẽ là:

Cộng: 15
Trừ: 5
Nhân: 50
Chia: 2
Lấy phần dư: 0

Phép Toán So Sánh (Relational Operators)

Phép toán so sánh được sử dụng để so sánh các giá trị và trả về kết quả là true hoặc false. Các phép toán so sánh trong Java bao gồm:

Phép toánKý hiệuMô tả
Bằng==Kiểm tra nếu hai giá trị bằng nhau
Khác!=Kiểm tra nếu hai giá trị không bằng nhau
Lớn hơn>Kiểm tra nếu giá trị bên trái lớn hơn giá trị bên phải
Nhỏ hơn < Kiểm tra nếu giá trị bên trái nhỏ hơn giá trị bên phải
Lớn hơn hoặc bằng>=Kiểm tra nếu giá trị bên trái lớn hơn hoặc bằng giá trị bên phải
Nhỏ hơn hoặc bằng<=Kiểm tra nếu giá trị bên trái nhỏ hơn hoặc bằng giá trị bên phải

Ví dụ:

public class RelationalOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        System.out.println("a == b: " + (a == b));  // false
        System.out.println("a != b: " + (a != b));  // true
        System.out.println("a > b: " + (a > b));    // true
        System.out.println("a < b: " + (a < b));    // false
        System.out.println("a >= b: " + (a >= b));  // true
        System.out.println("a <= b: " + (a <= b));  // false
    }
}

Kết quả khi chạy chương trình trên sẽ là:

a == b: false
a != b: true
a > b: true
a < b: false
a >= b: true
a <= b: false

Phép Toán Logic (Logical Operators)

Phép toán logic được sử dụng để thực hiện các phép toán với các giá trị boolean (true hoặc false). Java cung cấp ba phép toán logic cơ bản:

Phép toánKý hiệuMô tả
AND&&Kết quả là true nếu cả hai biểu thức đều true
OR||Kết quả là true nếu ít nhất một biểu thức là true
NOT!Đảo ngược giá trị boolean (true thành false và ngược lại)

Ví dụ:

public class LogicalOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b: " + (a && b));  // false
        System.out.println("a || b: " + (a || b));  // true
        System.out.println("!a: " + !a);             // false
    }
}

Kết quả khi chạy chương trình trên sẽ là:

a && b: false
a || b: true
!a: false

Phép Toán Gán (Assignment Operators)

Phép toán gán được sử dụng để gán giá trị cho một biến. Java hỗ trợ một số phép toán gán đặc biệt, bao gồm:

Phép toánKý hiệuMô tả
Gán=Gán giá trị cho biến
Gán cộng+=Gán giá trị cộng với giá trị hiện tại
Gán trừ-=Gán giá trị trừ với giá trị hiện tại
Gán nhân*=Gán giá trị nhân với giá trị hiện tại
Gán chia/=Gán giá trị chia với giá trị hiện tại
Gán phần dư%=Gán phần dư của giá trị với giá trị hiện tại

Ví dụ

public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        a += 5;  // a = a + 5
        System.out.println("a += 5: " + a);  // 15

        a -= 3;  // a = a - 3
        System.out.println("a -= 3: " + a);  // 12

        a *= 2;  // a = a * 2
        System.out.println("a *= 2: " + a);  // 24

        a /= 4;  // a = a / 4
        System.out.println("a /= 4: " + a);  // 6
    }
}

Kết quả khi chạy chương trình trên sẽ là:

a += 5: 15
a -= 3: 12
a *= 2: 24
a /= 4: 6

Phép Toán Tăng Giảm (Increment and Decrement Operators)

Phép toán tăng và giảm được sử dụng để thay đổi giá trị của một biến với đơn vị là 1. Java cung cấp hai phép toán tăng giảm:

Phép toánKý hiệuMô tả
Tăng đơn (tiền tố)++aTăng giá trị của a lên 1 trước khi sử dụng
Tăng đơn (hậu tố)a++Tăng giá trị của a lên 1 sau khi sử dụng
Giảm đơn (tiền tố)--aGiảm giá trị của a xuống 1 trước khi sử dụng
Giảm đơn (hậu tố)a--Giảm giá trị của a xuống 1 sau khi sử dụng

Ví dụ:

public class IncrementDecrementOperators {
    public static void main(String[] args) {
        int a = 5;

        System.out.println("++a: " + (++a));  // Tăng trước, a = 6
        System.out.println("a++: " + (a++));  // Tăng sau, a = 6, nhưng giá trị là 6
        System.out.println("a: " + a);        // a = 7

        System.out.println("--a: " + (--a));  // Giảm trước, a = 6
        System.out.println("a--: " + (a--));  // Giảm sau, a = 6, nhưng giá trị là 6
        System.out.println("a: " + a);        // a = 5
    }
}

Kết quả khi chạy chương trình trên sẽ là:

++a: 6
a++: 6
a: 7
--a: 6
a--: 6
a: 5

Phép Toán Bitwise (Bitwise Operators)

Phép toán bitwise được sử dụng để thực hiện các phép toán ở mức độ bit trên các số nguyên. Các phép toán bitwise bao gồm:

Phép toánKý hiệuMô tả
AND bitwise&Phép toán AND giữa các bit
OR bitwise|Phép toán OR giữa các bit
XOR bitwise^Phép toán XOR giữa các bit
NOT bitwise~Đảo ngược tất cả các bit
Dịch trái<<Dịch các bit sang trái (shift left)
Dịch phải>>Dịch các bit sang phải (shift right)

Ví dụ:

public class BitwiseOperators {
    public static void main(String[] args) {
        int a = 5;  // 0101
        int b = 3;  // 0011

        System.out.println("a & b: " + (a & b));  // 0001 -> 1
        System.out.println("a | b: " + (a | b));  // 0111 -> 7
        System.out.println("a ^ b: " + (a ^ b));  // 0110 -> 6
        System.out.println("~a: " + (~a));        // 1010 -> -6
        System.out.println("a << 1: " + (a << 1)); // 1010 -> 10
        System.out.println("a >> 1: " + (a >> 1)); // 0010 -> 2
    }
}

Kết quả khi chạy chương trình trên sẽ là:

a & b: 1
a | b: 7
a ^ b: 6
~a: -6
a << 1: 10
a >> 1: 2

Kết luận

Các phép toán cơ bản trong Java là công cụ quan trọng giúp bạn thực hiện các phép tính toán trong chương trình. Bạn có thể sử dụng các phép toán số học, phép toán so sánh, phép toán logic, và nhiều phép toán khác để xử lý các giá trị và thực hiện các tác vụ trong ứng dụng của mình. Việc hiểu rõ các phép toán này sẽ giúp bạn viết mã hiệu quả và chính xác hơn.

Bài tiếp theo: Bài 12. Các phép toán một ngôi trong lập trình Java

Bài viết mới nhất

Bài viết liên quan

Newsletter border

Đăng ký để nhận tin từ RiverLee