Understanding Nested Objects and Classes in Kotlin

March 2025
M	T	W	T	F	S	S
	1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

Kotlin is a modern programming language that offers many features aimed at improving code clarity and simplicity. One such feature is its support for nested objects and classes. While this concept isn’t unique to Kotlin (Java also has nested classes), Kotlin’s approach provides more flexibility and clarity, particularly in how objects and classes are nested and accessed. In this blog post, we’ll dive into the concept of nested objects and classes in Kotlin, exploring how they differ from Java, their practical applications, and some key differences between Kotlin’s inner and regular nested classes.

What are Nested Objects in Kotlin?

In Kotlin, a nested object refers to an object defined within another class or object. These nested objects can be used in several scenarios, such as defining singletons or providing modular, tightly-coupled logic inside a class.

Companion Objects

One of the most common uses of nested objects in Kotlin is the companion object. This special object acts like a static member of a class in Java, providing access to its methods without needing an instance of the class.

class Thingy {
    companion object {
        fun doSomething() {
            println("Ummm... is this something?")
        }
    }
}

fun main() {
    Thingy.doSomething()
}

class Thingy {

companion object {

fun doSomething() {

println("Ummm... is this something?")

}

fun main() {

Thingy.doSomething()

}

In this example, the doSomething() method in the companion object can be called directly on the Thingy class, much like a static method in Java.

Named Nested Objects

You can also define a named nested object within a class. This allows you to reference the nested object using its name, similar to how you would access a property.

class Thingy {
    object Somethingifier {
        fun doSomething() {
            println("Ummm... is this something?")
        }
    }
}

fun main() {
    Thingy.Somethingifier.doSomething()
}

class Thingy {

object Somethingifier {

fun doSomething() {

println("Ummm... is this something?")

}

fun main() {

Thingy.Somethingifier.doSomething()

}

This pattern can be useful when you need to group related functionality within a class but don’t want to create an instance of the class itself.

Object Properties

Alternatively, you can use an object expression to assign a nested object to a property. This allows you to dynamically define and initialize the object.

interface Somethingifier {
    fun doSomething()
}

class Thingy {
    val somethingifier = object : Somethingifier {
        override fun doSomething() {
            println("Ummm... is this something?")
        }
    }
}

fun main() {
    val thingy = Thingy()
    thingy.somethingifier.doSomething()
}

interface Somethingifier {

fun doSomething()

}

class Thingy {

val somethingifier = object : Somethingifier {

override fun doSomething() {

println("Ummm... is this something?")

}

fun main() {

val thingy = Thingy()

thingy.somethingifier.doSomething()

}

This example demonstrates how nested objects can be used to implement interfaces and encapsulate behavior.

Nested Classes in Kotlin

Kotlin also allows for the creation of nested classes. A nested class is simply a class that is defined within another class. This is particularly useful when the nested class has a logical relationship with the enclosing class.

Simple Nested Classes

In Kotlin, you can define a simple nested class within an outer class:

class Foo {
    class Bar {
        fun whatever() {
            println("You were expecting something profound?")
        }
    }
}

fun main() {
    val bar = Foo.Bar()
    bar.whatever()
}

class Foo {

class Bar {

fun whatever() {

println("You were expecting something profound?")

}

fun main() {

val bar = Foo.Bar()

bar.whatever()

}

This code works similarly to Java’s static nested classes. The nested class is not tied to an instance of the outer class, meaning you don’t need an instance of Foo to create an instance of Bar.

Inner Classes

However, Kotlin also allows you to define inner classes, which are tied to an instance of the outer class. In Java, inner classes have access to the outer class’s instance members. Kotlin requires the inner keyword to achieve this functionality.

class Foo {
    val count = 1
    
    inner class Bar {
        fun count() = count
    }
}

fun main() {
    val foo = Foo()
    val bar = foo.Bar()
    println(bar.count())
}

class Foo {

val count = 1

inner class Bar {

fun count() = count

}

fun main() {

val foo = Foo()

val bar = foo.Bar()

println(bar.count())

}

Here, the Bar class has access to the instance properties of Foo, such as the count property. This is similar to the inner class behavior in Java.

Accessing the Outer Class Instance in Kotlin

In Java, if you need to access the outer class instance from an inner class, you use the syntax OuterClass.this. Kotlin provides a similar mechanism using this@OuterClass:

class Foo {
    val count = 1
    
    inner class Bar {
        fun theOuterThis() = this@Foo
    }
}

fun main() {
    val foo = Foo()
    val bar = foo.Bar()
    println(bar.theOuterThis()::class)
}

class Foo {

val count = 1

inner class Bar {

fun theOuterThis() = this@Foo

}

fun main() {

val foo = Foo()

val bar = foo.Bar()

println(bar.theOuterThis()::class)

}

This allows you to refer to the instance of the outer class that created the current inner class instance.

Nested Interfaces and Abstract Classes

Just as Kotlin allows you to nest classes and objects, it also supports nesting interfaces and abstract classes within other classes. This allows for tightly-coupled behavior that can be easily referenced.

class Thingy {
    interface Transmogrifier {
        fun transmogrify(): Thingy
    }
}

val moggle = object : Thingy.Transmogrifier {
    override fun transmogrify() = Thingy()
}

val thingy = moggle.transmogrify()

class Thingy {

interface Transmogrifier {

fun transmogrify(): Thingy

}

val moggle = object : Thingy.Transmogrifier {

override fun transmogrify() = Thingy()

}

val thingy = moggle.transmogrify()

Nesting interfaces or abstract classes can be useful when you want to define a specific behavior that is closely tied to the outer class.

Conclusion

Kotlin’s approach to nested objects and classes is powerful and offers a lot of flexibility. Whether you are using companion objects for static-like behavior, nested classes to group related functionality, or inner classes to access instance members, Kotlin makes it easy to define and organize your code in a clear and concise manner. By understanding these concepts, you can better design your Kotlin applications, making use of the full capabilities of the language.

Happy coding!