Kotlin diverges from Java in how it handles types defined within other types. By default, a class declared inside another is statically scoped and holds no impliict reference to its enclosing instance. Explicit modifiers and specific syntax are required to alter this behavior, manage memory references, and resolve scope conflicts.

Kotlin Type	Java Equivalent	Key Characteristics
Inner Class	Member Inner Class	Requires the inner modifier. Holds a strong reference to the outer instance, which can lead to memory leaks if lifecycle management is ignored. Accesses outer members directly; resolves naming collisions via this@OuterClass.
Nested Class	Static Nested Class	The default behavior for classes inside classes. Lacks an implicit reference to the outer instance. Cannot access non-static outer members but can freely interact with sibling nested classes. object declarations inside classes follow this static nesting rule.
Local Class	Local Inner Class	Declared inside a function body. Captures the surrounding function's scope for reading. Invisible to code outside the declaring function.
Anonymous Object	Anonymous Inner Class	Created via object expressions. Captures mutable local variables (var) without requiring final/val restrictions. Preferred for overriding multiple interface methods. Single-method interfaces typically leverage lambda syntax instead.

Inner Classes and Qualified this

Applying the inner keyword binds the nested type to a specific instance of the enclosing class. This enables direct member access but requires careful handling of identifier shadowing.

class NetworkClient {
    val endpoint = "https://primary.api"
    fun establishConnection() = println("Linking to $endpoint")

    inner class RequestDispatcher {
        val endpoint = "https://secondary.api"

        fun printLocalEndpoint() = println(endpoint)
        fun printOuterEndpoint() = println(this@NetworkClient.endpoint)
        fun triggerOuterConnection() = this@NetworkClient.establishConnection()

        fun demonstrateBlockShadowing() {
            val endpoint = "https://temporary.api"
            println(endpoint)
        }
    }
}

val dispatcher = NetworkClient().RequestDispatcher()
dispatcher.printLocalEndpoint()        // https://secondary.api
dispatcher.printOuterEndpoint()        // https://primary.api
dispatcher.triggerOuterConnection()    // Linking to https://primary.api
dispatcher.demonstrateBlockShadowing() // https://temporary.api

Static Nested Classes

Omitting the inner modifier creates a statically scoped class. These types operate independently of any outer instance and are instantiated directly through the outer class name.

class DataPipeline {
    val pipelineId = "PIPE_001"

    class Extractor {
        val source = "Database"
        fun runExtraction() = println("Pulling from $source")
    }

    class Transformer {
        val format = "Parquet"
        fun runTransformation() = println("Converting to $format")
        fun chainExtraction() = Extractor().runExtraction()
    }
}

DataPipeline.Extractor().runExtraction()      // Pulling from Database
DataPipeline.Transformer().runTransformation()// Converting to Parquet
DataPipeline.Transformer().chainExtraction()  // Pulling from Database

Local Classes

Classes defined within function boundaries are restricted to that scope. They can read parameters and local variables from the enclosing function but remain completely hidden from external callers. Their visibility is striclty limited to the block in which they are declared.

Anonymous Objects and SAM Conversions

Object expressions generate anonymous implementations on the fly. Kotlin relaxes Java's capture rules, allowing mutable local variables (var) to be modified from within the anonymous object.

fun initializeTracker() {
    var eventCount = 0
    val monitor = object {
        fun record() { eventCount++ }
        fun report() = println("Total events: $eventCount")
    }
    monitor.record()
}

interface UiInteraction {
    fun onTap()
    fun onHold()
}

fun bindInteraction(component: Any) {
    var interactionState = 0

    // Object expression for multi-method interfaces
    val handler = object : UiInteraction {
        override fun onTap() { interactionState += 1 }
        override fun onHold() { interactionState += 3 }
    }

    // SAM interfaces (single abstract method) support lambda shorthand
    // component.setOnClickListener { interactionState += 1 }
}