Kotlin Interface

interface Clickable {
    fun click() // Abstract method, requires implementation
    
    fun hover() { // Concrete method with default implementation
        println("Hovering")
    }
}

class Button : Clickable {
    override fun click() {
        println("Button clicked")
    }
    // hover() is inherited automatically, but can be overridden
}

interface User {
    val id: String // Abstract property, must be overridden in implementing class
    
    val role: String
        get() = "Guest" // Property with custom getter, no backing field
        
    // var count: Int = 0 // ERROR: Property initializers are not allowed in interfaces
}

class StandardUser(override val id: String) : User

interface A {
    fun execute() { println("A") }
}

interface B {
    fun execute() { println("B") }
}

class C : A, B {
    override fun execute() {
        super<A>.execute() // Invokes A's implementation
        super<B>.execute() // Invokes B's implementation
    }
}

interface Named {
    val name: String
}

interface Person : Named {
    val firstName: String
    val lastName: String
    
    // Overriding the inherited abstract property with a custom getter
    override val name: String 
        get() = "$firstName $lastName"
}

class Employee(
    override val firstName: String,
    override val lastName: String
) : Person // 'name' is already implemented by the Person interface

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

// Instantiation via SAM conversion (lambda)
val isEven = IntPredicate { it % 2 == 0 }