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.