Why delegation avoids inheritance in Kotlin - See It in Action

Why Delegation Avoids Inheritance in Kotlin

📖 Scenario: Imagine you are building a simple app where different types of workers perform tasks. You want to share common behavior without making a complex family tree of classes.

🎯 Goal: You will create a Kotlin example showing how delegation can be used to share behavior between classes without using inheritance.

📋 What You'll Learn

Create an interface called Worker with a function work()

Create a class called Developer that implements Worker and prints "Writing code" when work() is called

Create a class called Manager that uses delegation to a Worker instance

Show how Manager can delegate work() to a Developer instance

Print the output of calling work() on the Manager instance

💡 Why This Matters

🌍 Real World

Delegation is used in many Kotlin projects to share behavior without deep inheritance trees, making code easier to change and test.

💼 Career

Understanding delegation helps you write cleaner Kotlin code and is a valuable skill for Android and backend Kotlin development jobs.

1

Create the Worker interface and Developer class

Create an interface called Worker with a function work() that returns Unit. Then create a class called Developer that implements Worker and overrides work() to print "Writing code".

Kotlin

# Create interface Worker with function work()
# Create class Developer implementing Worker and override work() to print "Writing code"

Hint

Use interface keyword for Worker. Implement it in Developer with override fun work().

2

Create Manager class that delegates to Worker

Create a class called Manager that takes a worker parameter of type Worker in its constructor. Use Kotlin's delegation syntax : Worker by worker to delegate work() calls to the passed worker.

Kotlin

interface Worker {
    fun work()
}

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

# Create class Manager that delegates Worker by worker
# Your code here

Hint

Use class Manager(private val worker: Worker) : Worker by worker to delegate.

3

Create Developer instance and Manager instance delegating to Developer

Create a variable called dev and assign it a new Developer() instance. Then create a variable called mgr and assign it a new Manager(dev) instance.

Kotlin

interface Worker {
    fun work()
}

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

class Manager(private val worker: Worker) : Worker by worker

# Create variable dev as Developer instance
# Create variable mgr as Manager instance delegating to dev
# Your code here

Hint

Use val dev = Developer() and val mgr = Manager(dev).

4

Call work() on Manager instance and print output

Call work() on the mgr variable and print the output.

Kotlin

interface Worker {
    fun work()
}

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

class Manager(private val worker: Worker) : Worker by worker

val dev = Developer()
val mgr = Manager(dev)

# Call work() on mgr
# Your code here

Hint

Just call mgr.work() to see delegation in action.

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