Kotlin cho Android: kiến thức cơ bản về cú pháp và tính năng

Kotlin là gì?

Kotlin là ngôn ngữ lập trình kiểu tĩnh được tạo ra bởi JetBrains (nhà phát triển IntelliJ IDEA) và phát hành năm 2016 dưới giấy phép Apache 2.0. Kotlin biên dịch sang bytecode JVM, JavaScript và mã gốc (qua Kotlin/Native). Các lĩnh vực ứng dụng chính là phát triển Android, ứng dụng máy chủ và các dự án đa nền tảng.

Google đã công bố Kotlin là ngôn ngữ chính thức cho phát triển Android tại Google I/O 2017. Theo Google (Android Developer Blog, 2026), hơn 85% dự án mới trên Google Play sử dụng Kotlin. Ngôn ngữ này cũng được sử dụng tích cực trong phát triển máy chủ (Spring Boot, Ktor) và các dự án đa nền tảng (Kotlin Multiplatform Mobile).

Kotlin hoàn toàn tương thích với Java — bạn có thể gọi mã Java từ Kotlin và ngược lại trong cùng một dự án. Các công cụ xây dựng (Gradle, Maven) hỗ trợ cả hai ngôn ngữ, cho phép di chuyển dần dần từ Java sang Kotlin mà không gián đoạn phát triển.

Tại sao Kotlin phổ biến hơn Java cho Android

Các lý do chính: tính ngắn gọn — Kotlin yêu cầu trung bình ít hơn 40% dòng mã so với Java cho cùng một tác vụ. Null safety — trình biên dịch cấm sử dụng kiểu nullable mà không kiểm tra. Khả năng hàm — hàm bậc cao, lambda, extension functions và coroutines làm cho mã biểu cảm hơn và an toàn hơn.

Kiến thức cơ bản về cú pháp

Cú pháp Kotlin cơ bản kết hợp sự ngắn gọn với rõ ràng. Biến được khai báo thông qua val (bất biến) và var (có thể thay đổi). Trình biên dịch sử dụng suy luận kiểu, nhưng khai báo kiểu tường minh được hỗ trợ. Hàm được khai báo với từ khóa fun.

package com.example.intro

// Hằng số và biến
val appName: String = "KotlinApp"  // bất biến
var version = 1.0  // có thể thay đổi, kiểu được suy luận

// Hàm với expression body
fun sum(a: Int, b: Int) = a + b

// String templates
fun greet(name: String) = "Xin chào, $name! Phiên bản ${appName}_$version"

// Default and named arguments
fun createUser(
    name: String,
    age: Int = 18,
    email: String? = null
)

Biểu thức when thay thế switch trong Java và linh hoạt hơn: nó hỗ trợ kiểm tra kiểu, phạm vi, điều kiện và nhánh không cần break. Trình biên dịch kiểm tra phạm vi bao phủ đầy đủ cho enum và sealed classes. Smart casts tự động chuyển đổi kiểu sau khi kiểm tra is, loại bỏ việc ép kiểu tường minh.

fun analyzeValue(value: Any) = when (value) {
    is String -> "Chuỗi có độ dài ${value.length}"  // smart cast
    is Int -> "Số nguyên: $value"
    in 1..10 -> "Số trong phạm vi 1-10"
    else -> "Kiểu không xác định"
}

Null safety và toán tử Elvis

Null safety là tính năng chính của Kotlin loại bỏ NullPointerException tại thời điểm biên dịch. Trong Kotlin, kiểu không thể là null theo mặc định. Để cho phép null, thêm ? vào kiểu: String?. Trình biên dịch yêu cầu kiểm tra tường minh mọi giá trị nullable.

// Kiểu nullable và non-null
val nonNull: String = "Luôn không null"
val nullable: String? = null  // được phép

// Safe call — chỉ thực thi nếu không null
val length: Int? = nullable?.length

// Toán tử Elvis — giá trị mặc định
val text: String = nullable ?: "Default text"

// Let — thực thi khối với giá trị non-null
nullable?.let { value ->
    println("Giá trị: $value")
}

Toán tử safe call (?.) trả về null nếu đối tượng trước toán tử là null và gọi phương thức/thuộc tính trong trường hợp ngược lại. Toán tử Elvis (?:) cung cấp giá trị mặc định nếu vế trái là null. Khẳng định not-null (!!) ném NullPointerException nếu giá trị là null — chỉ sử dụng khi bạn chắc chắn 100% rằng giá trị tồn tại.

Kiểu platform — kiểu Java từ mã Java được gọi mà Kotlin không thể đánh dấu là nullable hoặc non-null. Kiểu được hiển thị dưới dạng String! (có dấu chấm than). Nhà phát triển chịu trách nhiệm về null safety khi làm việc với mã Java.

Data classes và giải cấu trúc

Data classes trong Kotlin tự động tạo equals(), hashCode(), toString(), copy() và componentN(). Điều này loại bỏ boilerplate của các mô hình Java (POJO) và làm cho mã sạch hơn. Khai báo một data class chỉ mất một dòng thay vì 20-30 dòng trong Java.

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int? = null
)

// Sử dụng
val user = User(1, "Anna", "anna@example.com")
val updatedUser = user.copy(age = 25)

// Giải cấu trúc
val (id, name) = user
println("Người dùng #$id: $name")

Giải cấu trúc cho phép phân rã data class thành các biến trong một dòng. Điều này thuận tiện khi làm việc với cặp, bộ ba và các giá trị tổng hợp khác. Giải cấu trúc được hỗ trợ cho data classes, collections chuẩn (List, Map) và bất kỳ lớp nào có operator fun componentN().

Hàm mở rộng

Hàm mở rộng là cơ chế của Kotlin để thêm phương thức mới vào các lớp hiện có mà không cần kế thừa. Các extension được biên dịch thành phương thức tĩnh với tham số receiver, do đó không cần kế thừa và dispatch ảo không được hỗ trợ.

// Hàm mở rộng cho String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Thuộc tính mở rộng
val String.isPhoneNumber: Boolean
    get() = this.matches(Regex("^\\+?[\\d-]{10,15}$"))

// Mở rộng tổng quát cho collections
fun List<Int>.sumOfEvens(): Int {
    return this.filter { it % 2 == 0 }.sum()
}

// Sử dụng
println("test@mail.com".isEmail())  // true

Extension được sử dụng rộng rãi trong Android SDK và các thư viện. Ví dụ, Activity extensions trong Android KTX là các extension functions cho Activity, Fragment, View và các lớp khác. Extension có thể được khai báo dưới dạng hàm cấp cao nhất trong tệp hoặc dưới dạng member extensions của một lớp.

Coroutines cho lập trình bất đồng bộ

Coroutines là cơ chế lập trình bất đồng bộ trong Kotlin cho phép viết mã không chặn theo phong cách tuần tự. Một coroutine tạm dừng thực thi tại hàm suspend mà không chặn luồng và tiếp tục sau khi hoàn thành thao tác. Đây là giải pháp thay thế cho chuỗi callback RxJava và AsyncTask.

import kotlinx.coroutines.*

// Hàm suspend — có thể tạm dừng
suspend fun fetchUserData(userId: Int): User {
    // delay — hàm suspend, không chặn luồng
    delay(500)
    return User(userId, "User $userId", "user@example.com")
}

// Khởi chạy trong coroutine
fun loadData() {
    CoroutineScope(Dispatchers.Main).launch {
        val user = fetchUserData(1)  // tạm dừng ở đây
        updateUI(user)  // tiếp tục trên luồng Main
    }
}

Dispatchers xác định nhóm luồng cho coroutine: Dispatchers.Main (luồng UI), Dispatchers.IO (thao tác mạng/đĩa), Dispatchers.Default (tác vụ tốn CPU). Tính đồng thời có cấu trúc đảm bảo rằng coroutine không hoạt động sau khi hoàn thành phạm vi — điều này ngăn rò rỉ bộ nhớ.

// Thực thi song song qua async/await
suspend fun loadDashboard(): Dashboard = coroutineScope {
    val user = async { fetchUserData(1) }
    val orders = async { fetchOrders(1) }
    val stats = async { fetchStats() }
    
    Dashboard(user.await(), orders.await(), stats.await())
}

Kotlin vs Java: so sánh

Lựa chọn giữa Kotlin và Java cho một dự án Android mới là một quyết định kiến trúc cơ bản. Kotlin cung cấp cú pháp hiện đại hơn và cơ chế bảo mật tích hợp, trong khi Java có nhóm nhà phát triển rộng hơn và các thư viện trưởng thành.

Hiệu suất của Kotlin và Java tương đương — cả hai đều biên dịch sang bytecode JVM. Kotlin đôi khi thêm một chút chi phí cho coroutines và inlining, nhưng điều này không đáng kể cho ứng dụng di động. Google và JetBrains đang tích cực đầu tư vào Kotlin: Kotlin Multiplatform, Kotlin/Wasm và cải thiện hiệu suất trình biên dịch K2.