All courses > Information Technology > App Development ::

10. Interfaces in Kotlin

Page 10 | Listen in audio

In Kotlin, interfaces play a crucial role in defining the contract for classes, allowing developers to specify what methods a class should implement without dictating how they should do so. This is particularly useful in Android app development, where modularity and flexibility are key to building scalable applications.

Unlike abstract classes, interfaces in Kotlin can contain abstract methods as well as method implementations. This is a significant departure from Java, where interfaces can only contain abstract methods (prior to Java 8). In Kotlin, interfaces can have properties and can also provide default implementations for methods, which makes them highly versatile.

Defining an Interface

To define an interface in Kotlin, you use the interface keyword. Here’s a simple example:

interface Clickable {
    fun click()
    fun showOff() = println("I'm clickable!")
}

In this example, the Clickable interface declares an abstract method click() and a method showOff() with a default implementation. Any class that implements this interface will need to provide an implementation for click(), but it can use the default implementation of showOff() or override it.

Implementing Interfaces

To implement an interface in a class, you use the : symbol followed by the interface name. Here’s an example:

class Button : Clickable {
    override fun click() {
        println("Button clicked")
    }
}

In this example, the Button class implements the Clickable interface. It provides an implementation for the click() method. The showOff() method can be used as is, or it can be overridden if desired:

class Button : Clickable {
    override fun click() {
        println("Button clicked")
    }

    override fun showOff() {
        println("I'm a button and I'm clickable!")
    }
}

Multiple Interfaces

Kotlin allows a class to implement multiple interfaces, which is a powerful feature for creating flexible and reusable components. Here’s how you can do it:

interface Focusable {
    fun setFocus(b: Boolean) = println("I ${if (b) "got" else "lost"} focus.")
}

class Button : Clickable, Focusable {
    override fun click() {
        println("Button clicked")
    }

    override fun showOff() {
        println("I'm a button and I'm clickable and focusable!")
    }
}

In this example, the Button class implements both the Clickable and Focusable interfaces. It provides an implementation for the click() method and overrides the showOff() method from the Clickable interface. The setFocus() method from the Focusable interface is used as is.

Interface Properties

Interfaces in Kotlin can also contain properties. These properties can either be abstract or have accessor implementations. Here’s an example:

interface User {
    val nickname: String
    val email: String
        get() = "[email protected]"
}

class PrivateUser(override val nickname: String) : User

class SubscribingUser(val emailAddress: String) : User {
    override val nickname: String
        get() = emailAddress.substringBefore('@')
}

In this example, the User interface declares a property nickname without an accessor implementation, making it abstract. It also declares a property email with a default accessor implementation. The PrivateUser class provides its own implementation for nickname, while the SubscribingUser class provides a custom implementation for nickname and uses the default implementation for email.

Resolving Interface Conflicts

When a class implements multiple interfaces that have methods with the same signature, you need to explicitly specify which implementation to use. This is done using the super keyword. Here’s an example:

interface A {
    fun showOff() = println("I'm A!")
}

interface B {
    fun showOff() = println("I'm B!")
}

class C : A, B {
    override fun showOff() {
        super.showOff()
        super.showOff()
    }
}