Why extensions add without modifying in Kotlin

Introduction

Extensions let you add new features to existing code without changing it. This keeps the original code safe and clean.

You want to add a new function to a class from a library you can't change.

You want to keep your code organized by adding helpers outside the main class.

You want to add features to built-in types like String or List.

You want to avoid breaking existing code by not modifying original classes.

Syntax

Kotlin

fun ClassName.newFunction() {
    // code here
}

Extensions look like normal functions but are declared outside the class.

They do not change the original class or its bytecode.

Examples

Adds a new function shout to String that makes text uppercase and adds an exclamation.

Kotlin

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

Adds sumAll to List<Int> to sum all numbers in the list.

Kotlin

fun List<Int>.sumAll() = this.sum()

Sample Program

This program adds a shout function to String. It prints "HELLO!" without changing the original String class.

Kotlin

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

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

Important Notes

Extensions do not actually insert code into the original class; they are static functions called with special syntax.

If the original class has a function with the same name and parameters, the class's function is called instead of the extension.

Summary

Extensions add new functions without changing original code.

This keeps code safe and easy to maintain.

They are useful for adding helpers to classes you don't own.

Practice

1. What is the main reason Kotlin extensions add functionality without modifying the original class?

easy

A. They create new functions outside the class without changing its code

B. They rewrite the original class bytecode

C. They require inheritance from the original class

D. They replace the original class methods at runtime

Solution

1. Step 1: Understand how extensions work

   Kotlin extensions define new functions outside the original class without altering its source code.

2. Step 2: Compare with other options

   Options A, B, and D involve modifying or replacing the original class, which extensions do not do.

3. Final Answer:

   They create new functions outside the class without changing its code -> Option A

4. Quick Check:

   Extensions add functions externally = C [OK]

Hint: Extensions add functions externally, no class code change [OK]

Common Mistakes:

• Thinking extensions modify original class code
• Confusing extensions with inheritance
• Believing extensions replace methods at runtime

2. Which of the following is the correct syntax to define an extension function greet for the String class in Kotlin?

easy

A. fun greet() = String { println("Hello") }

B. fun greet(String) { println("Hello") }

C. fun greet() String { println("Hello") }

D. fun String.greet() { println("Hello") }

Solution

1. Step 1: Recall extension function syntax

   Extension functions are declared as fun ClassName.functionName(), so for String: fun String.greet().

2. Step 2: Validate options

   fun String.greet() { println("Hello") } matches correct syntax. Others have wrong parameter placement or return type.

3. Final Answer:

   fun String.greet() { println("Hello") } -> Option D

4. Quick Check:

   Extension syntax = fun ClassName.functionName() [OK]

Hint: Extension syntax: fun ClassName.functionName() [OK]

Common Mistakes:

• Placing class name as parameter instead of receiver
• Incorrect return type syntax
• Using function without receiver type

3. What will be the output of this Kotlin code?

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

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

medium

A. hello!

B. HELLO!

C. Hello!

D. Error: No such function

Solution

1. Step 1: Understand the extension function

   The extension shout() converts the string to uppercase and adds an exclamation mark.

2. Step 2: Apply the function to "hello"

   "hello" becomes "HELLO" plus "!" resulting in "HELLO!".

3. Final Answer:

   HELLO! -> Option B

4. Quick Check:

   Uppercase + ! = HELLO! [OK]

Hint: Extension adds uppercase and ! to string [OK]

Common Mistakes:

• Assuming original string unchanged
• Confusing uppercase with capitalized
• Expecting runtime error for extension

4. Identify the error in this Kotlin extension function code:

fun Int.addFive() = this + 5

fun main() {
    val number = 10
    println(number.addfive())
}

medium

A. Missing return type in extension function

B. Extension function cannot be defined on Int

C. Function call uses wrong case: addfive() instead of addFive()

D. Cannot call extension function on val variable

Solution

1. Step 1: Check extension function definition

   The extension addFive() is correctly defined on Int with proper syntax.

2. Step 2: Check function call in main()

   The call uses addfive() with lowercase 'f', which does not match the defined function name.

3. Final Answer:

   Function call uses wrong case: addfive() instead of addFive() -> Option C

4. Quick Check:

   Function names are case-sensitive = A [OK]

Hint: Function names are case-sensitive in Kotlin [OK]

Common Mistakes:

• Ignoring case sensitivity in function calls
• Thinking extension can't be on Int
• Assuming val variables can't use extensions

5. You want to add a function isEven() to the Int class that returns true if the number is even, without modifying the original Int class. Which Kotlin code correctly achieves this and why does it not change the original class?

hard

A. fun Int.isEven() = this % 2 == 0 // Adds function externally without changing Int class

B. class Int { fun isEven() = this % 2 == 0 } // Rewrites Int class

C. fun isEven(n: Int) = n % 2 == 0 // Defines a separate function, not extension

D. Int.isEven = { this % 2 == 0 } // Attempts to assign function to Int class

Solution

1. Step 1: Identify correct extension syntax

   fun Int.isEven() = this % 2 == 0 defines an extension function on Int using fun Int.isEven(), which is the correct way.

2. Step 2: Understand why original class is unchanged

   Extensions add functions externally without modifying or rewriting the original Int class bytecode.

3. Final Answer:

   fun Int.isEven() = this % 2 == 0 // Adds function externally without changing Int class -> Option A

4. Quick Check:

   Extension adds function externally = D [OK]

Hint: Extensions add functions externally, no class rewrite [OK]

Common Mistakes:

• Trying to redefine Int class directly
• Confusing extension with normal function
• Attempting to assign function to class property