📜 Interface

🎯 Mục tiêu: Hiểu Interface - contract định nghĩa hành vi chung, với default implementations, properties, và cách resolve conflicts.

---

💡 Interface là gì?

Interface định nghĩa “contract” - tập hợp các methods và properties mà class phải có. Nó mô tả “cái gì” (what) mà không quan tâm “như thế nào” (how).

// Định nghĩa interface
interface Clickable {
    fun click()
}

// Class implement interface
class Button : Clickable {
    override fun click() {
        println("Button clicked!")
    }
}

fun main() {
    val button = Button()
    button.click()  // Button clicked!

    // Polymorphism - lưu Button như Clickable
    val clickable: Clickable = button
    clickable.click()  // Button clicked!
}

---

📝 Tại sao cần Interface?

Polymorphism - Đa hình

interface Playable {
    fun play()
}

class MusicPlayer : Playable {
    override fun play() = println("🎵 Playing music...")
}

class VideoPlayer : Playable {
    override fun play() = println("🎬 Playing video...")
}

class Game : Playable {
    override fun play() = println("🎮 Playing game...")
}

// Hàm làm việc với bất kỳ Playable nào
fun startMedia(media: Playable) {
    print("Starting: ")
    media.play()
}

fun main() {
    startMedia(MusicPlayer())  // Starting: 🎵 Playing music...
    startMedia(VideoPlayer())  // Starting: 🎬 Playing video...
    startMedia(Game())         // Starting: 🎮 Playing game...
}

Loose Coupling - Giảm phụ thuộc

// Bad: Tight coupling
class EmailService {
    fun sendEmail(message: String) { /* ... */ }
}

class OrderProcessor {
    private val emailService = EmailService()  // ❌ Phụ thuộc trực tiếp

    fun processOrder(order: Order) {
        emailService.sendEmail("Order confirmed")
    }
}

// Good: Loose coupling với Interface
interface NotificationService {
    fun notify(message: String)
}

class EmailNotification : NotificationService {
    override fun notify(message: String) = println("Email: $message")
}

class SMSNotification : NotificationService {
    override fun notify(message: String) = println("SMS: $message")
}

class OrderProcessor(private val notifier: NotificationService) {
    fun processOrder(order: Order) {
        // Logic...
        notifier.notify("Order confirmed")
    }
}

fun main() {
    // Dễ dàng switch implementation
    val emailProcessor = OrderProcessor(EmailNotification())
    val smsProcessor = OrderProcessor(SMSNotification())
}

---

🔧 Default Implementation

Interface có thể có default implementation - không bắt buộc override:

interface Clickable {
    fun click()  // Abstract - PHẢI implement

    fun showOff() = println("I'm clickable!")  // Default - optional override

    fun doubleClick() {  // Cũng là default implementation
        click()
        click()
    }
}

class Button(val name: String) : Clickable {
    override fun click() {
        println("$name clicked")
    }
    // showOff() và doubleClick() đã có default, không cần override
}

fun main() {
    val button = Button("Submit")
    button.click()        // Submit clicked
    button.showOff()      // I'm clickable!
    button.doubleClick()  // Submit clicked \n Submit clicked
}

Ghi chú

Khác với Java < 8: Java 8+ mới có default methods. Kotlin hỗ trợ từ đầu.

---

📦 Interface Properties

Interface có thể có abstract properties:

interface Identifiable {
    val id: String  // Abstract property
    val createdAt: Long  // Abstract property

    // Property với default getter
    val displayId: String
        get() = "ID: $id"
}

class User(override val id: String) : Identifiable {
    override val createdAt = System.currentTimeMillis()
}

class Document(override val id: String) : Identifiable {
    override val createdAt = System.currentTimeMillis()
}

fun main() {
    val user = User("user-123")
    println(user.displayId)   // ID: user-123
    println(user.createdAt)   // Timestamp
}

Chú ý

Interface KHÔNG có backing field: Không thể khởi tạo state trong interface.

interface Bad {
    val name: String = "Default"  // ❌ Lỗi! Không có backing field
}

interface Good {
    val name: String  // ✅ Abstract
        get() = "Default"  // ✅ Default getter (computed, không lưu state)
}

---

🔀 Multiple Interface Inheritance

Class có thể implement nhiều interfaces:

interface Walkable {
    fun walk() = println("Walking...")
}

interface Swimable {
    fun swim() = println("Swimming...")
}

interface Flyable {
    fun fly() = println("Flying...")
}

class Duck : Walkable, Swimable, Flyable  // Implement 3 interfaces

class Fish : Swimable  // Chỉ implement Swimable

class Penguin : Walkable, Swimable {
    // Không fly()
}

fun main() {
    val duck = Duck()
    duck.walk()  // Walking...
    duck.swim()  // Swimming...
    duck.fly()   // Flying...
}

Resolving Conflicts

Khi multiple interfaces có method cùng tên:

interface A {
    fun foo() = println("A.foo")
    fun bar()
}

interface B {
    fun foo() = println("B.foo")
    fun bar() = println("B.bar")
}

class C : A, B {
    // PHẢI override foo() vì conflict
    override fun foo() {
        super<A>.foo()  // Gọi A.foo()
        super<B>.foo()  // Gọi B.foo()
    }

    // PHẢI override bar() vì abstract trong A
    override fun bar() {
        super<B>.bar()  // Có thể dùng default từ B
    }
}

fun main() {
    val c = C()
    c.foo()
    // A.foo
    // B.foo

    c.bar()
    // B.bar
}

---

🏛️ Interface vs Abstract Class

Feature	Interface	Abstract Class
State (fields)	❌ Không	✅ Có
Constructor	❌ Không	✅ Có
Multiple inheritance	✅ Có	❌ Không
Default implementations	✅ Có	✅ Có
Visibility modifiers	Chỉ public	Tất cả
Dùng khi	Contract, behavior	Shared base + state

// Interface - chỉ behavior, không có state
interface Logger {
    fun log(message: String)
}

// Abstract class - shared implementation + state
abstract class BaseLogger(protected val tag: String) {
    abstract fun log(message: String)

    protected fun formatMessage(msg: String): String {
        return "[$tag] ${System.currentTimeMillis()}: $msg"
    }
}

class ConsoleLogger(tag: String) : BaseLogger(tag) {
    override fun log(message: String) {
        println(formatMessage(message))
    }
}

---

🎯 Interface Delegation

Kotlin cho phép delegate interface implementation:

interface Printer {
    fun print(text: String)
}

class ConsolePrinter : Printer {
    override fun print(text: String) = println(text)
}

// Delegate Printer implementation cho consolePrinter
class Logger(consolePrinter: Printer) : Printer by consolePrinter {
    fun logInfo(msg: String) {
        print("[INFO] $msg")
    }
}

fun main() {
    val logger = Logger(ConsolePrinter())
    logger.print("Hello")       // Hello (delegated)
    logger.logInfo("Starting")  // [INFO] Starting
}

---

🛠️ Thực hành

Bài tập: Tạo hierarchy với interfaces

// TODO: Tạo:
// - interface Vehicle với properties và methods
// - interface Electric với charge()
// - class Car, ElectricCar, Bicycle implementing phù hợp

Lời giải:

interface Vehicle {
    val brand: String
    val maxSpeed: Int

    fun start()
    fun stop()

    fun info() = "$brand (max: $maxSpeed km/h)"
}

interface Electric {
    val batteryLevel: Int

    fun charge()

    fun batteryStatus() = "Battery: $batteryLevel%"
}

class Car(
    override val brand: String,
    override val maxSpeed: Int = 200
) : Vehicle {
    override fun start() = println("$brand: Engine started 🚗")
    override fun stop() = println("$brand: Engine stopped")
}

class ElectricCar(
    override val brand: String,
    override val maxSpeed: Int = 250,
    override var batteryLevel: Int = 100
) : Vehicle, Electric {
    override fun start() = println("$brand: Silently starting ⚡🚗")
    override fun stop() = println("$brand: Stopped")
    override fun charge() {
        batteryLevel = 100
        println("$brand: Fully charged!")
    }
}

class Bicycle(
    override val brand: String,
    override val maxSpeed: Int = 40
) : Vehicle {
    override fun start() = println("$brand: Pedaling 🚲")
    override fun stop() = println("$brand: Braking")
}

fun main() {
    val vehicles: List<Vehicle> = listOf(
        Car("Toyota"),
        ElectricCar("Tesla"),
        Bicycle("Giant")
    )

    vehicles.forEach { vehicle ->
        println(vehicle.info())
        vehicle.start()

        if (vehicle is Electric) {
            println(vehicle.batteryStatus())
        }
        println()
    }
}

---

📱 Trong Android

// Repository pattern
interface UserRepository {
    suspend fun getUser(id: Long): User?
    suspend fun saveUser(user: User)
    suspend fun deleteUser(id: Long)
}

class NetworkUserRepository(private val api: UserApi) : UserRepository {
    override suspend fun getUser(id: Long) = api.fetchUser(id)
    override suspend fun saveUser(user: User) = api.updateUser(user)
    override suspend fun deleteUser(id: Long) = api.deleteUser(id)
}

class LocalUserRepository(private val dao: UserDao) : UserRepository {
    override suspend fun getUser(id: Long) = dao.findById(id)
    override suspend fun saveUser(user: User) = dao.insert(user)
    override suspend fun deleteUser(id: Long) = dao.deleteById(id)
}

// Callback interfaces
interface OnItemClickListener<T> {
    fun onItemClick(item: T, position: Int)
    fun onItemLongClick(item: T, position: Int) = false  // Default
}

// ViewModel interface
interface LoadingState {
    val isLoading: Boolean
    val error: String?
}

class UserViewModel : ViewModel(), LoadingState {
    override var isLoading = false
    override var error: String? = null
}

---

⚠️ Lưu ý quan trọng

Ghi chú

Ưu tiên Interface over Implementation:
Khi declare types, dùng interface thay vì concrete class:

// ✅ Good - flexible
val list: List<String> = mutableListOf()

// ❌ Avoid - tight coupling
val list: MutableList<String> = mutableListOf()

Chú ý

Interface methods mặc định là public:
Không thể có private methods trong interface. Dùng abstract class nếu cần.

---

✅ Checklist - Tự kiểm tra

Sau bài học này, bạn có thể:

• Hiểu tại sao cần interface (polymorphism, loose coupling)
• Tạo interface với abstract methods
• Sử dụng default implementation
• Tạo interface properties
• Implement multiple interfaces
• Resolve conflicts khi multiple inheritance
• Phân biệt interface vs abstract class
• Áp dụng interface delegation

---

Tiếp theo: Inheritance