Πώς πραγματοποιείται η υλοποίηση διεπαφών στο Kotlin…

Οι διεπαφές στο Kotlin υλοποιούνται με τη χρήση της λέξης-κλειδιού implements (αυτονόητο στο Kotlin, απλώς δηλώνεται με άνω και κάτω τελεία) ή by για την ανάθεση.

Οι βασικοί τρόποι υλοποίησης:

Άμεση υλοποίηση: Το αντικείμενο ή η κλάση υλοποιεί όλα τα μέλη της διεπαφής άμεσα.

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

class MyClass : MyInterface {
    override fun doSomething() {
        println("Κάνοντας κάτι στο MyClass")
    }

    override val myProperty: String = "Γειά"
}

Όταν κληρονομεί από μια κλάση και υλοποιεί διεπαφές ταυτόχρονα, η κλάση δηλώνεται πρώτη.

open class BaseClass

class AnotherClass : BaseClass(), MyInterface {
    override fun doSomething() {
        println("Κάνοντας κάτι στο AnotherClass")
    }

    override val myProperty: String = "Κόσμος"
}

Ανάθεση υλοποίησης: Η υλοποίηση της διεπαφής ανατίθεται σε ένα άλλο αντικείμενο. Χρησιμοποιείται η λέξη-κλειδί by. Αυτό είναι χρήσιμο για σύνθεση και για την αποφυγή προβλημάτων πολλαπλής κληρονομικότητας.
```
interface DelegatedInterface {
    fun performAction()
}

class DelegatedObject : DelegatedInterface {
    override fun performAction() {
        println("Ενέργεια εκτελείται από το 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() // Καλεί την υλοποίηση του foo από το InterfaceA
        super<InterfaceB>.foo() // Καλεί την υλοποίηση του foo από το InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Χρησιμοποιεί την υλοποίηση του bar από το InterfaceB
    }
}

Πώς πραγματοποιείται η υλοποίηση διεπαφών στο Kotlin;