Why delegation avoids inheritance in Kotlin - Visual Breakdown

Concept Flow - Why delegation avoids inheritance

Start

↓

Define Interface

↓

Create Class A (implements Interface)

↓

Create Class B (delegates to Class A)

↓

Use Class B instance

↓

Calls forwarded to Class A

↓

Avoids inheritance issues

↓

End

Shows how delegation forwards calls to another class instead of inheriting, avoiding tight coupling and allowing flexible behavior.

Execution Sample

Kotlin

interface Printer {
    fun print()
}

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

class DelegatingPrinter(printer: Printer) : Printer by printer

fun main() {
    val real = RealPrinter()
    val delegator = DelegatingPrinter(real)
    delegator.print()
}

This code shows a class delegating the print() call to another class instead of inheriting from it.

Execution Table

Step	Action	Evaluation	Result
1	Create RealPrinter instance	RealPrinter()	real = RealPrinter instance
2	Create DelegatingPrinter with real	DelegatingPrinter(real)	delegator delegates to real
3	Call delegator.print()	delegator.print()	Call forwarded to real.print()
4	real.print() executes	println("Printing from RealPrinter")	Output: Printing from RealPrinter
5	End of main	No more calls	Program ends

💡 Program ends after delegator.print() call is forwarded and executed

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
real	null	RealPrinter instance	RealPrinter instance	RealPrinter instance	RealPrinter instance
delegator	null	null	DelegatingPrinter instance (delegates to real)	DelegatingPrinter instance	DelegatingPrinter instance

Key Moments - 3 Insights

Why doesn't DelegatingPrinter inherit from RealPrinter?

DelegatingPrinter uses delegation to forward calls to RealPrinter instead of inheriting, so it avoids tight coupling and allows changing behavior by swapping the delegate (see execution_table step 2 and 3).

How does delegator.print() call reach RealPrinter's print()?

Delegation automatically forwards the print() call from DelegatingPrinter to the RealPrinter instance it holds (see execution_table step 3 and 4).

What problem does delegation solve compared to inheritance?

Delegation avoids the rigid class hierarchy and tight coupling of inheritance by forwarding calls to a contained object, allowing more flexible code reuse (see concept_flow and execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'delegator' after step 2?

A RealPrinter instance

B DelegatingPrinter instance delegating to real

C null

D Printer interface

💡 Hint

Check variable_tracker row for 'delegator' after step 2

At which step does the actual print output happen?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at execution_table where println is called

If DelegatingPrinter inherited from RealPrinter instead of delegating, what would change?

A DelegatingPrinter would be tightly coupled to RealPrinter

B Delegation would be more flexible

C Calls would still be forwarded automatically

D No difference in behavior

💡 Hint

Refer to key_moments about inheritance vs delegation

Concept Snapshot

Delegation in Kotlin lets a class forward interface calls to another object.
Syntax: class B(printer: Printer) : Printer by printer
Avoids tight coupling of inheritance.
Allows flexible behavior by swapping delegate.
Calls to B are forwarded to the delegate object.
Useful to reuse code without subclassing.

Full Transcript

This example shows how delegation avoids inheritance in Kotlin. We define an interface Printer with a print() function. RealPrinter implements Printer and prints a message. DelegatingPrinter takes a Printer object and delegates all calls to it using 'by'. When we call print() on DelegatingPrinter, it forwards the call to RealPrinter's print(). This avoids inheritance's tight coupling and rigid hierarchy by forwarding calls to a contained object. The execution table traces creating instances and forwarding calls step-by-step. Variable tracker shows how variables change. Key moments clarify why delegation is preferred over inheritance here. The visual quiz tests understanding of delegation flow and differences from inheritance. The snapshot summarizes delegation syntax and benefits in Kotlin.