Why extensions add without modifying in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of extension function call

What is the output of this Kotlin code using an extension function?

Kotlin

fun String.shout() = this.uppercase() + "!"

fun main() {
    val word = "hello"
    println(word.shout())
}

A hello

B HELLO

C HELLO!

D hello!

💡 Hint

Remember extension functions can add new behavior without changing the original class.

The extension function shout() converts the string to uppercase and adds an exclamation mark. It does not modify the original string but returns a new one.

🧠 Conceptual

intermediate

Why extensions don't modify original class

Why do Kotlin extension functions add functionality without modifying the original class?

A Because extensions create subclasses of the original class with new methods

B Because extensions rewrite the original class bytecode at runtime

C Because extensions replace the original class methods with new ones

D Because extensions are static functions that use the receiver object but don't change its code or state

💡 Hint

Think about how extensions are compiled and how they access the receiver.

Kotlin extensions are compiled as static functions with the receiver passed as a parameter. They do not alter the original class's code or state, so the original class remains unchanged.

🔧 Debug

advanced

Why does this extension not change the original list?

Consider this Kotlin code. Why does the original list remain unchanged after calling the extension function?

Kotlin

fun MutableList<Int>.addOne() {
    this.map { it + 1 }
}

fun main() {
    val numbers = mutableListOf(1, 2, 3)
    numbers.addOne()
    println(numbers)
}

A Because map returns a new list and does not modify the original list

B Because the extension function is not called correctly

C Because MutableList cannot be modified by extensions

D Because the list is immutable

💡 Hint

Check what map() does to the list and if it changes the original.

The map function creates and returns a new list with transformed elements but does not change the original list. The extension function does not assign or modify the original list, so it stays the same.

📝 Syntax

advanced

Which extension function syntax is correct?

Which of the following Kotlin extension function definitions is syntactically correct?

A fun isEven(this: Int) = this % 2 == 0

B fun Int.isEven() = this % 2 == 0

C fun Int.isEven { return this % 2 == 0 }

D fun Int.isEven() { this % 2 == 0 }

💡 Hint

Remember the syntax for extension functions includes the receiver type before the function name.

Option B correctly defines an extension function on Int using the receiver syntax and expression body. Options B, C, and D have syntax errors or missing return statements.

🚀 Application

expert

How to add a new behavior to a class without inheritance or modification?

You want to add a new function to the Kotlin String class that returns the string reversed with dashes between characters. You cannot modify the String class or create a subclass. Which approach is best?

A Create an extension function on String that returns the reversed string with dashes

B Create a new class that inherits from String and add the function there

C Use a global function that takes a String parameter and returns the reversed string with dashes

D Modify the Kotlin standard library source code to add the function

💡 Hint

Think about how Kotlin allows adding functions without changing original classes or inheritance.

Extension functions let you add new behaviors to existing classes without inheritance or modifying their source. This is the cleanest and safest way to add functionality like this.