Học Kotlin cho Android: Cú pháp và Khái niệm Cốt lõi Bạn Cần Nắm Vững

Kotlin không khó ở cú pháp. Nó khó ở chỗ cùng một việc có năm cách viết đều đúng, và tutorial thì dạy cả năm. Bài này chốt những gì bạn thật sự dùng khi học Kotlin cho Android (bản 2.4.21): cú pháp lõi, cách mô hình hoá dữ liệu và trạng thái, extension, scope function, rồi coroutines ở mức đủ để đọc ViewModel của người khác.

Mục tiêu là sau khi đọc xong, bạn viết được một màn hình có model, UI state và lời gọi API bằng coroutine mà không phải tra từng dòng.

Cập nhật 2026: những gì đã đổi

  • Kotlin 2.4.21 là bản ổn định (10/2026). K2 là compiler mặc định từ Kotlin 2.0, không còn công tắc “K2 mode” để bật.
  • K2 chẩn đoán tốt hơn: smart cast chính xác hơn, lỗi nullability và when thiếu nhánh được báo sớm và rõ hơn. Nhiều mẹo ép kiểu trong tutorial cũ giờ không còn cần thiết.
  • KAPT là legacy. Room 2.8.5 và Hilt 2.60.1 chạy KSP2; đừng thêm kapt vào dự án mới.
  • Kotlin 2.5.0 dự kiến 12/2026 và chưa phát hành. Đừng viết code dựa trên tính năng chỉ có trong bản chưa ra.

Học Kotlin cho Android: bốn thứ dùng hằng ngày

Bốn thứ chiếm phần lớn code Android bạn viết: biến, null-safety, model và lambda.

val, var và suy luận kiểu

val là tham chiếu chỉ đọc, var là tham chiếu gán lại được. Cả hai không nói gì về việc object bên trong có thay đổi hay không — val không phải “immutable”.

val appName = "Evotek Tasks"        // String, không gán lại được
var retryCount = 3                  // Int, gán lại được
val ids = mutableListOf(1L, 2L)     // val: tham chiếu cố định, nội dung vẫn đổi
ids += 3L

Dùng val làm mặc định, chỉ var khi cần gán lại. Biến local để compiler suy luận; API public nên khai báo kiểu tường minh.

Chuỗi dùng template thay vì nối bằng +:

val name = "Linh"
val pending = 3
val label = "Chào $name, bạn còn ${pending + 1} việc"
val json = """{"owner":"$name","pending":$pending}"""   // raw string
val price = "Giá: \$12"                                  // escape dấu $

$name cho biến, ${...} cho biểu thức; raw string """ không cần escape dấu nháy, dùng trimIndent() cho JSON/SQL nhiều dòng.

Null-safety: chỗ Kotlin khác Java rõ nhất

Kiểu mặc định là non-null. Muốn nhận null, bạn phải viết String?, và compiler bắt bạn xử lý trước khi dùng. Ba toán tử đủ cho gần hết trường hợp:

data class Profile(val displayName: String?, val avatarUrl: String?)

fun greeting(profile: Profile?): String {
    val name = profile?.displayName ?: "bạn"
    return "Chào $name"
}

fun unsafeLength(profile: Profile?): Int =
    profile!!.displayName!!.length     // NPE nếu một trong hai là null

?. trả null nếu receiver null, ?: đưa giá trị dự phòng. !! chỉ bỏ qua kiểm tra của compiler: nếu thực tế null, app crash như Java. Trong code production, !! là dấu hiệu bạn chưa hiểu dữ liệu của mình.

Thay thế: requireNotNull(value) { "task id bắt buộc" } khi null là bug và bạn muốn fail sớm; ?: return khi null là trạng thái hợp lệ. Với API Java, giá trị trả về là platform type (String!) — hãy coi nó nullable cho đến khi có annotation @Nullable/@NonNull.

Smart cast chỉ hoạt động với val local hoặc property không có custom getter; var bị capture trong lambda thì phải copy ra biến local. Đây là nguồn gốc lỗi “smart cast is impossible”.

data class, sealed, enum: mô hình hoá trạng thái

Model dữ liệu gần như luôn là data class bất biến:

// File: model/Task.kt
data class Task(
    val id: Long,
    val title: String,
    val done: Boolean = false,
    val tags: List<String> = emptyList(),
)

Compiler sinh equals/hashCode/toString/copy và componentN. Nhờ đó bạn có so sánh theo nội dung và tạo bản sửa mà không đột biến object gốc:

val next = task.copy(done = true)
val (id, title) = task                 // destructuring

Đừng đặt var trong data class. hashCode phụ thuộc giá trị, nên nếu object đang là key của map hoặc phần tử của set mà bạn sửa field, entry đó biến mất. Cần “sửa” thì dùng copy. Data class cũng không được open, abstract hay sealed.

UI state nên là sealed interface, không phải một data class với năm field nullable:

sealed interface UiState {
    data object Loading : UiState
    data class Content(val tasks: List<Task>) : UiState
    data class Error(val message: String) : UiState
}

Sealed là tập con hữu hạn và đóng: compiler biết hết các nhánh. Từ Kotlin 1.5, lớp con chỉ cần cùng package và cùng module, không bắt buộc cùng file. data object dùng cho case không mang dữ liệu nhưng vẫn cần equals/toString tử tế.

Tình huống enum class sealed
Tập giá trị cố định, không payload Phù hợp: SortOrder.NAME Thừa: mỗi giá trị cần một object
Mỗi case mang dữ liệu riêng Không: mọi entry dùng chung constructor Phù hợp: Content(tasks)
Dùng cho Cấu hình, loại cố định, quyền UI state, kết quả API, sự kiện

when là biểu thức, không phải câu lệnh

fun label(state: UiState): String = when (state) {
    UiState.Loading -> "Đang tải"
    is UiState.Content -> "${state.tasks.size} việc"
    is UiState.Error -> "Lỗi: ${state.message}"
}

Không cần else vì đã đủ nhánh. Thêm case mới vào sealed interface sẽ làm mọi when thiếu nhánh fail lúc compile — đó là tính năng. Với enum cũng vậy: bỏ else để compiler bắt entry thêm sau này. when không subject hoạt động như chuỗi if-else: when { a > b -> ... else -> ... }.

Collections và lambda: viết ít hơn, đọc rõ hơn

val tasks = listOf(Task(1, "Viết test"), Task(2, "Sửa bug", done = true))

val openTitles = tasks.filterNot { it.done }.map { it.title }
val byId = tasks.associateBy { it.id }
val doneCount = tasks.count { it.done }
val firstLong = tasks.firstOrNull { it.title.length > 10 }

Phân biệt read-only và mutable: listOf trả về List không có add/remove; mutableListOf trả về MutableList. Read-only không có nghĩa bất biến — nếu list đến từ Java, nó vẫn có thể bị sửa từ bên ngoài; cần snapshot thì gọi toList().

Lambda là hàm không tên, tham số duy nhất có tên mặc định it. Trailing lambda cho phép viết tasks.filter { ... }. Hàm nhận lambda nên đánh dấu inline nếu gọi trong vòng lặp nóng. Đừng dùng forEach khi map/filter diễn đạt ý định rõ hơn.

Extension function: thêm hành vi, không sửa class

// File: core/ContextExt.kt
fun Context.toast(message: String) {
    Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
}

fun Context.dp(value: Int): Int =
    (value * resources.displayMetrics.density).toInt()

Gọi context.toast("Đã lưu"). Extension không kế thừa, không sửa class gốc — hợp để bọc API SDK. Nhưng resolution là static: member cùng tên và cùng tham số luôn thắng extension, và extension không đa hình theo kiểu runtime. Đặt chúng theo file chủ đề (ContextExt.kt, FlowExt.kt) thay vì rải khắp project.

Extension trên nullable receiver cũng hợp lệ và rất tiện: fun String?.orDash() = this ?: "—".

Scope function: năm hàm, một quy tắc chọn

Hàm Receiver và kết quả Dùng khi
let it, trả về kết quả lambda Biến đổi giá trị nullable, đổi tên cho dễ đọc
run this, trả về kết quả lambda Tính toán trên object, hoặc block không receiver
apply this, trả về chính object Cấu hình object rồi vẫn cần object đó
also it, trả về chính object Side effect: log, validate, analytics
with this, trả về kết quả lambda Gọi nhiều method trên object đã non-null
val intent = Intent(context, DetailActivity::class.java).apply {
    putExtra("task_id", taskId)
}

val title = task?.let { "${it.title} (${it.id})" } ?: "Chưa chọn"

repository.load()
    .also { log("loaded ${it.size} tasks") }

Quy tắc thực dụng: apply để cấu hình, also cho side effect, let để biến đổi nullable, run khi cần this và trả về kết quả, with khi object đã non-null. Nếu block chỉ có một dòng, viết thẳng — scope function thêm một tầng đọc mà không thêm giá trị nào.

Property, object, interface và generics

Property và backing field

class Counter(initial: Int) {
    var value: Int = initial
        private set                        // đọc công khai, ghi nội bộ

    val isEmpty: Boolean
        get() = value == 0                 // không có backing field

    var label: String = ""
        get() = field.ifBlank { "Bộ đếm" } // field = backing field
}

Đừng viết getValue()/setValue() kiểu Java: dùng counter.value. field chỉ tồn tại khi getter/setter dùng nó. lateinit var cho giá trị gán sau (view binding, DI), chỉ với kiểu non-null không phải primitive; by lazy cho khởi tạo đắt, thread-safe mặc định.

object và companion object

object Clock {
    fun now(): Long = System.currentTimeMillis()
}

class TaskRepository private constructor() {
    companion object {
        const val PAGE_SIZE = 20
        fun create(): TaskRepository = TaskRepository()
    }
}

object là singleton theo classloader. companion object gọi như static từ Kotlin nhưng thực chất có instance; Java cần @JvmStatic. Đừng dùng object làm state toàn cục thay đổi được — singleton khó test và dễ leak.

Interface và default implementation

interface TaskFormatter {
    fun format(task: Task): String
    fun formatAll(tasks: List<Task>): List<String> =
        tasks.map { format(it) }           // default implementation
}

class ShortFormatter : TaskFormatter {
    override fun format(task: Task) = task.title
}

Interface có thể có thân hàm; class implement chỉ cần override phần trừu tượng. Khác abstract class: interface không giữ state và không có constructor.

Generics ở mức đủ dùng

fun <T> List<T>.secondOrNull(): T? = getOrNull(1)

class Cache<T : Any>(private val loader: () -> T) {
    private var value: T? = null
    fun get(): T = value ?: loader().also { value = it }
}

List<out T> covariant, MutableList<T> invariant, in cho vị trí consumer như Comparable<in T>. Kiểm tra kiểu lúc runtime cần reified + inline. Mức nhập môn: out khi chỉ đọc, in khi chỉ ghi.

Coroutines ở mức nhập môn

Coroutine là cách Android xử lý bất đồng bộ; AsyncTask đã deprecated từ API 30. Bốn khái niệm đủ để bắt đầu: suspend, scope, dispatcher và Flow.

suspend fun loadTasks(api: TaskApi): List<Task> =
    withContext(Dispatchers.IO) {
        api.fetchTasks()
    }

suspend đánh dấu hàm có thể tạm dừng mà không block thread; chỉ gọi được từ coroutine hoặc hàm suspend khác. withContext(Dispatchers.IO) đưa việc mạng/đĩa ra khỏi main thread rồi trả kết quả về.

// File: ui/TasksViewModel.kt
fun refresh() = viewModelScope.launch {
    _state.value = UiState.Loading
    _state.value = runCatching { repository.loadTasks() }
        .fold(
            onSuccess = { UiState.Content(it) },
            onFailure = { UiState.Error(it.message ?: "Lỗi không xác định") },
        )
}

launch trả về Job, dùng khi không cần kết quả. async trả về Deferred, dùng khi cần kết quả hoặc chạy song song:

coroutineScope {
    val profile = async { api.profile() }
    val tasks = async { api.tasks() }
    render(profile.await(), tasks.await())
}

coroutineScope đảm bảo cả hai nhánh xong trước khi tiếp tục; một nhánh fail thì nhánh còn lại bị cancel. Đây là structured concurrency, không phải “gọi async rồi quên”. Dispatcher: Dispatchers.Main cho UI, Dispatchers.IO cho mạng/đĩa, Dispatchers.Default cho CPU. Không tự tạo thread pool riêng.

fun observeTasks(): Flow<List<Task>> = flow {
    emit(repository.loadTasks())
}

// Compose: state.collectAsStateWithLifecycle()
// ViewModel: val state: StateFlow<UiState>

Flow là stream lạnh: mỗi lần collect chạy lại. StateFlow là hot, luôn có value hiện tại và conflate giá trị; UI đọc bằng collectAsStateWithLifecycle() để dừng khi màn hình không còn hiển thị.

Lỗi thường gặp

  • Dùng !! để “cho nhanh”. Nó biến một lỗi dữ liệu thành crash. Dùng ?./?: hoặc requireNotNull với thông điệp.
  • Đặt var trong data class. Làm hỏng hashCode, mất entry trong map/set, và Compose không thấy thay đổi. Dùng copy.
  • Lạm dụng scope function. apply lồng let lồng also là code khó đọc. Một tầng là đủ; hai tầng thì tách biến local.
  • Nhầm == và ===. == gọi equals (data class so sánh nội dung), === so sánh identity. Dùng == cho giá trị; === gần như chỉ dành cho test và cache.
  • Nhầm List<Task>? với List<Task?>. Cái đầu là list có thể null, cái sau là phần tử có thể null. Chỉ chọn cái sau khi null là phần tử hợp lệ, và xử lý bằng filterNotNull() trước khi map.
  • Viết getter/setter kiểu Java. user.getName() phải là user.name; setAge(30) phải là user.age = 30 nếu property là var.
  • Block trong coroutine. Thread.sleep, runBlocking hay gọi IO trên Dispatchers.Main đều gây ANR. Dùng delay và withContext(Dispatchers.IO).

Nhìn về 2027 và checklist

Kotlin 2.5.0 dự kiến ra 12/2026; khi đó KSP và Compose compiler phải khớp version với Kotlin plugin. K2 tiếp tục thay mẹo cũ bằng chẩn đoán chính xác hơn, KSP2 là mặc định cho codegen, còn coroutines/Flow vẫn là nền của app Android.

  • Model bằng data class bất biến; UI state bằng sealed interface.
  • Không dùng !! trong code production; thay bằng ?: hoặc requireNotNull có message.
  • Extension đặt theo file chủ đề; scope function tối đa một tầng.
  • IO trong withContext(Dispatchers.IO); UI state qua StateFlow.
  • Dùng KSP2 cho Room/Hilt, không thêm kapt vào dự án mới.

Đọc tiếp: Kotlin vs Java để hiểu vì sao Kotlin là mặc định, OOP trong Android để nối phần class/interface với kiến trúc, coroutines, threads và RxJava để đi sâu bất đồng bộ, và lộ trình Android để đặt các kỹ năng này vào đúng chặng.