Why delegation avoids inheritance in Kotlin - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to delegate the print function to the printer object.

Kotlin

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

class Document(val printer: Printer) {
    fun print() = printer.[1]()
}

Drag options to blanks, or click blank then click option'

AprintDocument

Bprint

Cprintln

Ddisplay

Attempts:

3 left

💡 Hint

Common Mistakes

Using println instead of print causes a compilation error.

Calling a non-existent method like printDocument or display.

The print function in Document delegates the call to the print function of the Printer object.

2fill in blank

medium

Complete the code to use Kotlin's delegation syntax for the interface Printer.

Kotlin

interface Printer {
    fun print()
}

class RealPrinter : Printer {
    override fun print() {
        println("Real printing")
    }
}

class Document(printer: Printer) : Printer by [1] {
}

fun main() {
    val doc = Document(RealPrinter())
    doc.print()
}

Drag options to blanks, or click blank then click option'

Aprinter

BRealPrinter()

Cthis

DDocument()

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'RealPrinter()' directly instead of the parameter name.

Using 'this' or 'Document()' which are incorrect here.

The class Document delegates the Printer interface implementation to the printer object passed in the constructor.

3fill in blank

hard

Fix the error by completing the code to delegate the interface correctly.

Kotlin

interface Logger {
    fun log(message: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) {
        println("Log: $message")
    }
}

class Service : Logger by [1] {
}

fun main() {
    val service = Service()
    service.log("Started")
}

Drag options to blanks, or click blank then click option'

Athis

BConsoleLogger

CConsoleLogger()

DLogger()

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name without parentheses causes an error.

Using 'this' or 'Logger()' which are invalid here.

The delegation requires an instance of ConsoleLogger, so ConsoleLogger() is correct.

4fill in blank

hard

Fill both blanks to create a class that delegates Logger and adds a new function.

Kotlin

interface Logger {
    fun log(message: String)
}

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

class AppLogger([1]: Logger) : Logger by [2] {
    fun error(message: String) {
        log("Error: $message")
    }
}

Drag options to blanks, or click blank then click option'

Alogger

Blog

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the parameter and delegation causes errors.

Using 'log' which is a function name, not a variable.

The constructor parameter logger is used to delegate the Logger interface.

5fill in blank

hard

Fill all three blanks to implement delegation with an additional method in Kotlin.

Kotlin

interface Speaker {
    fun speak()
}

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

class Robot([1]: Speaker) : Speaker by [2] {
    fun compute() {
        println("Computing...")
    }
}

fun main() {
    val robot = Robot([3])
    robot.speak()
    robot.compute()
}

Drag options to blanks, or click blank then click option'

Ahuman

CHuman()

Drobot

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for parameter and delegation.

Passing 'robot' instead of 'Human()' when creating Robot.

The constructor parameter human is delegated to implement Speaker, and an instance Human() is passed when creating Robot.

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