Delegation vs inheritance decision in Kotlin - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of delegation example

What is the output of this Kotlin code using delegation?

Kotlin

interface Printer {
    fun print()
}

class RealPrinter : Printer {
    override fun print() {
        println("Printing from RealPrinter")
    }
}

class Delegator(printer: Printer) : Printer by printer

fun main() {
    val realPrinter = RealPrinter()
    val delegator = Delegator(realPrinter)
    delegator.print()
}

A Printing from RealPrinter

B Runtime exception

C Compilation error

D Printing from Delegator

💡 Hint

Delegation forwards calls to the provided object.

The Delegator class delegates the print() call to RealPrinter, so the output is from RealPrinter.

❓ Predict Output

intermediate

Output of inheritance example

What is the output of this Kotlin code using inheritance?

Kotlin

open class Printer {
    open fun print() {
        println("Printing from Printer")
    }
}

class ChildPrinter : Printer() {
    override fun print() {
        println("Printing from ChildPrinter")
    }
}

fun main() {
    val printer: Printer = ChildPrinter()
    printer.print()
}

A Printing from Printer

B Compilation error

C Runtime exception

D Printing from ChildPrinter

💡 Hint

Inheritance allows overriding methods.

ChildPrinter overrides print(), so calling print() on a ChildPrinter instance prints its own message.

🧠 Conceptual

advanced

Choosing delegation over inheritance

Which scenario best justifies using delegation instead of inheritance in Kotlin?

A When you want to reuse code but avoid tight coupling and allow changing behavior at runtime

B When you want to create a strict type hierarchy with shared implementation

C When you want to override a method in a subclass to change behavior

D When you want to prevent any changes to the base class behavior

💡 Hint

Delegation allows flexible behavior without inheritance constraints.

Delegation allows an object to use another object's functionality without inheriting from it, enabling loose coupling and runtime behavior changes.

❓ Predict Output

advanced

Output with delegation and overridden method

What is the output of this Kotlin code where delegation is combined with an overridden method?

Kotlin

interface Speaker {
    fun speak()
}

class EnglishSpeaker : Speaker {
    override fun speak() {
        println("Hello")
    }
}

class CustomSpeaker(private val speaker: Speaker) : Speaker by speaker {
    override fun speak() {
        println("Custom speak start")
        speaker.speak()
        println("Custom speak end")
    }
}

fun main() {
    val english = EnglishSpeaker()
    val custom = CustomSpeaker(english)
    custom.speak()
}

A Compilation error

B

Custom speak start
Hello
Custom speak end

C

Custom speak start
Custom speak end

D Hello

💡 Hint

Overriding a delegated method allows adding behavior before and after delegation.

CustomSpeaker overrides speak() to add prints before and after calling the delegated speaker's speak().

🧠 Conceptual

expert

Why avoid inheritance for behavior reuse?

Why might inheritance be a poor choice for reusing behavior compared to delegation in Kotlin?

A Inheritance cannot override methods, delegation can

B Inheritance is slower at runtime than delegation

C Inheritance creates tight coupling and limits flexibility, while delegation allows composition and runtime behavior changes

D Inheritance requires more code to implement than delegation

💡 Hint

Think about coupling and flexibility differences.

Inheritance tightly couples classes and fixes behavior at compile time, while delegation composes behavior and allows changing it dynamically.