როგორ ხორციელდება ინტერფეისების რეალიზაცია Kotlin-ში?

Kotlin- ში ინტერფეისები რეალიზდება საკვანძო სიტყვა implements-ის გამოყენებით (Kotlin- ში არ არის პირდაპირი, უბრალოდ მითითებულია ორწერტილიანი წერტილით) ან by გადაცემისთვის:

ძირითადი რეალიზაციის გზები:

1. მხოლოდ პირდაპირი რეალიზაცია: ობიექტი ან კლასი პირდაპირ რეალიზებს ყველა წევრს ინტერფეისის.

   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"
   }
   

2. რეალიზაციის დელეგირება: ინტერფეისის რეალიზაცია გადაეცემა სხვა ობიექტს. გამოიყენება 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-ის რეალიზაციას
    }
}