Interface declaration and implementation in Kotlin - Step-by-Step Execution

Concept Flow - Interface declaration and implementation

Declare Interface

↓

Define Methods (no body)

↓

Create Class

↓

Implement Interface

↓

Provide Method Bodies

↓

Create Object

↓

Call Methods

↓

Use Implemented Behavior

First, you declare an interface with method signatures. Then, a class implements this interface by providing method bodies. Finally, you create objects and call the implemented methods.

Execution Sample

Kotlin

interface Animal {
    fun sound(): String
}

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

fun main() {
    val dog = Dog()
    println(dog.sound())
}

This code declares an interface Animal with a method sound, then a Dog class implements it, and finally prints the dog's sound.

Execution Table

Step	Action	Evaluation	Result
1	Declare interface Animal with method sound()	No body, just signature	Interface Animal ready
2	Create class Dog implementing Animal	Must override sound()	Class Dog ready
3	Override sound() in Dog	Returns "Woof"	Method sound() implemented
4	In main(), create Dog object	dog = Dog()	dog object created
5	Call dog.sound()	Calls Dog's sound()	Returns "Woof"
6	Print returned value	Prints "Woof"	Output: Woof
7	Program ends	No more instructions	Execution stops

💡 Program ends after printing the dog's sound.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
dog	undefined	Dog object created	Dog object used to call sound()	Dog object remains

Key Moments - 3 Insights

Why does the interface method have no body?

Interfaces only declare method signatures without bodies, as shown in step 1 of the execution_table. The actual method body is provided in the implementing class (step 3).

What does 'override' mean in the class?

'override' means the class provides its own version of the interface method. Step 3 shows Dog overriding sound() to return "Woof".

Why can we call dog.sound() even though sound() is declared in the interface?

Because Dog implements the interface and provides the method body (step 3), so calling dog.sound() uses Dog's version (step 5).

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of calling dog.sound() at step 5?

A No output

B "Meow"

C "Woof"

D Error

💡 Hint

Check the 'Evaluation' and 'Result' columns at step 5 in the execution_table.

At which step is the Dog object created?

A Step 2

B Step 4

C Step 6

D Step 1

💡 Hint

Look for the action mentioning 'create Dog object' in the execution_table.

If the Dog class did not override sound(), what would happen when calling dog.sound()?

A Compilation error because sound() is not implemented

B It would print "Woof" anyway

C It would print nothing

D It would call a default sound() from interface

💡 Hint

Interfaces require implementing all methods; see step 3 about overriding sound().

Concept Snapshot

interface InterfaceName {
    fun methodName(): ReturnType
}

class ClassName : InterfaceName {
    override fun methodName() = implementation
}

- Interfaces declare method signatures only.
- Classes must override all interface methods.
- Objects of the class use implemented methods.

Full Transcript

This visual execution shows how Kotlin interfaces work. First, an interface named Animal is declared with a method sound() that has no body. Then, a class Dog implements Animal and overrides sound() to return "Woof". In the main function, a Dog object is created and its sound() method is called, printing "Woof". The execution table traces each step from interface declaration to method call and output. Variables like dog are tracked through creation and usage. Key moments clarify why interfaces have no method bodies, the meaning of override, and how method calls work through the interface. The quiz tests understanding of method results, object creation, and implementation requirements. The snapshot summarizes syntax and rules for interface declaration and implementation in Kotlin.

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