interface

// Define an interface
interface Drawable {
    fun draw()  // Abstract method (must be overridden)
    fun clear() = println("Clearing")  // Default implementation
    val color: String  // Abstract property
}

// Implement the interface
class Circle(override val color: String) : Drawable {
    override fun draw() = println("Drawing a $color circle")
}

// Implement multiple interfaces
class Button : Drawable, Clickable {
    override val color = "Blue"
    override fun draw() = println("Drawing a button")
    override fun onClick() = println("Button clicked")
}

// Define interfaces
interface Animal {
    val name: String
    fun sound(): String
    fun introduce() = println("I am ${name}. I say ${sound()}.")
}

interface Pet {
    fun play() = println("Playing!")
    fun groom() = println("Grooming...")
}

// Implement multiple interfaces
class Dog(override val name: String) : Animal, Pet {
    override fun sound() = "Woof"
    override fun play() {
        super.play()  // Call the default implementation
        println("  Fetching the ball!")
    }
}

class Cat(override val name: String) : Animal, Pet {
    override fun sound() = "Meow"
}

// Resolving conflicting default implementations
interface A {
    fun hello() = println("Hello from A")
}
interface B {
    fun hello() = println("Hello from B")
}
class C : A, B {
    // When both interfaces have a default implementation, you must explicitly choose one.
    override fun hello() {
        super<A>.hello()
        super<B>.hello()
        println("Additional logic in C")
    }
}

fun main() {
    val dog = Dog("Rex")
    dog.introduce()   // Animal default implementation
    dog.play()        // Overridden method
    dog.groom()       // Pet default implementation

    println()

    val cat = Cat("Whiskers")
    cat.introduce()

    println()

    // Treat objects as their interface type
    val animals: List<Animal> = listOf(Dog("Buddy"), Cat("Luna"))
    animals.forEach { it.introduce() }

    println()

    // Resolve conflicting default implementations
    C().hello()
}

Kotlin interfaces support default implementations, giving them similar capabilities to Java 8 interfaces. However, interfaces cannot hold state (field values) — properties must either be computed via a getter or delegated to the implementing class.

When two interfaces share a default implementation with the same name, the implementing class must explicitly select one using super<InterfaceName>.method().

For the difference between interfaces and inheritance, see open / override. For the singleton pattern, see object / companion object.