Interface declaration and implementation in Kotlin

Introduction

An interface lets you define a set of actions that different classes can share. It helps organize code by saying what actions are possible, without saying how they work.

When you want different classes to follow the same rules or actions.

When you want to write code that works with many types of objects in the same way.

When you want to separate what something does from how it does it.

When you want to make your code easier to change or add new features later.

Syntax

Kotlin

interface InterfaceName {
    fun action1()
    fun action2(): ReturnType
    // properties can also be declared
    val propertyName: Type
}

class ClassName : InterfaceName {
    override fun action1() {
        // implementation
    }
    override fun action2(): ReturnType {
        // implementation
    }
    override val propertyName: Type = value
}

Use interface keyword to declare an interface.

Classes use : to say they implement an interface and must provide all its functions and properties.

Examples

Simple interface Drivable with one function. Car class implements it by providing the drive function.

Kotlin

interface Drivable {
    fun drive()
}

class Car : Drivable {
    override fun drive() {
        println("Car is driving")
    }
}

Interface with a property. Person class implements it by overriding the property in the constructor.

Kotlin

interface Named {
    val name: String
}

class Person(override val name: String) : Named

Interface with a default function implementation. ConsoleLogger class uses the default log method without extra code.

Kotlin

interface Logger {
    fun log(message: String) {
        println("Log: $message")
    }
}

class ConsoleLogger : Logger

Sample Program

This program defines an Animal interface with a sound function. Dog and Cat classes implement it with their own sounds. The main function creates objects and calls their sounds.

Kotlin

interface Animal {
    fun sound()
}

class Dog : Animal {
    override fun sound() {
        println("Woof!")
    }
}

class Cat : Animal {
    override fun sound() {
        println("Meow!")
    }
}

fun main() {
    val dog: Animal = Dog()
    val cat: Animal = Cat()
    dog.sound()
    cat.sound()
}

Important Notes

Interfaces cannot hold state (no backing fields), only abstract properties or methods with default implementations.

Classes must use override keyword to implement interface members.

Interfaces help write flexible and reusable code by focusing on what actions are possible.

Summary

Interfaces define a contract of functions and properties without implementation details.

Classes implement interfaces by providing the actual code for the functions and properties.

This helps organize code and allows different classes to be used interchangeably.

Practice

1. What is the main purpose of an interface in Kotlin?

easy

A. To inherit implementation from multiple classes

B. To create objects directly without classes

C. To store data like variables and constants

D. To define a contract with functions and properties without implementation

Solution

1. Step 1: Understand what an interface is

   An interface in Kotlin declares functions and properties but does not provide their implementation.

2. Step 2: Compare options with interface purpose

   To define a contract with functions and properties without implementation correctly states that interfaces define a contract without implementation. Other options describe features unrelated to interfaces.

3. Final Answer:

   To define a contract with functions and properties without implementation -> Option D

4. Quick Check:

   Interface = Contract without code [OK]

Hint: Interfaces declare what, not how, functions work [OK]

Common Mistakes:

• Thinking interfaces can create objects directly
• Confusing interfaces with classes that store data
• Believing interfaces inherit from classes

2. Which of the following is the correct way to declare an interface in Kotlin?

easy

A. interface MyInterface { fun doWork() }

B. class MyInterface { fun doWork() }

C. fun interface MyInterface { fun doWork(); fun doOther() }

D. interface MyInterface() { fun doWork() }

Solution

1. Step 1: Recall Kotlin interface syntax

   Interfaces are declared with the keyword interface followed by the name and curly braces containing function declarations without parentheses after the name.

2. Step 2: Check each option

   interface MyInterface { fun doWork() } matches the correct syntax. class MyInterface { fun doWork() } uses class instead of interface. fun interface MyInterface { fun doWork() } uses fun interface which is for functional interfaces but requires a single abstract method and different usage. interface MyInterface() { fun doWork() } incorrectly adds parentheses after the interface name.

3. Final Answer:

   interface MyInterface { fun doWork() } -> Option A

4. Quick Check:

   Interface syntax = interface Name { ... } [OK]

Hint: Interfaces use 'interface' keyword without parentheses [OK]

Common Mistakes:

• Using class keyword instead of interface
• Adding parentheses after interface name
• Confusing fun interface with regular interface

3. What will be the output of the following Kotlin code?

interface Greeter {
    fun greet(): String
}

class FriendlyGreeter : Greeter {
    override fun greet() = "Hello!"
}

fun main() {
    val greeter: Greeter = FriendlyGreeter()
    println(greeter.greet())
}

medium

A. FriendlyGreeter

B. Greeter

C. Hello!

D. Compilation error

Solution

1. Step 1: Understand interface implementation

   The interface Greeter declares a function greet(). The class FriendlyGreeter implements this interface and overrides greet() to return "Hello!".

2. Step 2: Trace the main function output

   In main(), an instance of FriendlyGreeter is assigned to a variable of type Greeter. Calling greet() on this instance returns "Hello!" which is printed.

3. Final Answer:

   Hello! -> Option C

4. Quick Check:

   Interface method call returns overridden string [OK]

Hint: Interface calls use implemented class methods [OK]

Common Mistakes:

• Expecting interface name printed instead of method result
• Thinking it causes compilation error without implementation
• Confusing class name with output

4. Identify the error in this Kotlin code snippet:

interface Animal {
    fun sound(): String
}

class Dog : Animal {
    fun sound() = "Bark"
}

medium

A. Dog class must override sound() with 'override' keyword

B. Interface cannot have functions with return type

C. Dog class should not implement Animal interface

D. sound() function should be private in Dog class

Solution

1. Step 1: Check interface function implementation rules

   When a class implements an interface function, it must use the override keyword to provide the implementation.

2. Step 2: Analyze the Dog class

   The Dog class defines sound() without override. This causes a compilation error because it does not properly override the interface method.

3. Final Answer:

   Dog class must override sound() with 'override' keyword -> Option A

4. Quick Check:

   Override keyword required for interface methods [OK]

Hint: Always use 'override' when implementing interface methods [OK]

Common Mistakes:

• Omitting the override keyword
• Thinking interface methods can't have return types
• Making interface implementation optional

5. Given the interface and classes below, what will be the output when main() is run?

interface Calculator {
    fun calculate(x: Int, y: Int): Int
}

class Adder : Calculator {
    override fun calculate(x: Int, y: Int) = x + y
}

class Multiplier : Calculator {
    override fun calculate(x: Int, y: Int) = x * y
}

fun main() {
    val calculators: List<Calculator> = listOf(Adder(), Multiplier())
    for (calc in calculators) {
        println(calc.calculate(3, 4))
    }
}

hard

A. 12
7

B. 7
12

C. 34
34

D. Compilation error due to interface list

Solution

1. Step 1: Understand interface implementations

   Two classes implement Calculator: Adder adds two numbers, Multiplier multiplies them.

2. Step 2: Trace the loop output

   The list contains an Adder and a Multiplier. Calling calculate(3,4) on Adder returns 7, on Multiplier returns 12. These are printed in order.

3. Final Answer:

   7 12 -> Option B

4. Quick Check:

   Adder + Multiplier outputs 7 and 12 [OK]

Hint: Interface list calls each class's method in order [OK]

Common Mistakes:

• Mixing order of outputs
• Expecting string concatenation instead of arithmetic
• Thinking interface list causes error