Multiple interface implementation in Kotlin - Step-by-Step Execution

Concept Flow - Multiple interface implementation

Define Interface A

↓

Define Interface B

↓

Create Class implementing A & B

↓

Override methods from A & B

↓

Create instance of Class

↓

Call methods from both interfaces

↓

Observe combined behavior

This flow shows how a class can implement multiple interfaces by overriding their methods and then using those methods through an instance.

Execution Sample

Kotlin

interface A {
    fun foo() = println("A's foo")
}
interface B {
    fun bar() = println("B's bar")
}
class C : A, B

fun main() {
    val c = C()
    c.foo()
    c.bar()
}

This code defines two interfaces A and B, a class C implementing both, and calls their methods.

Execution Table

Step	Action	Evaluation	Result
1	Define interface A with foo()	foo() prints "A's foo"	Interface A ready
2	Define interface B with bar()	bar() prints "B's bar"	Interface B ready
3	Define class C implementing A and B	C inherits foo() and bar()	Class C ready
4	Create instance c of class C	c is instance of C	Instance c created
5	Call c.foo()	Calls foo() from A	Prints: A's foo
6	Call c.bar()	Calls bar() from B	Prints: B's bar
7	Program ends	No more calls	Execution stops

💡 All interface methods called, program ends normally

Variable Tracker

Variable	Start	After Step 4	After Step 7
c	undefined	Instance of C	Instance of C (no change)

Key Moments - 2 Insights

Why can class C call both foo() and bar() methods?

Because class C implements both interfaces A and B, it inherits their methods, so calling c.foo() and c.bar() works as shown in steps 5 and 6 of the execution_table.

What happens if interfaces A and B have methods with the same name?

Then class C must override that method explicitly to resolve the conflict, which is not shown here but important to know.

Visual Quiz - 3 Questions

Look at the execution_table, what is printed when c.foo() is called at step 5?

A "foo from C"

B "B's bar"

C "A's foo"

D Nothing is printed

💡 Hint

Check the Result column at step 5 in execution_table

At which step is the instance c of class C created?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look at the Action column for instance creation in execution_table

If class C did not implement interface B, what would happen when calling c.bar() at step 6?

A It would cause a compile error

B It would print "B's bar" anyway

C It would call foo() instead

D It would print nothing

💡 Hint

Recall that c.bar() comes from interface B, see execution_table step 6

Concept Snapshot

Multiple interface implementation in Kotlin:
- Use 'class C : A, B' to implement interfaces A and B
- Override interface methods if needed
- Class inherits all interface methods
- Create instance and call methods from all interfaces
- Resolves method conflicts by overriding explicitly

Full Transcript

This example shows how Kotlin allows a class to implement multiple interfaces. Interfaces A and B each have one method. Class C implements both interfaces, inheriting their methods. When we create an instance of C and call foo() and bar(), the program prints messages from both interfaces. This demonstrates how multiple interface implementation combines behaviors from different sources into one class.

Practice

1. What does it mean when a Kotlin class implements multiple interfaces?

easy

A. The class cannot have its own functions if it implements interfaces.

B. The class can only use one interface's functions at a time.

C. The class agrees to provide all functions defined in all those interfaces.

D. The class automatically inherits properties from all interfaces without code.

Solution

1. Step 1: Understand interface implementation

   Implementing interfaces means the class must provide the functions declared in those interfaces.

2. Step 2: Check multiple interfaces

   When multiple interfaces are implemented, the class must provide all functions from each interface.

3. Final Answer:

   The class agrees to provide all functions defined in all those interfaces. -> Option C

4. Quick Check:

   Multiple interface implementation = implement all interface functions [OK]

Hint: Remember: Implementing means providing all interface functions [OK]

Common Mistakes:

• Thinking interfaces provide code automatically
• Believing only one interface's functions are needed
• Assuming class can't have its own functions

2. Which of the following is the correct syntax to declare a Kotlin class MyClass implementing interfaces InterfaceA and InterfaceB?

easy

A. class MyClass : InterfaceA, InterfaceB {}

B. class MyClass implements InterfaceA, InterfaceB {}

C. class MyClass extends InterfaceA, InterfaceB {}

D. class MyClass : InterfaceA & InterfaceB {}

Solution

1. Step 1: Recall Kotlin interface syntax

   Kotlin uses a colon (:) to implement interfaces, separated by commas.

2. Step 2: Check each option

   class MyClass : InterfaceA, InterfaceB {} uses colon and commas correctly. Options B and C use Java-like keywords. class MyClass : InterfaceA & InterfaceB {} uses & which is invalid in Kotlin.

3. Final Answer:

   class MyClass : InterfaceA, InterfaceB {} -> Option A

4. Quick Check:

   Use ':' and commas for interfaces [OK]

Hint: Use ':' and commas to list interfaces in Kotlin [OK]

Common Mistakes:

• Using 'implements' keyword like Java
• Using 'extends' for interfaces
• Using '&' to combine interfaces

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

interface A { fun greet() = println("Hello from A") }
interface B { fun greet() = println("Hello from B") }
class C : A, B {
  override fun greet() {
    super<A>.greet()
    super<B>.greet()
  }
}
fun main() {
  val c = C()
  c.greet()
}

medium

A. Hello from A\nHello from B

B. Hello from B\nHello from A

C. Hello from A

D. Compilation error due to greet() conflict

Solution

1. Step 1: Understand interface default methods

   Both interfaces A and B have greet() with default implementations.

2. Step 2: Check class C's override

   C overrides greet() and calls both super<A>.greet() and super<B>.greet() in order.

3. Step 3: Predict output

   First prints "Hello from A", then "Hello from B" on separate lines.

4. Final Answer:

   Hello from A Hello from B -> Option A

5. Quick Check:

   Calling both super interface methods prints both greetings [OK]

Hint: Use super<InterfaceName> to call specific interface method [OK]

Common Mistakes:

• Assuming compilation error due to method conflict
• Only calling one interface's greet()
• Mixing order of greetings

4. Identify the error in this Kotlin code where class D implements interfaces X and Y:

interface X { fun foo() }
interface Y { fun bar() }
class D : X, Y {
  override fun foo() { println("foo") }
}

medium

A. Cannot implement two interfaces at once

B. Missing override of bar() from interface Y

C. foo() should not be overridden

D. Class D should be abstract

Solution

1. Step 1: Check implemented interfaces

   D implements X and Y, so must override all their functions.

2. Step 2: Verify overridden functions

   D overrides foo() from X but does not override bar() from Y.

3. Step 3: Identify error

   Missing override of bar() causes compilation error.

4. Final Answer:

   Missing override of bar() from interface Y -> Option B

5. Quick Check:

   All interface functions must be overridden [OK]

Hint: Override all interface functions or make class abstract [OK]

Common Mistakes:

• Forgetting to override all interface methods
• Thinking multiple interfaces are not allowed
• Assuming override is optional

5. You have two interfaces:

interface Printer { fun print() }
interface Scanner { fun scan() }

You want a class MultiFunctionDevice that implements both and logs each action. Which is the best way to implement this?

hard

A. class MultiFunctionDevice : Scanner {
override fun scan() { println("Scanning...") }
}

B. class MultiFunctionDevice : Printer {
override fun print() { println("Printing...") }
}

C. class MultiFunctionDevice {
fun print() { println("Printing...") }
fun scan() { println("Scanning...") }
}

D. class MultiFunctionDevice : Printer, Scanner {
override fun print() { println("Printing...") }
override fun scan() { println("Scanning...") }
}

Solution

1. Step 1: Understand requirement

   MultiFunctionDevice must implement both Printer and Scanner interfaces.

2. Step 2: Check options

   class MultiFunctionDevice : Printer, Scanner { override fun print() { println("Printing...") } override fun scan() { println("Scanning...") } } implements both interfaces and overrides both functions with logging. Options A and B implement only one interface each. class MultiFunctionDevice { fun print() { println("Printing...") } fun scan() { println("Scanning...") } } does not implement interfaces.

3. Final Answer:

   class MultiFunctionDevice : Printer, Scanner { override fun print() { println("Printing...") } override fun scan() { println("Scanning...") } } -> Option D

4. Quick Check:

   Implement all interfaces and override all methods [OK]

Hint: Implement all interfaces and override all their methods [OK]

Common Mistakes:

• Implementing only one interface when multiple are needed
• Not overriding interface methods
• Not declaring interfaces in class header