Multiple interface implementation in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of multiple interface implementation with method override

What is the output of this Kotlin code when the test() function is called?

Kotlin

interface A {
    fun greet() = "Hello from A"
}

interface B {
    fun greet() = "Hello from B"
}

class C : A, B {
    override fun greet(): String {
        return super<A>.greet() + " and " + super<B>.greet()
    }
}

fun test() {
    val c = C()
    println(c.greet())
}

A Hello from B and Hello from A

B Hello from A

C Compilation error due to ambiguous greet()

D Hello from A and Hello from B

💡 Hint

Look at how super is used to specify which interface's method to call.

Class C implements both interfaces A and B, each with a default greet() method. To resolve ambiguity, C overrides greet() and explicitly calls both interface methods using super<A>.greet() and super<B>.greet(). The output concatenates both greetings.

❓ Predict Output

intermediate

Which method is called in multiple interface implementation?

Given the following Kotlin code, what will be printed when test() is executed?

Kotlin

interface X {
    fun action() = "Action from X"
}

interface Y {
    fun action() = "Action from Y"
}

class Z : X, Y {
    override fun action(): String {
        return super<Y>.action()
    }
}

fun test() {
    val z = Z()
    println(z.action())
}

A Action from Y

B Action from X

C Compilation error due to ambiguity

D Runtime error

💡 Hint

Check which interface's method is explicitly called with super.

Class Z overrides action() and explicitly calls super<Y>.action(), so the method from interface Y is executed, printing "Action from Y".

🔧 Debug

advanced

Identify the error in multiple interface implementation

What error will this Kotlin code produce when compiled?

Kotlin

interface M {
    fun foo() = "M"
}

interface N {
    fun foo()
}

class O : M, N {
    // No override of foo()
}

A Compilation error: Class O must override foo()

B No error, compiles successfully

C Compilation error: Conflicting implementations of foo()

D Runtime error: foo() not implemented

💡 Hint

Check which interface requires foo() to be implemented and which provides a default.

Interface M provides a default implementation of foo(), but interface N declares foo() without implementation. Class O must override foo() to resolve this conflict; otherwise, compilation fails.

📝 Syntax

advanced

Correct syntax for multiple interface implementation with property

Which option correctly implements two interfaces with a property of the same name in Kotlin?

Kotlin

interface P {
    val value: String
}

interface Q {
    val value: String
}

class R : P, Q {
    // Implement value here
}

A override fun value() = "Hello"

B override var value = "Hello"

C override val value = "Hello"

D val value = "Hello"

💡 Hint

Properties from interfaces must be overridden with 'override val' or 'override var'.

Both interfaces declare a property 'value'. The class must override it with 'override val value = "Hello"'. Option C tries to override a property as a function, which is invalid. Option C misses 'override', C uses 'var' which is allowed but less precise here, and D correctly overrides the property.

🚀 Application

expert

Implement a class that combines behaviors from two interfaces

You have two interfaces in Kotlin:

interface Logger { fun log(msg: String) }
interface Printer { fun print(msg: String) }

Implement a class Console that implements both interfaces. The log method should print the message prefixed with "LOG: ", and the print method should print the message prefixed with "PRINT: ".

Which of the following class implementations correctly does this?

A

class Console : Logger, Printer {
    fun log(msg: String) {
        println("LOG: $msg")
    }
    fun print(msg: String) {
        println("PRINT: $msg")
    }
}

B

class Console : Logger, Printer {
    override fun log(msg: String) {
        println("LOG: $msg")
    }
    override fun print(msg: String) {
        println("PRINT: $msg")
    }
}

C

class Console : Logger, Printer {
    override fun log(msg: String) {
        println("PRINT: $msg")
    }
    override fun print(msg: String) {
        println("LOG: $msg")
    }
}

D

class Console : Logger, Printer {
    override fun log(msg: String) = println("LOG: $msg")
}

💡 Hint

Remember to use 'override' keyword for interface methods and implement both methods.

Option B correctly overrides both interface methods with the required prefixes. Option B misses 'override' keyword, causing compilation error. Option B swaps the prefixes, so behavior is incorrect. Option B only overrides one method, missing the other.