Kotlin : 100 Interview Questions and Answers PART16

76. What is a Member Function in Kotlin?

A member function in Kotlin is a function that is defined inside a class or object. It operates on the instance of the class and can access its properties and other functions.

Example

class Person(val name: String, var age: Int) {
    fun greet() {
        println("Hello, my name is $name and I am $age years old.")
    }
}

Here, greet() is a member function of the Person class.

Characteristics of Member Functions

• 1. Belong to a class or object
• 2. Can access class-level properties and methods
• 3. Can be called using an object instance
• 4. Can be open, final, override, etc.

Types of Member Functions

1. Regular: Defined inside a class

2. Open / Override: For inheritance

3. Abstract: Must be implemented in subclasses

4. Companion Object Functions: Similar to static

5. Extension Functions: Defined outside but act like members (syntactic sugar)

77. What is Top-level Functions in kotlin ?

In Kotlin, top-level functions are functions that are declared outside any class, object, or interface. They are defined directly in a Kotlin file, not wrapped in a class like in Java.

Example

// File: Utils.kt

fun greet(name: String) {
    println("Hello, $name!")
}

You can call this function from anywhere in your code:

greet("Alice")

No need to create an object or class like in Java.

Why Are Top-Level Functions Useful?

• ✅ Cleaner, more concise code
• ✅ No need to create utility classes (e.g., Utils, Helper)
• ✅ Better organization with Kotlin’s packages
• ✅ Can be marked @JvmStatic or @JvmName for Java interop

Comparision

78. The difference between extension functions and member functions in Kotlin

• Member functions = native part of the class, full control and access, polymorphic
• Extension functions = syntactic sugar for adding functionality externally, cannot access private/protected members or be overridden
•  

Here is a comparison table showing the key differences between Extension Functions and Member Functions in Kotlin:

79. Member vs Top-level Functions

80. The concept of property access in Kotlin.

In Kotlin, property access refers to how variables (properties) are read and written, and how you can customize or intercept those operations using:

• 1. Getters (read access)
• 2. Setters (write access)
• 3. Backing fields
• 4. Delegated properties
•  

1. Default Property Access

• Kotlin automatically provides a getter and setter for each property.

var name: String = "John"

This is equivalent to:

var name: String = "John"
    get() = field
    set(value) {
        field = value
    }

field is a backing field used to hold the actual value.

2. Custom Getter/Setter

You can override the default behavior.

var age: Int = 18
    get() = field + 1  // Custom getter adds 1
    set(value) {
        field = if (value < 0) 0 else value
    }
    
Output:
age = -5       // Sets to 0 (setter logic)
println(age)   // Prints 1 (getter logic)

3. Read-only Properties (val)

val id: Int = 42

Equivalent to:

val id: Int
    get() = 42

val only has a getter, no setter.

4. Delegated Property Access

val username: String by lazy { "user123" }   // Read access is delegated

You can also observe and veto changes with:

var count: Int by Delegates.observable(0) { prop, old, new ->
    println("${prop.name} changed from $old to $new")
}

5. Backing Properties

Used when you want to control access to a property, but store the data in a different field.

private var _email = "test@example.com"

val email: String
    get() = _email  // Expose only getter

Useful for encapsulation.

Importtant Table