Why Interface declaration and implementation in Kotlin? - Purpose & Use Cases

The Big Idea

What if you could write one plan and have many different characters follow it perfectly without confusion?

The Scenario

Imagine you are building a game where different characters can perform actions like jump, run, or attack. Without a clear plan, you write separate code for each character, repeating similar actions again and again.

The Problem

This manual way is slow and confusing. If you want to add a new character or change an action, you must update many places. Mistakes happen easily, and your code becomes messy and hard to fix.

The Solution

Interfaces let you define a clear list of actions that any character must have. You write the action rules once, then each character promises to follow them. This keeps your code neat, easy to update, and everyone knows what to expect.

Before vs After

✗ Before

class Knight {
  fun attack() { /* code */ }
}
class Archer {
  fun attack() { /* code */ }
}

✓ After

interface Fighter {
  fun attack()
}
class Knight : Fighter {
  override fun attack() { /* code */ }
}
class Archer : Fighter {
  override fun attack() { /* code */ }
}

What It Enables

Interfaces make your code flexible and organized, so you can add new features easily without breaking what already works.

Real Life Example

Think of a remote control that works with many devices. The remote defines buttons (interface), and each device implements how those buttons work, so you can control TVs, music players, or lights with the same remote.

Key Takeaways

Interfaces define a clear set of actions to follow.

They help avoid repeating code and reduce errors.

They make adding new features easier and safer.

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