> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Kotlin Nested Class
A nested class in Kotlin is a class declared within the lexical scope of another class. By default, nested classes are statically bound, meaning they do not hold an implicit reference to an instance of their enclosing (outer) class. This behavior is structurally equivalent to a `static` nested class in Java.
Because a nested class lacks a reference to the outer class instance, it cannot access the instance members (properties or functions) of the enclosing class. It operates entirely independently of the outer class's state.
## Syntax and Instantiation
To instantiate a nested class, you qualify the nested class name with the outer class name, treating the outer class purely as a namespace. You do not need to instantiate the outer class first.
```kotlin theme={"dark"}
class Outer {
private val outerInstanceProperty: String = "Outer State"
class Nested {
fun printMessage() {
println("Executing inside the nested class.")
// The following line would cause a compilation error:
// println(outerInstanceProperty)
}
}
}
// Instantiation requires the Outer class name as a qualifier,
// but does NOT require an instance of Outer.
val nestedObject = Outer.Nested()
nestedObject.printMessage()
```
## Nesting Interfaces
Kotlin allows interfaces to be nested within classes, and classes to be nested within interfaces. By definition, all nested interfaces and classes nested within interfaces are implicitly static.
```kotlin theme={"dark"}
class Outer {
interface NestedInterface {
fun execute()
}
}
// Implementing a nested interface
class Implementation : Outer.NestedInterface {
override fun execute() {
println("Implemented nested interface")
}
}
```
## Contrast with Inner Classes
To alter the default static binding of a nested class so that it *can* access the outer class's instance members, the nested class must be explicitly modified with the `inner` keyword.
Marking a class as `inner` changes its memory footprint and instantiation mechanics. It forces the nested class to hold a reference to the outer class instance, meaning the nested class can no longer be instantiated without first creating an instance of the outer class.
```kotlin theme={"dark"}
class Outer {
private val outerState: String = "Outer State"
// 'inner' keyword changes the class from statically nested to an inner class
inner class Inner {
fun accessOuter() {
// Access to outer class members is now permitted
println(outerState)
}
}
}
// Instantiation now requires an instance of the Outer class
val outerInstance = Outer()
val innerObject = outerInstance.Inner()
```
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
