Nested and Inner Classes in Kotlin

In Kotlin, classes can be defined inside other classes to logically group and encapsulate related functionality. These are known as nested and inner classes. Although they look similar, they behave differently in how they access members of the outer class.

1. Why Use Nested or Inner Classes?

Nested and inner classes improve structure and encapsulation:

Encapsulation: Helps organize related code logically within a parent class.
Readability: Keeps supporting classes close to where they are used.
Access Control: Inner classes can access members of the outer class, but nested ones cannot (unless made inner).

2. Nested Classes

A nested class is simply a class defined inside another class. By default, it does not hold a reference to the outer class and cannot access its members.


class Outer {
    private val outerName = "Outer Class"

    class Nested {
        fun show() = "Hello from Nested Class"
        // Cannot access outerName directly
    }
}

fun main() {
    val nested = Outer.Nested() // No need to create Outer instance
    println(nested.show())
}

Output:

Hello from Nested Class

Key Points:

Defined using class Nested inside another class.
Acts like a static class in Java.
Cannot access members (properties or methods) of the outer class directly.
Does not require an instance of the outer class to be created.

3. Inner Classes

If you want the nested class to access the members of the outer class, you must declare it as an inner class using the inner keyword.


class Outer {
    private val outerName = "Outer Class"

    inner class Inner {
        fun show() = "Accessing: $outerName from Inner Class"
    }
}

fun main() {
    val inner = Outer().Inner() // Requires Outer instance
    println(inner.show())
}

Output:

Accessing: Outer Class from Inner Class

Key Points:

Declared using the inner keyword.
Holds a reference to the outer class instance.
Can access all members (including private ones) of the outer class.
Requires an instance of the outer class to be created first.

4. Accessing Outer Class Members

The this@OuterClassName syntax allows inner classes to explicitly refer to the outer class instance.


class Outer {
    private val outerName = "Outer"

    inner class Inner {
        private val innerName = "Inner"
        fun display() {
            println("Inner Name: $innerName")
            println("Outer Name: ${this@Outer.outerName}")
        }
    }
}

fun main() {
    val obj = Outer().Inner()
    obj.display()
}

Output:


Inner Name: Inner
Outer Name: Outer

5. Nested vs Inner Class (Comparison)

Feature	Nested Class	Inner Class
Keyword	Defined normally	Declared using `inner`
Outer Class Reference	Does not hold a reference	Holds a reference
Access to Outer Members	Cannot access outer members	Can access outer members (even private ones)
Object Creation	`Outer.Nested()`	`Outer().Inner()`
Analogy in Java	Static nested class	Non-static inner class

6. Nested and Inner Classes in Real Use Cases

UI Components: Inner classes are often used for click listeners or callbacks that access activity data.
Encapsulation: Nested helper classes can be used to contain logic only relevant to the outer class.
Builder Pattern: Nested classes can implement builder-style configurations without referencing the outer class instance.

7. Technical Interview Questions

What is a nested class in Kotlin?
A class defined inside another class without the inner keyword. It cannot access members of the outer class.
What is an inner class in Kotlin?
A class defined inside another class using the inner keyword. It has access to members of the outer class instance.
How do you access outer class members from an inner class?
By using the syntax this@OuterClassName.memberName.
Do nested classes hold a reference to the outer class?
No, nested classes do not. Only inner classes hold such a reference.
Can an inner class access private members of the outer class?
Yes, it can. Kotlin’s inner class has full access to all members of its outer class.
When to use nested vs inner classes?
Use nested when no outer class reference is needed, and inner when you need to access outer data or behavior.

8. Key Takeaways

Nested classes are static by default in Kotlin.
Inner classes hold a reference to their outer class instance.
Use this@OuterClass to access outer members explicitly.
Nested and inner classes improve code organization and encapsulation.
Choose inner classes carefully to avoid unnecessary memory references to the outer class.