Lập trình Hướng đối tượng (OOP) trong Android: Giải thích và Ví dụ Minh họa

OOP trong Android không phải bài giảng về bốn trụ cột. Bạn đã biết đóng gói là gì, kế thừa là gì. Vấn đề thật nằm ở chỗ khác: một Activity 800 dòng, một base class không ai dám sửa vì không biết nó làm gì ngầm, và state bị sửa từ ba nơi qua một singleton. Bài này nói về những quyết định thiết kế bạn đưa ra mỗi ngày trong Kotlin — class, constructor, property, interface, sealed type, composition — và cách chúng trông thế nào trong một app Compose năm 2026.

Cập nhật 2026: OOP trong Android viết bằng Kotlin, không mô phỏng Java

  • Kotlin 2.4.21 là bản ổn định (10/2026). K2 compiler là mặc định từ Kotlin 2.0; chẩn đoán exhaustiveness, smart cast và nullability chặt hơn nhiều tutorial viết trước 2024.
  • sealed interface + data object là cách chuẩn để mô tả state; enum cộng nullable field không còn cần thiết.
  • Hilt 2.60.1 (KSP2) inject qua constructor. Service locator kiểu object RepositoryProvider là anti-pattern, không phải giải pháp.
  • Compose-first: UI đọc state bất biến từ StateFlow. Class có state mutable công khai không còn chỗ đứng.

Class, constructor, property: phần dùng hàng ngày

Kotlin gộp class, primary constructor và property vào một chỗ. Viết đúng ba thứ đó đã loại bỏ phần lớn boilerplate mà Java OOP dạy bạn phải sinh ra.

// File: domain/Money.kt
class Money(
    val amount: Long,
    val currency: String
) {
    // secondary constructor phải ủy nhiệm cho primary
    constructor(amount: Long) : this(amount, currency = "VND")

    // computed property: không có backing field
    val isFree: Boolean
        get() = amount == 0L
}

val chỉ có getter, var có cả setter. Nếu dữ liệu phải đi qua kiểm tra, đừng để setter public — dùng private set và một hàm cập nhật. Đây là chỗ đóng gói có tác dụng thật, không phải nghi thức.

class Cart(private val lines: List<Pair<Money, Int>>) {
    var couponCode: String = ""
        private set

    val total: Money
        get() = Money(lines.sumOf { (price, qty) -> price.amount * qty })

    fun applyCoupon(code: String): Boolean {
        if (code.isBlank()) return false
        couponCode = code      // nơi duy nhất được đổi state
        return true
    }
}

Điểm dễ sai: var khai báo trong primary constructor tạo setter public. Với state trong ViewModel hay model chia sẻ, mặc định dùng val; chỉ dùng var khi vòng đời của nó bị giới hạn trong một class.

Kế thừa: open là quyết định, không phải mặc định

Class trong Kotlin là final cho đến khi bạn viết open, và thành viên chỉ override được khi cũng đánh dấu open. Điều này ngược với Java, nơi mọi thứ mở trừ khi bạn đóng. Hệ quả thực tế: không ai vô tình kế thừa class của bạn rồi phụ thuộc vào hành vi nội bộ của nó.

open class ScreenController {
    open fun onStart() { /* hook mặc định */ }
    fun render() = onStart()          // template method
}

class OrdersController : ScreenController() {
    override fun onStart() { /* ... */ }
}

Chỉ đánh dấu open khi bạn cam kết duy trì hành vi đó cho lớp con qua nhiều version. Một open đặt sai chỗ là một API bạn không thể sửa.

Interface và default implementation

Interface là hợp đồng, không giữ state, nhưng vẫn có default implementation:

interface OrderRepository {
    suspend fun getOrders(): List<Order>

    // default: chỉ dùng khi rẻ và không phụ thuộc state
    fun observeOrders(): Flow<List<Order>> = flow { emit(getOrders()) }
}

Default method giúp implementation nhỏ khỏi viết lặp, nhưng tạo hành vi ẩn: người implement không thấy mỗi lần gọi observeOrders lại chạy một network call. Nếu default có chi phí, để nó abstract và buộc implement tự quyết.

Abstract class: chỉ khi cần constructor hoặc state

Interface không có constructor parameter và không giữ field. Khi cần một trong hai, abstract class là lựa chọn đúng:

abstract class OrderTask(private val dispatcher: CoroutineDispatcher) {
    protected abstract suspend fun execute(): List<Order>

    suspend fun run(): List<Order> = withContext(dispatcher) { execute() }
}

Ở đây abstract class không phải “base class cho mọi thứ” — nó tồn tại vì có dependency truyền vào constructor và một template method. Nếu bạn tạo abstract class mà mọi thành viên đều abstract, đó là interface viết sai kiểu.

Visibility: chọn theo phạm vi, không theo thói quen

Modifier Phạm vi Dùng khi nào
public (mặc định) Mọi nơi, kể cả module khác API công khai của module
internal Trong cùng module Gradle Phần lớn code app: ViewModel, repository, model
protected Class hiện tại và lớp con Hook cho lớp kế thừa
private Trong class, hoặc cả file nếu khai báo top-level State nội bộ, helper

Trong app một module, internal tốt hơn public: nó ngăn module khác lấy trực tiếp repository thay vì qua ViewModel. private ở top-level áp dụng cho cả file, không chỉ một class — chi tiết hay bị bỏ qua.

object và companion object

class OrderFormatter {
    companion object {
        const val DATE_PATTERN = "dd/MM/yyyy"   // OK: hằng số
    }
}

Hằng số, regex, tên key của DataStore — companion object là đúng chỗ. Nhưng nếu trong đó có var cache, lateinit var context hay fun getInstance(): X, bạn vừa tạo global mutable state và một service locator: test không thay được dependency, thứ tự khởi tạo thành vấn đề, và process có thể giữ Context sống lâu hơn Activity.

object chỉ nên chứa hành vi không state, hoặc state thật sự toàn cục như một Clock. Mọi thứ khác truyền qua constructor.

data class và sealed interface: state bất biến

data class sinh equals, hashCode, toString và copy từ các property trong primary constructor. Đó chính là những gì state cần:

data class Order(
    val id: String,
    val customerName: String,
    val total: Long,
    val status: OrderStatus
)

sealed interface OrderStatus {
    data object Pending : OrderStatus
    data object Paid : OrderStatus
    data class Failed(val reason: String) : OrderStatus
}

Cập nhật state bằng order.copy(status = OrderStatus.Paid) tạo object mới, giữ nguyên phần còn lại, và equals vẫn đúng. Đó là lý do var trong state là bẫy: sửa tại chỗ làm object giữ nguyên tham chiếu, StateFlow so sánh bằng equals nên không phát ra emission, UI không cập nhật dù dữ liệu đã đổi.

sealed biến tập trạng thái thành đóng: compiler biết mọi subtype, nên when thiếu nhánh là lỗi compile, không phải bug production. Dùng sealed interface thay vì sealed class khi không cần constructor — mỗi subtype có thể là data class hay data object.

Composition thay vì kế thừa trong Android

Android bắt bạn kế thừa ở tầng framework: Activity, Fragment, Application. Vấn đề bắt đầu khi bạn extends tiếp lên trên.

BaseActivity mở rộng AppCompatActivity, trong đó có setupToolbar(), handleError(), registerAnalytics(), một abstract fun getLayoutId(), và một initOrder() phải gọi trước khi dùng bất cứ thứ gì. Ba tháng sau nó dài 1.200 dòng, mọi screen phụ thuộc vào thứ tự khởi tạo của nó, và không ai dám xóa một hàm vì không biết screen nào còn gọi ngầm. Đây là kế thừa như cái phễu: mọi thứ chảy qua một chỗ, mọi thay đổi lan ra toàn app.

Composition đảo ngược điều đó. Activity chỉ làm ba việc: host Compose, thu state, gọi ViewModel. Phần logic nằm trong ViewModel, repository và use case — những class bạn khởi tạo và truyền vào, không phải những class bạn thừa kế.

// Trước: ViewModel biết mọi thứ
class OrdersViewModel(app: Application) : AndroidViewModel(app) {
    fun load() { /* Retrofit + parse + cache + format */ }
}

// Sau: ViewModel chỉ điều phối, dependency đến từ constructor
class OrdersViewModel(private val repository: OrderRepository) : ViewModel()

Base class chứa hành vi ẩn nên xóa: nếu behavior không nhìn thấy từ tên class và constructor, nó thành bug không tái hiện được. Một hàm top-level gọi rõ ràng tốt hơn một hook trong onCreate của lớp cha.

Ví dụ chạy được: repository, ViewModel và sealed state

Code dưới đây chạy với Kotlin 2.4.21, androidx.lifecycle 2.11.0 và kotlinx-coroutines. Import chính: androidx.lifecycle.ViewModel, ViewModelProvider, viewModelScope, androidx.lifecycle.viewmodel.viewModelFactory và initializer, kotlinx.coroutines.flow.*, kotlinx.coroutines.launch, kotlin.coroutines.cancellation.CancellationException.

// File: domain/OrderRepository.kt
interface OrderRepository {
    suspend fun getOrders(): List<Order>
}

// File: data/InMemoryOrderRepository.kt  (thay bằng impl Retrofit của bạn)
class InMemoryOrderRepository(
    private val source: suspend () -> List<Order> = { emptyList() }
) : OrderRepository {
    override suspend fun getOrders(): List<Order> = source()
}

Interface là hợp đồng, implementation là chi tiết. ViewModel không biết dữ liệu đến từ đâu, nên bạn thay InMemoryOrderRepository bằng bản gọi API mà không sửa một dòng nào trong ViewModel — và test chỉ cần một fake implementation.

// File: ui/OrdersUiState.kt
sealed interface OrdersUiState {
    data object Loading : OrdersUiState
    data class Content(val orders: List<Order>) : OrdersUiState
    data class Error(val message: String) : OrdersUiState
}

// File: ui/OrdersViewModel.kt
class OrdersViewModel(
    private val repository: OrderRepository
) : ViewModel() {

    private val _uiState = MutableStateFlow<OrdersUiState>(OrdersUiState.Loading)
    val uiState: StateFlow<OrdersUiState> = _uiState.asStateFlow()

    init { refresh() }

    fun refresh() {
        viewModelScope.launch {
            _uiState.value = OrdersUiState.Loading
            _uiState.value = try {
                OrdersUiState.Content(repository.getOrders())
            } catch (e: CancellationException) {
                throw e                          // không nuốt cancellation
            } catch (e: Exception) {
                OrdersUiState.Error(e.message ?: "Không tải được đơn hàng")
            }
        }
    }

    companion object {
        fun factory(repository: OrderRepository): ViewModelProvider.Factory =
            viewModelFactory {
                initializer { OrdersViewModel(repository) }
            }
    }
}

Ba chi tiết: _uiState là private, uiState chỉ đọc; rethrow CancellationException để coroutine bị hủy không bị biến thành lỗi UI; và factory nhận repository qua tham số, không đọc từ biến toàn cục.

// File: ui/OrdersScreen.kt
@Composable
fun OrdersScreen(viewModel: OrdersViewModel) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()

    when (val current = state) {
        OrdersUiState.Loading -> CircularProgressIndicator()
        is OrdersUiState.Content -> Text("${current.orders.size} đơn hàng")
        is OrdersUiState.Error -> Text(current.message)
    }
}

when không có else vì OrdersUiState là sealed. Thêm một state mới, compiler báo thiếu nhánh ngay — đó là giá trị thực của sealed hierarchy, không phải mẹo trình diễn.

Dependency injection không cần service locator

Constructor injection là toàn bộ ý tưởng: class khai báo thứ nó cần, người tạo cung cấp. Trong app nhỏ, một AppContainer tạo repository ở Application và truyền xuống là đủ. Khi dùng Hilt 2.60.1, cùng dependency đó khai báo ở module:

@Module
@InstallIn(SingletonComponent::class)
object DataModule {
    @Provides
    @Singleton
    fun provideOrderRepository(api: OrdersApi): OrderRepository =
        RemoteOrderRepository(api)
}

Điều bạn không làm: một object RepositoryLocator giữ var repository: OrderRepository? mà ViewModel tự đọc. Nó che giấu dependency, buộc test reset global, và giữ Context sống ngoài lifecycle.

Pitfall thường gặp và cách sửa

  • open mọi class. Mỗi open là một lời hứa duy trì API. Chỉ mở class thật sự là điểm mở rộng; còn lại để final.
  • Abstract class mà mọi thành viên đều abstract. Không state, không constructor parameter thì dùng interface; abstract class chỉ để chứa template method hoặc dependency.
  • Property var public. Bất biến (invariant) bị phá từ ngoài. Dùng val, private set, và một hàm cập nhật có kiểm tra.
  • data class có var trong state. copy() mất ý nghĩa, equals sai, StateFlow không emit. State phải immutable.
  • Singleton giữ Context. object với lateinit var context giữ Activity và gây leak. Nếu buộc phải có Context, dùng applicationContext và truyền qua DI.
  • companion object làm global state. Test chạy song song sẽ đọc ghi cùng một biến; thay bằng dependency truyền vào constructor.
  • God Activity hoặc god ViewModel. Khi một class có quá ba trách nhiệm, tách thành repository hoặc use case — composition, không phải thêm base class.

Chọn gì cho tình huống nào

Nhu cầu Chọn Vì sao
Model hoặc state bất biến data class equals và copy miễn phí, an toàn với StateFlow
Tập trạng thái đóng (loading, content, error) sealed interface when exhaustive, compiler kiểm tra khi thêm nhánh
Hợp đồng không state (repository, api) interface Dễ fake trong test, thay implementation không đổi call site
Cần dependency trong constructor và hook abstract class Interface không giữ được field hay constructor parameter
Hằng số, tiện ích không state object / companion object Không cần khởi tạo, không có state để hỏng
Singleton có state hoặc Context DI + constructor Tránh leak và global mutable state

Hướng 2027

Kotlin 2.5.0 dự kiến 12/2026, chưa phát hành — đừng viết code dựa trên nó. Context parameters có thể thay một phần constructor injection trong Compose hay serialization, nhưng chưa thay DI ở tầng app. Hướng kiến trúc vẫn là state bất biến, sealed type và composition; Kotlin Multiplatform chỉ làm yêu cầu đó chặt hơn, vì model dùng chung không được phụ thuộc Android.

Checklist trước khi commit

  • Class mới mặc định final; chỉ open khi có lý do viết ra được.
  • State trong ViewModel là val, cập nhật bằng copy(), không sửa tại chỗ.
  • Mọi trạng thái UI là một nhánh của sealed interface, không phải cặp isLoading cộng error: String?.
  • Dependency vào qua constructor; không có object XxxLocator hay companion object giữ state.
  • Không còn base class nào mà bạn không giải thích được trong một câu.

Bài tiếp theo

Nếu phần class và interface còn mờ, đọc lại 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. Repository trong bài này là một design pattern — bài Repository, Factory và Builder trong Phát triển ứng dụng Android đi sâu vào cách chọn. Cách những class này ghép thành kiến trúc app nằm ở MVC, MVP, MVVM hay MVI, còn Dependency Injection: Hilt, Koin và Dagger giải thích phần DI mà bài này chỉ chạm tới.