Các toán tử số học (Arithmetic Operators) trong Kotlin

1. Giới thiệu

Các toán tử số học trong Kotlin tương tự như Python và hầu hết các ngôn ngữ lập trình khác. Kotlin cung cấp các toán tử cơ bản để thực hiện các phép tính toán học.

2. Các toán tử số học cơ bản

Toán tử	Tên	Ví dụ	Kết quả
`+`	Cộng	`10 + 5`	`15`
`-`	Trừ	`10 - 5`	`5`
`*`	Nhân	`10 * 5`	`50`
`/`	Chia	`10 / 5`	`2`
`%`	Chia lấy dư (modulo)	`10 % 3`	`1`

2.1. Phép cộng (`+`)


val a = 10
val b = 5
val sum = a + b
println(sum)  // 15
 
// Với số thực
val x = 3.5
val y = 2.5
println(x + y)  // 6.0

2.2. Phép trừ (`-`)


val a = 10
val b = 5
val difference = a - b
println(difference)  // 5
 
// Số âm
val negative = -10
println(negative)  // -10

2.3. Phép nhân (`*`)


val a = 10
val b = 5
val product = a * b
println(product)  // 50
 
// Nhân với số thực
val price = 99.99
val quantity = 3
println(price * quantity)  // 299.97

2.4. Phép chia (`/`)


// Chia số nguyên
val a = 10
val b = 3
println(a / b)  // 3 (kết quả là số nguyên)
 
// Chia số thực
val x = 10.0
val y = 3.0
println(x / y)  // 3.3333333333333335
 
// Hoặc ép kiểu
println(a.toDouble() / b)  // 3.3333333333333335

Lưu ý quan trọng:

Chia hai số nguyên Int luôn cho kết quả Int
Để có kết quả thập phân, ít nhất một trong hai số phải là Double hoặc Float

2.5. Phép chia lấy dư (`%`)


println(10 % 3)   // 1
println(15 % 4)   // 3
println(20 % 5)   // 0
println(7 % 2)    // 1 (số lẻ)
 
// Kiểm tra số chẵn/lẻ
val number = 17
if (number % 2 == 0) {
    println("$number là số chẵn")
} else {
    println("$number là số lẻ")
}

3. Thứ tự ưu tiên của toán tử

Giống như toán học, Kotlin tuân theo quy tắc ưu tiên:

() - Ngoặc đơn (cao nhất)
*, /, % - Nhân, chia, chia lấy dư
+, - - Cộng, trừ (thấp nhất)


val result1 = 2 + 3 * 4      // 14 (nhân trước, cộng sau)
val result2 = (2 + 3) * 4    // 20 (ngoặc được tính trước)
 
val result3 = 10 + 5 * 2 - 3  // 17
// Thứ tự: 5 * 2 = 10, 10 + 10 = 20, 20 - 3 = 17

4. Toán tử gán và toán tử gán phức hợp

4.1. Toán tử gán (`=`)


var x = 10
x = 20  // Gán giá trị mới

4.2. Toán tử gán phức hợp

Toán tử	Tương đương	Ví dụ
`+=`	`x = x + y`	`x += 5`
`-=`	`x = x - y`	`x -= 5`
`*=`	`x = x * y`	`x *= 5`
`/=`	`x = x / y`	`x /= 5`
`%=`	`x = x % y`	`x %= 5`


var count = 10
 
count += 5   // count = 15
count -= 3   // count = 12
count *= 2   // count = 24
count /= 4   // count = 6
count %= 4   // count = 2
 
println(count)  // 2

5. Toán tử tăng/giảm (Increment/Decrement)

5.1. Toán tử tăng (`++`)


var x = 5
 
// Prefix increment (tăng trước)
println(++x)  // 6 (tăng rồi mới in)
println(x)    // 6
 
// Postfix increment (tăng sau)
var y = 5
println(y++)  // 5 (in rồi mới tăng)
println(y)    // 6

5.2. Toán tử giảm (`--`)


var x = 5
 
// Prefix decrement
println(--x)  // 4
 
// Postfix decrement
var y = 5
println(y--)  // 5
println(y)    // 4

Ví dụ thực tế:


var lives = 3
 
// Mất mạng
lives--
println("Còn $lives mạng")  // Còn 2 mạng
 
// Cộng mạng
lives++
println("Còn $lives mạng")  // Còn 3 mạng

6. Toán tử Unary (Một ngôi)

Toán tử	Ý nghĩa	Ví dụ
`+x`	Unary plus	`+5` = `5`
`-x`	Unary minus	`-5` = `-5`
`++x`	Prefix increment	`++x`
`--x`	Prefix decrement	`--x`
`x++`	Postfix increment	`x++`
`x--`	Postfix decrement	`x--`


val positive = +10   // 10
val negative = -10   // -10
 
val x = 5
val y = -x          // -5
val z = +x          // 5

7. Làm việc với các kiểu số khác nhau

7.1. Chuyển đổi kiểu khi tính toán


val intValue: Int = 10
val longValue: Long = 20L
 
// Phải chuyển đổi kiểu tường minh
val sum = intValue.toLong() + longValue  // OK
// val sum = intValue + longValue  // Lỗi!
 
val doubleValue: Double = 3.14
val result = intValue.toDouble() + doubleValue  // OK

7.2. Ép kiểu tự động trong biểu thức


val a = 10      // Int
val b = 20L     // Long
val c = 3.14    // Double
 
// Kotlin tự động chọn kiểu "lớn nhất"
val result1 = a + b.toInt()  // Int
val result2 = a.toLong() + b // Long
val result3 = a + c          // Lỗi! Phải ép kiểu

8. Các hàm toán học hữu ích

Kotlin cung cấp các hàm toán học trong kotlin.math:


import kotlin.math.*
 
// Giá trị tuyệt đối
println(abs(-10))          // 10
 
// Lũy thừa
println(2.0.pow(3.0))      // 8.0
 
// Căn bậc hai
println(sqrt(16.0))        // 4.0
 
// Làm tròn
println(ceil(3.2))         // 4.0
println(floor(3.8))        // 3.0
println(round(3.5))        // 4.0
 
// Min, Max
println(max(10, 20))       // 20
println(min(10, 20))       // 10
 
// Trigonometry
println(sin(PI / 2))       // 1.0
println(cos(0.0))          // 1.0

9. Ví dụ thực tế

Ví dụ 1: Tính tổng tiền mua hàng


fun main() {
    val pricePerItem = 25000  // VNĐ
    val quantity = 3
    val discount = 10000      // VNĐ
 
    val subtotal = pricePerItem * quantity
    val total = subtotal - discount
 
    println("Đơn giá: ${pricePerItem} VNĐ")
    println("Số lượng: $quantity")
    println("Tạm tính: ${subtotal} VNĐ")
    println("Giảm giá: ${discount} VNĐ")
    println("Tổng cộng: ${total} VNĐ")
}

Ví dụ 2: Tính điểm trung bình


fun main() {
    val math = 8.5
    val physics = 7.0
    val chemistry = 9.0
 
    val average = (math + physics + chemistry) / 3
    println("Điểm trung bình: %.2f".format(average))
}

Ví dụ 3: Chuyển đổi nhiệt độ


fun celsiusToFahrenheit(celsius: Double): Double {
    return celsius * 9.0 / 5.0 + 32.0
}
 
fun main() {
    val celsius = 25.0
    val fahrenheit = celsiusToFahrenheit(celsius)
    println("$celsius°C = $fahrenheit°F")
}

10. So sánh với Python

Toán tử	Kotlin	Python	Ghi chú
Chia số nguyên	`/`	`//`	Kotlin: 10/3 = 3, Python: 10//3 = 3
Chia thực	`/`	`/`	Cả hai đều giống nhau với số thực
Lũy thừa	`x.pow(y)`	`x ** y`	Khác nhau
Tăng/giảm	`++`, `--`	Không có	Python không có `++`, `--`

📝 Tóm tắt

Toán tử cơ bản: +, -, *, /, %
Thứ tự ưu tiên: () > *, /, % > +, -
Toán tử gán phức hợp: +=, -=, *=, /=, %=
Tăng/giảm: ++, -- (prefix và postfix)
Chia số nguyên: Kết quả là số nguyên
Chuyển đổi kiểu: Phải tường minh với toXxx()
Hàm toán học: abs(), pow(), sqrt(), max(), min()