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.
Mục lục
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 objectlà 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 RepositoryProviderlà 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
openmọi class. Mỗiopenlà 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
varpublic. Bất biến (invariant) bị phá từ ngoài. Dùngval,private set, và một hàm cập nhật có kiểm tra. data classcóvartrong state.copy()mất ý nghĩa,equalssai,StateFlowkhông emit. State phải immutable.- Singleton giữ
Context.objectvớilateinit var contextgiữ Activity và gây leak. Nếu buộc phải có Context, dùngapplicationContextvà truyền qua DI. companion objectlà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ỉopenkhi có lý do viết ra được. - State trong ViewModel là
val, cập nhật bằngcopy(), 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ặpisLoadingcộngerror: String?. - Dependency vào qua constructor; không có
object XxxLocatorhaycompanion objectgiữ 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.



