Multiple interface implementation in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean to implement multiple interfaces in Kotlin?

It means a class can follow the rules (methods and properties) of more than one interface, allowing it to have behaviors from all those interfaces.

beginner

How do you declare a class that implements two interfaces named A and B in Kotlin?

Use a colon and separate the interfaces with commas, like: <br> <code>class MyClass : A, B { ... }</code>

intermediate

If two interfaces have a method with the same name, how does Kotlin handle it when a class implements both?

Kotlin requires the class to override the method and explicitly specify which interface's method to use or provide its own implementation.

intermediate

What keyword is used in Kotlin to call a specific interface's method implementation inside an overriding method?

The keyword is super with the interface name, like super<InterfaceName>.method().

beginner

Why is multiple interface implementation useful in Kotlin?

It allows a class to combine different behaviors from multiple sources without inheriting from multiple classes, which Kotlin does not support.

How do you declare a Kotlin class that implements interfaces A and B?

A class MyClass implements A, B

B class MyClass : A, B

C class MyClass extends A, B

D class MyClass inherits A, B

In Kotlin, use a colon and separate interfaces with commas: class MyClass : A, B

What must you do if two interfaces have a method with the same name and your class implements both?

A Rename one of the interface methods

B Nothing, Kotlin handles it automatically

C Override the method and specify which interface's method to use

D Use inheritance instead of interfaces

Kotlin requires you to override the method and explicitly choose or provide your own implementation.

Which keyword lets you call a specific interface's method inside an overriding method?

A super<InterfaceName>.method()

B base.method()

C this.method()

D parent.method()

Use super with the interface name in angle brackets to call that interface's method.

Why can't Kotlin classes inherit from multiple classes?

A Because Kotlin supports multiple interface implementation instead

B Because Kotlin does not support inheritance

C Because interfaces are the same as classes

D Because Kotlin only supports single inheritance

Kotlin supports only single class inheritance but allows multiple interfaces to be implemented.

What is the main benefit of implementing multiple interfaces?

A Combining behaviors from different sources without multiple class inheritance

B Making code run faster

C Avoiding the use of classes

D Automatically resolving method conflicts

Multiple interfaces let a class have many behaviors without inheriting from multiple classes.

Explain how Kotlin handles method conflicts when a class implements multiple interfaces with the same method name.

Think about how you tell Kotlin which method to use.

Describe the syntax to implement multiple interfaces in a Kotlin class and why this is useful.

Focus on the declaration and the benefit.

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