Why delegation avoids inheritance in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of delegation vs inheritance example

What is the output of this Kotlin code that uses delegation instead of inheritance?

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 Runtime error: NullPointerException

B Printing from Delegator

C Compilation error due to delegation

D Printing from RealPrinter

💡 Hint

Delegation forwards calls to the object it delegates to.

The Delegator class delegates the print() call to the RealPrinter instance. So the output is from RealPrinter's print() method.

🧠 Conceptual

intermediate

Why delegation avoids tight coupling

Which reason best explains why delegation avoids tight coupling compared to inheritance?

A Delegation allows changing behavior at runtime by swapping delegate objects.

B Delegation forces all subclasses to share the same implementation.

C Delegation requires the subclass to override all methods explicitly.

D Delegation prevents code reuse across classes.

💡 Hint

Think about flexibility in changing behavior without changing class hierarchy.

Delegation lets an object forward tasks to another object that can be swapped or changed at runtime, reducing tight coupling.

🔧 Debug

advanced

Identify the error in delegation usage

What error will this Kotlin code produce and why?

Kotlin

interface Speaker {
    fun speak()
}

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

class Robot(speaker: Speaker) : Speaker by speaker {
    fun speak() {
        println("Robot speaking")
    }
}

fun main() {
    val person = Person()
    val robot = Robot(person)
    robot.speak()
}

A Prints 'Hello'

B Prints 'Robot speaking'

C Compilation error: 'speak' overrides nothing

D Runtime error: StackOverflowError

💡 Hint

Check which speak() method is called on robot.

Robot defines its own speak() method which overrides the delegated one, so 'Robot speaking' is printed.

❓ Predict Output

advanced

Output when delegation changes delegate at runtime

What is the output of this Kotlin code that changes the delegate object at runtime?

Kotlin

interface Worker {
    fun work()
}

class Developer : Worker {
    override fun work() {
        println("Writing code")
    }
}

class Tester : Worker {
    override fun work() {
        println("Testing code")
    }
}

class Manager(var worker: Worker) : Worker by worker {
    fun changeWorker(newWorker: Worker) {
        worker = newWorker
    }
}

fun main() {
    val dev = Developer()
    val test = Tester()
    val manager = Manager(dev)
    manager.work()
    manager.changeWorker(test)
    manager.work()
}

A

Writing code
Testing code

B Compilation error: delegation cannot be changed

C

Writing code
Writing code

D

Testing code
Testing code

💡 Hint

Delegation is set at object creation and does not change when the delegate variable changes.

Delegation in Kotlin is fixed at construction time. Changing the delegate variable later does not affect delegated calls.

🧠 Conceptual

expert

Why delegation is preferred over inheritance for code reuse

Which statement best explains why delegation is often preferred over inheritance for code reuse in Kotlin?

A Delegation allows combining behaviors from multiple sources without a rigid class hierarchy.

B Delegation forces all subclasses to inherit from a single parent class.

C Delegation prevents any form of polymorphism.

D Delegation requires less code but cannot be used with interfaces.

💡 Hint

Think about flexibility and combining behaviors.

Delegation lets an object reuse code by forwarding calls to multiple delegate objects, avoiding the limitations of single inheritance.