Nested class independence from outer in Kotlin - Step-by-Step Execution

Concept Flow - Nested class independence from outer

Define Outer Class

↓

Define Nested Class inside Outer

↓

Create Nested Class Instance

↓

Nested Class Accesses Own Members

↓

No Access to Outer Class Members

↓

Nested Class Works Independently

Shows how a nested class is defined inside an outer class but works independently without accessing outer class members.

Execution Sample

Kotlin

class Outer {
    val outerVal = "Outer"
    class Nested {
        fun nestedFun() = "Nested"
    }
}

val nested = Outer.Nested()
println(nested.nestedFun())

Defines an outer class with a nested class inside; nested class method returns its own string, showing independence.

Execution Table

Step	Action	Evaluation	Result
1	Define class Outer with property outerVal	outerVal = "Outer"	Outer class ready
2	Define nested class Nested inside Outer	Nested class has method nestedFun()	Nested class ready
3	Create instance of Nested: Outer.Nested()	nested = Outer.Nested()	Nested instance created
4	Call nested.nestedFun()	nestedFun() returns "Nested"	Output: Nested
5	Try to access outerVal from Nested (not shown in code)	Not allowed without reference	No access to outerVal
6	Program ends		Execution complete

💡 Nested class instance created and method called; nested class does not access outer class members.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
outerVal	"Outer"	"Outer"	"Outer"	"Outer"
nested	null	Instance of Nested	Instance of Nested	Instance of Nested

Key Moments - 2 Insights

Why can't the nested class access the outer class's property directly?

Because the nested class is static by default in Kotlin and does not hold a reference to the outer class instance, as shown in step 5 of the execution_table.

How do we create an instance of the nested class?

We create it using Outer.Nested(), not through an instance of Outer, as shown in step 3 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution table, what is the output when nested.nestedFun() is called at step 4?

A "Outer"

B "Nested"

C Error

D null

💡 Hint

Check the 'Result' column at step 4 in the execution_table.

At which step is the nested class instance created?

A Step 3

B Step 1

C Step 5

D Step 6

💡 Hint

Look at the 'Action' column for instance creation in the execution_table.

If the nested class tried to access outerVal directly, what would happen according to the execution_table?

A It would access outerVal successfully

B It would return null

C It would cause a compile error

D It would print "Outer"

💡 Hint

Refer to step 5 in the execution_table about access to outerVal.

Concept Snapshot

Nested classes in Kotlin are static by default.
They do not have access to outer class instance members.
Create nested class instances with Outer.Nested().
Nested class methods work independently.
To access outer members, use inner classes instead.

Full Transcript

This example shows a Kotlin outer class with a nested class inside. The nested class has its own method returning "Nested". We create an instance of the nested class using Outer.Nested() and call its method. The nested class cannot access the outer class's property directly because it is static by default. The execution table traces these steps clearly, showing the nested class's independence from the outer class instance.

Practice

1. What is true about a nested class in Kotlin compared to an inner class?

easy

A. A nested class can access all members of the outer class directly.

B. A nested class does not have access to the outer class's members.

C. A nested class is the same as an inner class.

D. A nested class must be declared with the inner keyword.

Solution

1. Step 1: Understand nested class independence

   In Kotlin, a nested class is static by default and cannot access outer class members.

2. Step 2: Compare with inner class

   Only inner classes (declared with inner) can access outer class properties and functions.

3. Final Answer:

   A nested class does not have access to the outer class's members. -> Option B

4. Quick Check:

   Nested class independence = A [OK]

Hint: Remember: nested = no outer access, inner = has outer access [OK]

Common Mistakes:

• Confusing nested and inner classes
• Thinking nested classes access outer members
• Assuming nested classes require 'inner' keyword

2. Which of the following is the correct syntax to declare a nested class inside an outer class in Kotlin?

easy

A. class Outer { inner class Nested { } }

B. class Outer { nested class Nested { } }

C. class Outer { static class Nested { } }

D. class Outer { class Nested { } }

Solution

1. Step 1: Recall Kotlin nested class syntax

   In Kotlin, nested classes are declared simply inside the outer class without any keyword.

2. Step 2: Identify incorrect options

   inner declares an inner class, static and nested keywords do not exist in Kotlin.

3. Final Answer:

   class Outer { class Nested { } } -> Option D

4. Quick Check:

   Nested class syntax = B [OK]

Hint: Nested class = just class inside class, no keywords needed [OK]

Common Mistakes:

• Using 'static' keyword (Java style)
• Using 'nested' keyword (not valid Kotlin)
• Confusing inner and nested class syntax

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

class Outer {
    val x = 10
    class Nested {
        fun printX() = "Cannot access x"
    }
}
fun main() {
    val nested = Outer.Nested()
    println(nested.printX())
}

medium

A. Cannot access x

B. NullPointerException

C. Compilation error

D. 10

Solution

1. Step 1: Analyze nested class access

   The nested class cannot access the outer class property x because it is not an inner class.

2. Step 2: Check printX() function

   It returns the string "Cannot access x" explicitly, so that will be printed.

3. Final Answer:

   Cannot access x -> Option A

4. Quick Check:

   Nested class method output = D [OK]

Hint: Nested classes can't access outer properties directly [OK]

Common Mistakes:

• Expecting nested class to print 10
• Assuming compilation error due to access
• Confusing inner and nested class behavior

4. Identify the error in this Kotlin code snippet:

class Outer {
    val y = 5
    class Nested {
        fun printY() = y
    }
}

medium

A. Nested class cannot access 'y' directly; must be inner class.

B. Missing 'inner' keyword before Nested class declaration.

C. Property 'y' must be static to be accessed.

D. No error; code is correct.

Solution

1. Step 1: Check nested class access rules

   A nested class cannot access outer class properties directly because it is static by default.

2. Step 2: Understand how to fix

   To access outer properties, the class must be declared as inner, but here it is not.

3. Final Answer:

   Nested class cannot access 'y' directly; must be inner class. -> Option A

4. Quick Check:

   Nested class access error = A [OK]

Hint: Nested class can't access outer vars; use inner class instead [OK]

Common Mistakes:

• Thinking 'inner' keyword is optional
• Assuming 'y' can be static in Kotlin
• Ignoring nested class static nature

5. Given this Kotlin code, what is the correct way to allow Nested to access outerValue from Outer class?

class Outer(val outerValue: Int) {
    class Nested {
        fun printValue() = "Cannot access outerValue"
    }
}

hard

A. Pass outerValue as a parameter to Nested's constructor.

B. Make outerValue static to access from Nested.

C. Change Nested to an inner class and access outerValue directly.

D. Use a companion object inside Nested to access outerValue.

Solution

1. Step 1: Understand nested vs inner class access

   Nested classes cannot access outer class properties unless declared inner.

2. Step 2: Apply inner class to access outerValue

   Changing Nested to inner class Nested allows direct access to outerValue.

3. Final Answer:

   Change Nested to an inner class and access outerValue directly. -> Option C

4. Quick Check:

   Use inner class for outer access = C [OK]

Hint: Use 'inner' keyword to access outer class properties [OK]

Common Mistakes:

• Trying to make properties static (not Kotlin style)
• Passing outerValue manually instead of inner class
• Using companion object incorrectly for instance data