Ինչպես է իրականացվում ինտերֆեյսների իրականացմանը…

Ինտերֆեյսները Kotlin-ում իրականացվում են օգտագործելով implements բանալի բառը (ոչ հստակ Kotlin-ում, պարզապես նշվում է երկկողմանի կետով) կամ by փոխանցման համար:

Հիմնական իրականացման եղանակները՝

Ուղիղ իրականացում: Օբյեկտը կամ դասը ուղղակիորեն իրականացնում է ինտերֆեյսի բոլոր անդամները:

interface MyInterface {
    fun doSomething()
    val myProperty: String
}

class MyClass : MyInterface {
    override fun doSomething() {
        println("Doing something in MyClass")
    }

    override val myProperty: String = "Hello"
}

Երբ ժառանգում եք դասից և իրականացնում ինտերֆեյսներ միաժամանակ, դասը նշվում է առաջինը:

open class BaseClass

class AnotherClass : BaseClass(), MyInterface {
    override fun doSomething() {
        println("Doing something in AnotherClass")
    }

    override val myProperty: String = "World"
}

Ինտերֆեյսի իրականացման փոխանցում: Ինտերֆեյսի իրականացումը փոխանցվում է այլ օբյեկտին, օգտագործելով by բանալի բառը:

interface DelegatedInterface {
    fun performAction()
}

class DelegatedObject : DelegatedInterface {
    override fun performAction() {
        println("Action performed by DelegatedObject")
    }
}

class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
    // ImplementingClass փոխանցում է performAction() մեթոդի իրականացումը di օբյեկտին
}

Այս դեպքում ImplementingClass-ը ինքնուրույն չի իրականացնում performAction, փոխարենը performingClass.performAction() կանչը ուղղորդվում է di.performAction():

Երբ միաժամանակ իրականացնում եք մի քանի ինտերֆեյսներ, որոնց անդամները նույնանուն են, անհրաժեշտ է լուծել կոնֆլիկտները՝ հստակ վերագրելով անդամը և նշելով, թե որ ինտերֆեյսից է իրականացումը, օգտագործելով <Интерфейс>.<член> սինտաքսիս:

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

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

class ResolvingConflict : InterfaceA, InterfaceB {
    override fun foo() {
        super<InterfaceA>.foo() // Կոչում է InterfaceA- ի `foo` իրականացումը
        super<InterfaceB>.foo() // Կոչում է InterfaceB- ի `foo` իրականացումը
    }

    override fun bar() {
        super<InterfaceB>.bar() // Օգտագործում է InterfaceB- ի `bar` իրականացումը
    }
}

Ինչպես է իրականացվում ինտերֆեյսների իրականացմանը Kotlin-ում?