Nested and Inner Classes in Kotlin

Introduction

Nested and Inner Classes is a fundamental concept every Kotlin developer should understand. Classes bundle data and behaviour. Kotlin reduces boilerplate with concise constructors, properties, and sensible defaults compared to Java.

A nested class is declared inside another class and does not hold a reference to the outer instance. In this tutorial you will learn the syntax, walk through a complete example program, study the sample output, and review best practices so you can apply the concept confidently in your own projects.

Definition

• A nested class is declared inside another class and does not hold a reference to the outer instance.
• An inner class uses the inner modifier and can access members of the outer class.
• Nested classes are static by default compared to Java’s non-static inner classes.

Syntax

class Outer {
    class Nested { }
    inner class Inner { }
}

Nested and Inner Classes in Kotlin Example Program in Kotlin

class Shop(val name: String) {
    inner class Counter {
        fun label() = "Counter of $name"
    }
    class Info {
        fun type() = "Shop info block"
    }
}

fun main() {
    val shop = Shop("Book Store")
    println(shop.Counter().label())
    println(Shop.Info().type())
}

Sample Output

Counter of Book Store
Shop info block

When to use

Use classes to model entities with state and behaviour — users, orders, view models, or service objects.

How it works

1. The program starts with a main function — the entry point that runs when you execute the file.

2. A nested class is declared inside another class and does not hold a reference to the outer instance.

3. Run the program in IntelliJ IDEA, Android Studio, or with the Kotlin command-line compiler (kotlinc / kotlin). Compare your console output with the sample output shown below.

Best Practices

• Keep constructors short; move complex setup to init blocks or factory functions.
• Expose behaviour through methods rather than public mutable fields.
• Mark classes final (default) unless inheritance is intentional.

Common Mistakes

• Skipping the example and only reading the definition — hands-on practice cements the concept.
• Copying syntax without understanding nullable vs non-nullable types or scope rules.
• Ignoring compiler warnings that often point to safer alternatives.

Key Points

• A nested class is declared inside another class and does not hold a reference to the outer instance.
• An inner class uses the inner modifier and can access members of the outer class.
• Nested classes are static by default compared to Java’s non-static inner classes.
• Test the example locally and verify the output matches the sample.
• Experiment by changing input values to see how behaviour changes.

Notes

• Semicolons at the end of statements are optional in Kotlin.