Why delegation avoids inheritance in Kotlin - Performance Analysis

Time Complexity: Why delegation avoids inheritance

O(n)

Understanding Time Complexity

We want to see how using delegation instead of inheritance affects the time it takes for a program to run.

Specifically, how does the program's work grow when it uses delegation compared to inheritance?

Scenario Under Consideration

Analyze the time complexity of the following Kotlin code using delegation.

interface Printer {
    fun print()
}

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

class DelegatingPrinter(private val printer: Printer) : Printer by printer

fun main() {
    val realPrinter = RealPrinter()
    val delegatingPrinter = DelegatingPrinter(realPrinter)
    delegatingPrinter.print()
}
    

This code shows a class using delegation to pass print calls to another class instead of inheriting from it.

Identify Repeating Operations

Look for repeated actions that affect time.

• Primary operation: Calling the print() method through delegation.
• How many times: Each call to print() is forwarded once to the real printer.

How Execution Grows With Input

Each print call goes through delegation once, so the work grows directly with how many times print() is called.

Input Size (n)	Approx. Operations
10	10 calls forwarded once each
100	100 calls forwarded once each
1000	1000 calls forwarded once each

Pattern observation: The number of operations grows directly with the number of calls, no extra repeated work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of method calls, without extra overhead from delegation.

Common Mistake

[X] Wrong: "Delegation adds a lot of extra work compared to inheritance because it calls methods twice."

[OK] Correct: Delegation forwards calls directly once, so it does not double the work. It just passes the call along efficiently.

Interview Connect

Understanding how delegation affects time helps you explain design choices clearly and shows you know how code structure impacts performance.

Self-Check

"What if the delegated method called another delegated method inside? How would that affect the time complexity?"

Practice

1. Why does Kotlin prefer delegation over inheritance in many cases?

easy

A. Inheritance is not supported in Kotlin.

B. Delegation requires less code than inheritance.

C. Delegation allows sharing behavior without tightly coupling classes.

D. Delegation makes classes run faster.

Solution

1. Step 1: Understand inheritance coupling

   Inheritance creates a strong link between parent and child classes, making changes harder.

2. Step 2: Understand delegation flexibility

   Delegation shares behavior by forwarding calls, avoiding tight coupling and allowing easier changes.

3. Final Answer:

   Delegation allows sharing behavior without tightly coupling classes. -> Option C

4. Quick Check:

   Delegation avoids tight coupling = A [OK]

Hint: Delegation shares behavior without tight class links [OK]

Common Mistakes:

• Thinking delegation is faster than inheritance
• Believing Kotlin does not support inheritance
• Confusing delegation with less code requirement

2. Which Kotlin syntax correctly shows delegation to an interface Printer by a class Document?

easy

A. class Document(printer: Printer) : Printer by printer

B. class Document : Printer(printer)

C. class Document implements Printer by printer

D. class Document extends Printer by printer

Solution

1. Step 1: Recall Kotlin delegation syntax

   Kotlin uses class ClassName(...) : Interface by instance to delegate.

2. Step 2: Match syntax to options

   class Document(printer: Printer) : Printer by printer matches the correct Kotlin delegation syntax exactly.

3. Final Answer:

   class Document(printer: Printer) : Printer by printer -> Option A

4. Quick Check:

   Delegation syntax uses ': Interface by instance' = B [OK]

Hint: Look for ': Interface by instance' syntax in Kotlin delegation [OK]

Common Mistakes:

• Using 'implements' or 'extends' keywords (Java style)
• Placing delegation inside parentheses incorrectly
• Confusing inheritance syntax with delegation

3. What is the output of this Kotlin code?

interface Logger {
    fun log(msg: String)
}

class ConsoleLogger : Logger {
    override fun log(msg: String) {
        println("Console: $msg")
    }
}

class FileLogger : Logger {
    override fun log(msg: String) {
        println("File: $msg")
    }
}

class Application(logger: Logger) : Logger by logger

fun main() {
    val app = Application(ConsoleLogger())
    app.log("Start")
}

medium

A. File: Start

B. Console: Start

C. Application: Start

D. No output

Solution

1. Step 1: Identify delegated logger instance

   The Application class delegates Logger to the passed instance, here ConsoleLogger.

2. Step 2: Trace the log call

   Calling app.log("Start") calls ConsoleLogger.log, printing "Console: Start".

3. Final Answer:

   Console: Start -> Option B

4. Quick Check:

   Delegation calls ConsoleLogger.log = A [OK]

Hint: Delegation calls methods on passed instance, check which one is used [OK]

Common Mistakes:

• Assuming FileLogger is used instead of ConsoleLogger
• Expecting Application prefix in output
• Thinking no output occurs without explicit print

4. Find the error in this Kotlin delegation code:

interface Worker {
    fun work()
}

class Engineer : Worker {
    override fun work() {
        println("Engineering work")
    }
}

class Manager(worker: Worker) : Worker {
    override fun work() {
        println("Managing")
    }
}

medium

A. Manager should delegate work to Worker using 'by' keyword.

B. Engineer class must not override work method.

C. Interface Worker cannot be implemented by classes.

D. Manager class should not have a constructor parameter.

Solution

1. Step 1: Check delegation usage

   Manager has a Worker parameter but does not delegate using 'by', so delegation is missing.

2. Step 2: Identify correct delegation syntax

   To delegate, Manager should declare: class Manager(worker: Worker) : Worker by worker.

3. Final Answer:

   Manager should delegate work to Worker using 'by' keyword. -> Option A

4. Quick Check:

   Missing 'by' keyword for delegation = D [OK]

Hint: Delegation requires ': Interface by instance' syntax [OK]

Common Mistakes:

• Thinking override is not needed in Engineer
• Believing interfaces can't be implemented
• Assuming constructor parameters are disallowed

5. You want to combine behaviors of two interfaces Reader and Writer in one class without inheritance. Which Kotlin approach best avoids inheritance problems?

hard

A. Copy all methods from Reader and Writer into one class manually.

B. Create a class that inherits from both interfaces directly.

C. Use inheritance from one interface and implement the other manually.

D. Use delegation to both interfaces by passing separate instances.

Solution

1. Step 1: Understand multiple inheritance issues

   Inheriting from multiple interfaces can cause tight coupling and complexity.

2. Step 2: Use delegation to combine behaviors safely

   Delegation allows combining behaviors by forwarding calls to separate instances, avoiding inheritance problems.

3. Final Answer:

   Use delegation to both interfaces by passing separate instances. -> Option D

4. Quick Check:

   Delegation combines behaviors safely = C [OK]

Hint: Delegate multiple interfaces to separate instances to avoid inheritance issues [OK]

Common Mistakes:

• Trying multiple inheritance which Kotlin disallows
• Manually copying methods causing code duplication
• Mixing inheritance and manual implementation causing complexity