Kotlin 接口 #

interface Clickable {
    fun click()
}

class Button : Clickable {
    override fun click() {
        println("Button clicked")
    }
}

val button = Button()
button.click()

interface Clickable {
    fun click()
}

interface Focusable {
    fun focus()
}

class Button : Clickable, Focusable {
    override fun click() {
        println("Clicked")
    }
    
    override fun focus() {
        println("Focused")
    }
}

interface Drawable {
    fun draw()  // 抽象方法，没有方法体
}

class Circle : Drawable {
    override fun draw() {
        println("Drawing circle")
    }
}

interface Clickable {
    fun click()
    
    fun doubleClick() {
        click()
        click()
    }
}

class Button : Clickable {
    override fun click() {
        println("Clicked")
    }
    // doubleClick 使用默认实现
}

val button = Button()
button.doubleClick()  // Clicked Clicked

interface Clickable {
    fun click()
    
    fun doubleClick() {
        click()
        click()
    }
}

class SpecialButton : Clickable {
    override fun click() {
        println("Clicked")
    }
    
    override fun doubleClick() {
        println("Special double click")
    }
}

interface Vehicle {
    val speed: Int  // 抽象属性
}

class Car : Vehicle {
    override val speed: Int = 100
}

interface Vehicle {
    val speed: Int
    
    val maxSpeed: Int
        get() = 200
}

class Car : Vehicle {
    override val speed: Int = 100
    // maxSpeed 使用默认实现
}

interface Vehicle {
    val speed: Int
}

class Car(override val speed: Int) : Vehicle

interface Clickable {
    fun click()
}

interface DoubleClickable : Clickable {
    fun doubleClick()
}

class Button : DoubleClickable {
    override fun click() {
        println("Clicked")
    }
    
    override fun doubleClick() {
        println("Double clicked")
    }
}

interface Readable {
    fun read(): String
}

interface Writable {
    fun write(data: String)
}

interface Storage : Readable, Writable {
    fun clear()
}

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

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

class C : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }
    
    override fun bar() {
        super<B>.bar()
    }
}

interface Base {
    fun message(): String
}

interface A : Base {
    override fun message() = "A"
}

interface B : Base {
    override fun message() = "B"
}

class C : A, B {
    override fun message(): String {
        return super<A>.message()  // 选择 A 的实现
    }
}

fun interface ClickListener {
    fun onClick()
}

// 使用 Lambda
val listener = ClickListener { println("Clicked") }
listener.onClick()

fun interface Predicate<T> {
    fun test(value: T): Boolean
}

val isEven = Predicate<Int> { it % 2 == 0 }
isEven.test(4)  // true

// 使用接口：定义行为
interface Clickable {
    fun click()
}

// 使用抽象类：共享实现
abstract class BaseAdapter {
    protected val items = mutableListOf<Any>()
    
    abstract fun bind(holder: ViewHolder, position: Int)
    
    fun getItemCount() = items.size
}

interface Observer<T> {
    fun onUpdate(data: T)
}

interface Observable<T> {
    fun subscribe(observer: Observer<T>)
    fun unsubscribe(observer: Observer<T>)
    fun notifyObservers(data: T)
}

class NewsAgency : Observable<String> {
    private val observers = mutableListOf<Observer<String>>()
    
    override fun subscribe(observer: Observer<String>) {
        observers.add(observer)
    }
    
    override fun unsubscribe(observer: Observer<String>) {
        observers.remove(observer)
    }
    
    override fun notifyObservers(data: String) {
        observers.forEach { it.onUpdate(data) }
    }
    
    fun publish(news: String) {
        notifyObservers(news)
    }
}

class NewsReader(val name: String) : Observer<String> {
    override fun onUpdate(data: String) {
        println("$name received: $data")
    }
}

interface PaymentStrategy {
    fun pay(amount: Double)
}

class CreditCardPayment : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Paid $amount by credit card")
    }
}

class PayPalPayment : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Paid $amount by PayPal")
    }
}

class ShoppingCart {
    private var strategy: PaymentStrategy? = null
    
    fun setPaymentStrategy(strategy: PaymentStrategy) {
        this.strategy = strategy
    }
    
    fun checkout(amount: Double) {
        strategy?.pay(amount) ?: println("No payment method selected")
    }
}

interface Callback<T> {
    fun onSuccess(result: T)
    fun onError(error: Exception)
}

fun fetchData(callback: Callback<String>) {
    try {
        val data = "Data from server"
        callback.onSuccess(data)
    } catch (e: Exception) {
        callback.onError(e)
    }
}

fetchData(object : Callback<String> {
    override fun onSuccess(result: String) {
        println("Success: $result")
    }
    
    override fun onError(error: Exception) {
        println("Error: ${error.message}")
    }
})

// 推荐：形容词或名词
interface Clickable
interface Drawable
interface Repository

// 不推荐：动词
// interface Click
// interface Draw

// 推荐：职责单一
interface Readable {
    fun read(): String
}

interface Writable {
    fun write(data: String)
}

// 不推荐：职责过多
// interface Storage {
//     fun read(): String
//     fun write(data: String)
//     fun delete()
//     fun compress()
// }

// 推荐：单方法接口使用 fun interface
fun interface OnClickListener {
    fun onClick()
}

// 使用 Lambda 简化
button.setOnClickListener { println("Clicked") }