1.1.50.9. fejezet, Interfészek

Beküldte pzoli - 2024, április 20 - 6:45du 
interface MyInterface {
    fun bar()
    fun foo() {
      // optional body
    }
}

Metódus implementálása:

class Child : MyInterface {
    override fun bar() {
        // body
    }
}

Tulajdonságok deklarálása

interface MyInterface {
    val prop: Int // abstract
 
    val propertyWithImplementation: String
        get() = "foo"
 
    fun foo() {
        print(prop)
    }
}
 
class Child : MyInterface {
    override val prop: Int = 29
}

Öröklődés

interface Named {
    val name: String
}
 
interface Person : Named {
    val firstName: String
    val lastName: String
 
    override val name: String get() = "$firstName $lastName"
}
 
data class Employee(
    // implementing 'name' is not required
    override val firstName: String,
    override val lastName: String,
    val position: Position
) : Person

A data class adattárolásra szolgáló osztály, amihez a kotlin automatikusan generál bizonyos metódusokat (lásd itt).

Felülírási konfliktusok feloldása

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

Funkcionális interfészek (SAM = SingleAbstractMethod)

Ezek az interfészek csak egy absztrakt metódussal rendelkeznek. Lehet több nem absztrakt része, de csak egy absztrakt metódusa.

fun interface KRunnable {
   fun invoke()
}

A funkcionális interfészek esetén használhatsz SAM konverziókat, amelyek segítenek a kódodat tömörebbé és olvashatóbbá tenni lambda kifejezések használatával. Vegyük a következő példa interfészt:

fun interface IntPredicate {
   fun accept(i: Int): Boolean
}

Ha nem használsz SAM konverziót, akkor így kell megírnod a kódot:

// Creating an instance of a class
val isEven = object : IntPredicate {
   override fun accept(i: Int): Boolean {
       return i % 2 == 0
   }
}

Ha használod a SAM konverziót, így implementálhatod a kódot:

val isEven = IntPredicate { it % 2 == 0 }

A kód tehát így néz ki:

fun interface IntPredicate {
   fun accept(i: Int): Boolean
}
 
val isEven = IntPredicate { it % 2 == 0 }
 
fun main() {
   println("Is 7 even? - ${isEven.accept(7)}")
}

Típus aliaszok:

typealias IntPredicate = (i: Int) -> Boolean
 
val isEven: IntPredicate = { it % 2 == 0 }
 
fun main() {
   println("Is 7 even? - ${isEven(7)}")
}