Kotlin Academy · Lesson

Nested Classes

Classes inside classes.

Lesson 1 of 413 steps

Nested Classes is a free Kotlin Academy lesson on CoddyKit. This is lesson 1 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Kotlin Academy learning path, and your progress syncs across the web and the CoddyKit app. The Kotlin Academy course includes 4 lessons in total.

Classes Inside Classes

Kotlin lets you declare a class inside another class. By default such a class is nested and does not hold a reference to the outer instance.

class Outer {
    class Nested {
        fun hello() = "Hi from Nested"
    }
}

fun main() {
    println(Outer.Nested().hello())
}

Creating a Nested Instance

Because a nested class is independent, you create it via the outer class name without an outer instance: Outer.Nested().

class Computer {
    class Cpu {
        val cores = 8
    }
}

fun main() {
    val cpu = Computer.Cpu()
    println(cpu.cores)
}

No Access to Outer Members

A nested class cannot see the outer class(rsquo)s instance members because it has no outer reference. It behaves like a top-level class scoped under a name.

class Bank {
    val name = "ACME"
    class Branch {
        fun describe() = "A branch"
    }
}

fun main() {
    println(Bank.Branch().describe())
}

Why Nest at All?

Nesting expresses a logical grouping: the inner type belongs conceptually to the outer one, improving organization and namespacing.

class Http {
    class Request(val url: String)
}

fun main() {
    val r = Http.Request("/home")
    println(r.url)
}

Nested Class with Properties

Nested classes are ordinary classes: they can have constructors, properties, and methods.

class Garage {
    class Car(val model: String) {
        fun honk() = "$model: beep"
    }
}

fun main() {
    println(Garage.Car("Tesla").honk())
}

Accessing Companion or Static-like Members

Nested classes can be referenced from anywhere using the outer name, similar to a static nested class in Java.

class Config {
    class Defaults {
        val timeout = 30
    }
}

fun main() {
    println(Config.Defaults().timeout)
}

Multiple Nested Classes

An outer class can contain several nested classes to group related types together.

class Shapes {
    class Circle(val r: Int)
    class Square(val side: Int)
}

fun main() {
    println(Shapes.Circle(5).r)
    println(Shapes.Square(4).side)
}

Nested Inside Nested

You can nest more than one level deep, though deep nesting can hurt readability.

class A {
    class B {
        class C {
            val value = 42
        }
    }
}

fun main() {
    println(A.B.C().value)
}

Nested vs Top-Level

Functionally a nested class is like a top-level class; the only difference is its qualified name. Choose nesting when the relationship aids clarity.

class Order {
    class Item(val price: Int)
}

fun main() {
    val total = Order.Item(10).price + Order.Item(5).price
    println(total)
}

A Practical Grouping

Grouping a builder result type under its owner reads naturally.

class Parser {
    class Result(val ok: Boolean, val message: String)

    fun parse(text: String) = Result(text.isNotEmpty(), "parsed")
}

fun main() {
    val res = Parser().parse("data")
    println("${res.ok} ${res.message}")
}

Key Rule to Remember

The keyword that makes a class hold an outer reference is inner. Without it, a nested class is static-like and isolated.

class Box {
    class Lid
}

fun main() {
    println(Box.Lid() != null)
}

Quick Check

Test your understanding of nested classes.

Answer it in the interactive lesson

Recap

You learned about nested classes:

Declared inside another class, default is class (nested).
No reference to the outer instance; cannot access outer members.
Created via the outer name: Outer.Nested().
Great for logical grouping and namespacing.

class Outer {
    class Nested { val x = 1 }
}

fun main() {
    println(Outer.Nested().x)
}

Free to start

Learn Kotlin with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 51
Lessons: 203

Start learning free View the full course

Frequently Asked Questions

Is the “Nested Classes” lesson free?

Yes — any 3 lessons of the Kotlin Academy learning path, including “Nested Classes”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Kotlin Academy course includes 4 lessons in total.

What will I learn in “Nested Classes”?

Classes inside classes. You practise Kotlin Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Kotlin Academy?

No prior experience is required. Kotlin Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 1 of 4.

How long does the “Nested Classes” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Kotlin Academy lesson?

Yes. Every Kotlin Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Kotlin Academy