In Kotlin, an inner class is a class that is nested inside another class, and it has access to the outer class’s properties and methods. Inner classes are useful when you need to group related classes together or when you need to access the outer class’s properties and methods from within the inner class. In this article, we’ll cover all aspects of inner classes in Kotlin.

Declaring an Inner Class

To declare an inner class in Kotlin, you simply use the keyword inner before the class declaration. Here’s an example:

class OuterClass {
    inner class InnerClass {
        // inner class properties and methods
    }
}

In the example above, we have an OuterClass with an inner class called InnerClass.

Relationship between outer and inner class

The relationship between an outer class and an inner class is not an “is-a” relationship, but a “has-a” relationship (composition or aggregation). That means Inner classes can be used when one type of object cannot exist without another type of object. For example, if a university has several departments, the department class can be declared inside the university class since departments cannot exist without the university.

Accessing Outer Class Members

Since an inner class has access to the outer class’s properties and methods, you can access them using this keyword with the name of the outer class. Here’s an example:

class OuterClass {
    private val outerProperty = "Hello, softAai!"

    inner class InnerClass {
        fun printOuterProperty() {
            println(this@OuterClass.outerProperty)
        }
    }
}

fun main() {
    val outer = OuterClass()
    val inner = outer.InnerClass()
    inner.printOuterProperty() // output: Hello, softAaiHer!
}

Here, we have an OuterClass with a private property called outerProperty. We also have an inner class called InnerClass with a method called printOuterProperty that prints the outerProperty using the this@OuterClass syntax.

Creating an Inner Class Instance

To create an instance of an inner class, you first need to create an instance of the outer class. Here’s an example:

class OuterClass {
    inner class InnerClass {
        // inner class properties and methods
    }
}

fun main() {
    val outer = OuterClass()
    val inner = outer.InnerClass()
}

In the example above, we have an OuterClass with an inner class called InnerClass. We create an instance of the OuterClass called outer and then create an instance of the InnerClass called inner using the outer.InnerClass() syntax.

Types of Inner Classes

1. Nested classes:

Nested classes are declared using the class keyword and are by default static. They can access only the members of the outer class that are static. Here’s an example:

class Outer {
    private val outerMember: Int = 1

    companion object {
        const val companionMember = "This is a companion object member."
    }

    class Nested {
        fun print() {
            println("This is a nested class.")
        }
    }
}

In this example, the Nested class is nested within the Outer class, and the companion object can be accessed without an instance of the Outer class. The companion object can also access the private members of the Outer class. the Nested class is a static nested class that can be accessed without an instance of the outer class. You can create an instance of the Nested class and access the print method like this:

val nested = Outer.Nested()
nested.print() // This is a nested class.

And you can access the companion object member like this:

println(Outer.companionMember) // This is a companion object member.

It can only access the outerMember if it is also declared as static.

2. Inner classes:

Inner classes are declared using the inner keyword and are by default non-static. They can access both instance and static members of the outer class. Here’s an example:

class Outer {
    private val outerMember: Int = 1

    inner class Inner {
        fun print() {
            println("This is an inner class with access to outerMember: $outerMember.")
        }
    }
}

In this example, the Inner class is an inner class that can access both instance and static members of the Outer class. You need to create an instance of the Outer class first before you can create an instance of the Inner class:

val outer = Outer()
val inner = outer.Inner()
inner.print() // This is an inner class with access to outerMember: 1.

Anonymous inner classes:

Anonymous inner classes are unnamed inner classes that are declared and instantiated in a single expression. They are often used for implementing interfaces or extending classes in a concise way. Here’s an example:

interface OnClickListener {
    fun onClick()
}

class Button {
    fun setOnClickListener(listener: OnClickListener) {
        // ...
    }
}

fun main() {
    val button = Button()
    button.setOnClickListener(object : OnClickListener {
        override fun onClick() {
            println("Button clicked!")
        }
    })
}

In this example, the OnClickListener interface is implemented as an anonymous inner class and passed to the setOnClickListener method of the Button class. This allows us to implement the interface inline without having to define a separate class.

Local inner classes:

Local inner classes are declared inside a block of code, such as a function or a method, and can access both local variables and members of the enclosing class. Here’s an example:

fun outerFunction() {
    val outerMember: Int = 1

    class Inner {
        fun print() {
            println("This is a local inner class with access to outerMember: $outerMember.")
        }
    }

    val inner = Inner()
    inner.print() // This is a local inner class with access to outerMember: 1.
}

In this example, the Inner class is a local inner class declared inside the outerFunction function. It can access the outerMember variable of the function, as well as any other members of the outerFunction class.

Use cases of inner classes

Let’s discuss nested and anonymous inner classes in different scenarios to understand their use cases better.

1. Various combinations of nested classes and interfaces

In Kotlin, you can declare nested classes and interfaces inside other classes, and you can use them in various combinations. Here are some examples of different combinations of nested classes and interfaces:

1.a) Interface inside a class:

class MyClass {
    interface MyInterface {
        fun doSomething()
    }
}

In this example, we declare an interface MyInterface inside the class MyClass. This interface can be implemented by any class, but it is only accessible through an instance of MyClass.

1.b) Nested class inside an interface:

interface MyInterface {
    class NestedClass {
        fun doSomething() {
            println("NestedClass is doing something")
        }
    }
}

In this example, we declare a nested class NestedClass inside the MyInterface. This nested class can be accessed without an instance of MyInterface. We can create an instance of this class and call its doSomething() method as follows:

val nestedClass = MyInterface.NestedClass()
nestedClass.doSomething() // prints "NestedClass is doing something"

1.c) Interface inside a nested class:

class MyClass {
    class MyNestedClass {
        interface MyInterface {
            fun doSomething()
        }
    }
}

In this example, we declare an interface MyInterface inside the nested class MyNestedClass. This interface can be implemented by any class, but it is only accessible through an instance of MyClass.MyNestedClass.

1.d) Nested class inside another nested class:

class MyClass {
    class MyOuterNestedClass {
        class MyInnerNestedClass {
            fun doSomething() {
                println("MyInnerNestedClass is doing something")
            }
        }
    }
}

In this example, we declare a nested class MyOuterNestedClass inside the MyClass, and a nested class MyInnerNestedClass inside the MyOuterNestedClass. This nested class can be accessed without an instance of MyClass. We can create an instance of this class and call its doSomething() method as follows:

val nestedClass = MyClass.MyOuterNestedClass.MyInnerNestedClass()
nestedClass.doSomething() // prints "MyInnerNestedClass is doing something"

2. Anonymous Inner class

2.a)Anonymous Inner class that extends a class:

open class SuperClass {
    open fun sayHello() {
        println("Hello from SuperClass")
    }
}

fun main() {
    val obj = object : SuperClass() {
        override fun sayHello() {
            println("Hello from anonymous inner class")
        }
    }
    obj.sayHello() // Output: Hello from anonymous inner class
}

You can create an anonymous inner class that extends a class using the object keyword followed by the class name in parentheses and the body of the class in curly braces.

2.b) Anonymous Inner class that implements an interface:

interface MyInterface {
    fun sayHello()
}

fun main() {
    val obj = object : MyInterface {
        override fun sayHello() {
            println("Hello from anonymous inner class")
        }
    }
    obj.sayHello() // Output: Hello from anonymous inner class
}

You can create an anonymous inner class that implements an interface using the object keyword followed by the interface name and the body of the class in curly braces.

2.c) Anonymous Inner class that is defined inside arguments:

fun doSomething(callback: () -> Unit) {
    callback()
}

fun main() {
    doSomething(object : Runnable {
        override fun run() {
            println("Hello from anonymous inner class")
        }
    })
}

You can define an anonymous inner class inside the arguments of a function call or constructor call using the object keyword followed by the class name, interface name, or a generic type and the body of the class in curly braces.

3. Access inner classes from different areas of the outer class

3.a) Access from instance methods or properties of the outer class:

fun doSomething(callback: () -> Unit) {
    callback()
}

fun main() {
    doSomething(object : Runnable {
        override fun run() {
            println("Hello from anonymous inner class")
        }
    })
}

Use this@Outer to refer to the outer class instance, followed by the dot operator and the name of the inner class.

3.b) Access from static methods or properties of the outer class:

class Outer {
    companion object {
        fun staticMethod() {
            val inner = Outer.Inner()
            inner.printMessage() // Output: Hello from inner class
        }
    }
    
    inner class Inner {
        fun printMessage() {
            println("Hello from inner class")
        }
    }
}

fun main() {
    Outer.staticMethod()
}

Use Outer. followed by the name of the inner class.

3.c) Access from another inner class of the outer class:

class Outer {
    private val outerProperty = "Outer property"
    
    inner class InnerA {
        inner class InnerB {
            fun printOuterProperty() {
                println(this@Outer.outerProperty)
            }
        }
    }
}

fun main() {
    val outer = Outer()
    val innerA = outer.InnerA()
    val innerB = innerA.InnerB()
    innerB.printOuterProperty() // Output: Outer property
}

Use this@Outer followed by the dot operator and the name of the inner class.

In all these cases, you can use this keyword to refer to the instance of the current class (inner or outer) and super keyword to refer to the superclass of the current class.

4. Inner Classes with Inheritance

Inner classes can also inherit from other classes. When you inherit from a class in an inner class, you can access the outer class’s properties and methods using the super keyword. Here’s an example:

class Outer {
    private val outerProperty = "Outer property"
    
    inner class InnerA {
        inner class InnerB {
            fun printOuterProperty() {
                println(this@Outer.outerProperty)
            }
        }
    }
}

fun main() {
    val outer = Outer()
    val innerA = outer.InnerA()
    val innerB = innerA.InnerB()
    innerB.printOuterProperty() // Output: Outer property
}

In this example, the Person class has an open method called greet() which is overridden in the Student class using the override keyword. Within the Student class, an Internship inner class is defined that extends the Job inner class of the Person class.

In the Internship class, the super keyword is used to refer to the printDetails() method of the Job class in the Person class. This allows the Internship class to inherit and extend the behavior of the Job class while also adding its own functionality.

5. Inner classes to improve encapsulation

5.a) Access to Outer Class Properties and Methods

class OuterClass(private val name: String) {
    private val id: Int = 123

    inner class InnerClass {
        fun printOuterName() {
            println(name) // can access name property of outer class
        }
        fun printOuterId() {
            println(id) // can access id property of outer class
        }
    }
}

Here InnerClass can access the private name and id properties of the OuterClass. This allows you to keep these properties hidden from the rest of the codebase, while still allowing the InnerClass to use them as needed.

5.b) Logical Grouping

class NetworkConnection {
    private val connectionUrl = "https://softaai.com"
    private val timeout = 5000

    inner class Message {
        fun send(message: String) {
            // implementation
        }
    }
}

In this example, the Message inner class represents a message to be sent over the network connection. By grouping this related functionality into its own class, you can make your code more organized and easier to understand.

5.c) Better Separation of Concerns

class ItemListView {
    private val items = listOf("item1", "item2", "item3")

    inner class ItemSelectionHandler {
        fun onItemSelected(item: String) {
            // implementation
        }
    }
}

In above example, the ItemSelectionHandler inner class handles item selection events in the ItemListView. By separating this functionality into its own class, you can make your code more modular and easier to test.

5.d) Access Control

class OuterClass {
    private val name: String = "John"

    inner class InnerClass {
        private val age: Int = 30 // private to InnerClass
        fun printName() {
            println(name) // can access name property of outer class
        }
        fun printAge() {
            println(age) // can access age property of inner class
        }
    }
}

In this example, the age property of the InnerClass is private to that class, and cannot be accessed from outside. This helps to prevent unwanted access to certain parts of your codebase and improve the security of your application.

Advantages of Inner Classes in Kotlin

1. Encapsulation: Inner classes can access private members of the enclosing class, which helps to encapsulate the code and restrict access to certain parts of the code.
2. Code organization: Inner classes help to organize the code and keep related code together. This makes the code easier to read and understand.
3. Improved code reuse: Inner classes can be reused in multiple places within the enclosing class, which reduces code duplication and improves code maintainability.
4. Improved readability: Inner classes can be used to define small, self-contained units of code that are easier to read and understand.
5. Access to outer class: Inner classes have access to the methods and variables of the outer class, which can be useful in certain situations.

Disadvantages of Inner Classes in Kotlin

1. Increased complexity: Inner classes can make the code more complex, especially when multiple layers of inner classes are used.
2. Performance overhead: Inner classes can result in additional memory usage and performance overhead, especially if the inner class is not static.
3. Tight coupling: Inner classes can create tight coupling between the inner class and the outer class, which can make it difficult to reuse the code in other contexts.
4. Potential for memory leaks: Inner classes can create memory leaks if they hold references to the outer class, as this can prevent the outer class from being garbage collected.
5. Name conflicts: Inner classes can have the same name as classes in the outer scope, which can lead to naming conflicts and make the code harder to read and understand.