Extensions vs member functions priority in Kotlin - Visual Side-by-Side Comparison

Concept Flow - Extensions vs member functions priority

Call function on object

↓

Is member function available?

No→Use extension function

Yes↓

Call member function

↓

End

When calling a function on an object, Kotlin first looks for a member function. If none is found, it uses an extension function.

Execution Sample

Kotlin

class Example {
    fun greet() = "Member"
}

fun Example.greet() = "Extension"

fun main() {
    println(Example().greet())
}

This code shows that the member function 'greet' is called instead of the extension function.

Execution Table

Step	Action	Function Found?	Function Called	Output
1	Call greet() on Example instance	Yes, member function	Member function greet()	Member
2	Print output	-	-	Member

💡 Member function exists, so extension function is ignored.

Variable Tracker

Variable	Start	After Call	Final
Example instance	Created	Used to call greet()	No change
Output	None	Member	Member

Key Moments - 2 Insights

Why does the member function get called instead of the extension function?

Because Kotlin always prefers member functions over extension functions when both exist, as shown in execution_table step 1.

What happens if the member function does not exist?

Then Kotlin calls the extension function if available, as the flow shows in the 'No' branch from member function check.

Visual Quiz - 3 Questions

Look at the execution table, what function is called at step 1?

A Extension function greet()

B Member function greet()

C No function is called

D Both member and extension functions

💡 Hint

See execution_table row 1 under 'Function Called'

If the member function greet() was removed, which function would be called?

A Member function greet()

B No function would be called

C Extension function greet()

D Both functions would be called

💡 Hint

Refer to concept_flow where member function absence leads to extension function call

According to variable_tracker, what is the output after calling greet()?

A "Member"

B No output

C "Extension"

D Error

💡 Hint

Check variable_tracker row 'Output' after call

Concept Snapshot

Kotlin calls member functions before extension functions.
If a member function exists, extension with same name is ignored.
Extension functions are used only if no member function matches.
This rule helps avoid ambiguity and keeps member functions priority clear.

Full Transcript

In Kotlin, when you call a function on an object, the language first checks if the object has a member function with that name. If it does, Kotlin calls that member function. If not, Kotlin looks for an extension function with that name and calls it if found. This means member functions have higher priority than extension functions. For example, if a class has a member function greet(), and there is also an extension function greet() for that class, calling greet() on an instance will call the member function. If the member function is removed, then the extension function will be called instead. This priority rule helps keep function calls clear and predictable.

Practice

1. In Kotlin, when a class has a member function and an extension function with the same name, which one is called by default?

easy

A. The member function of the class

B. The extension function

C. Both are called

D. It causes a compile-time error

Solution

1. Step 1: Understand member vs extension functions

   Member functions are defined inside the class, while extension functions are defined outside to add functionality.

2. Step 2: Check Kotlin's call priority

   Kotlin always prefers member functions over extension functions when both have the same name.

3. Final Answer:

   The member function of the class -> Option A

4. Quick Check:

   Member functions have priority = A [OK]

Hint: Member functions override extensions with same name [OK]

Common Mistakes:

• Thinking extension functions override member functions
• Assuming both functions run together
• Believing it causes a compile error

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

easy

A. fun greet() Person { println("Hello") }

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

C. extension fun Person.greet() { println("Hello") }

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

Solution

1. Step 1: Recall extension function syntax

   Extension functions are declared as fun ClassName.functionName().

2. Step 2: Match syntax with options

   fun Person.greet() { println("Hello") } matches the correct syntax: fun Person.greet().

3. Final Answer:

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

4. Quick Check:

   Extension syntax = D [OK]

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

Common Mistakes:

• Placing function name before class name
• Using 'extension' keyword incorrectly
• Wrong function declaration order

3. Consider the following Kotlin code:

class Box {
    fun size() = "Member size"
}

fun Box.size() = "Extension size"

fun main() {
    val box = Box()
    println(box.size())
}

What is the output when this code runs?

medium

A. Compilation error

B. Member size

C. Extension size

D. Runtime exception

Solution

1. Step 1: Identify member and extension functions

   Class Box has a member function size() returning "Member size". An extension function with the same name returns "Extension size".

2. Step 2: Determine which function is called

   Kotlin calls the member function when both exist, so box.size() calls the member function.

3. Final Answer:

   Member size -> Option B

4. Quick Check:

   Member function called over extension = C [OK]

Hint: Member function called if name clashes [OK]

Common Mistakes:

• Expecting extension function output
• Thinking both outputs print
• Assuming compile error due to name clash

4. Given this Kotlin code:

class Gadget {
    fun info() = "Member info"
}

fun Gadget.info() = "Extension info"

fun main() {
    val g: Gadget? = null
    println(g?.info())
}

What is the output when running this code?

medium

A. null

B. Member info

C. Extension info

D. NullPointerException

Solution

1. Step 1: Analyze nullable variable and safe call

   Variable g is null. The safe call operator ?. prevents calling functions on null.

2. Step 2: Understand safe call with extension/member functions

   Since g is null, g?.info() returns null without calling any function.

3. Final Answer:

   null -> Option A

4. Quick Check:

   Safe call on null returns null = B [OK]

Hint: Safe call on null returns null, no function called [OK]

Common Mistakes:

• Expecting function output despite null
• Thinking NullPointerException occurs
• Confusing extension and member call on null

5. You want to add a describe() function to class Device without modifying its source code. The class already has a member function describe(). How can you call the extension describe() function explicitly in Kotlin?

hard

A. You cannot call the extension if member exists with same name

B. Use (device as Device).describe() to call extension

C. Call extension with a wrapper function or different name

D. Use Device::describe.invoke(device) to call extension

Solution

1. Step 1: Understand member vs extension call priority

   Kotlin always calls member functions over extensions if names clash; extension cannot override member.

2. Step 2: Find workaround to call extension

   To call extension explicitly, rename it or call via a wrapper function with a different name.

3. Final Answer:

   Call extension with a wrapper function or different name -> Option C

4. Quick Check:

   Rename or wrap extension to call it = A [OK]

Hint: Rename extension or wrap it to call when member exists [OK]

Common Mistakes:

• Trying to cast to call extension directly
• Expecting extension to override member
• Using reflection incorrectly to call extension