Answer.

Nested and inner classes in Kotlin are used for logical grouping and encapsulation of functionality within an outer class.

Background

The idea of nested classes came from Java as a way to structure code and isolate helper components within the main class. In Kotlin, the syntax and approach are inherited from Java, but with important differences.

The Issue

The main task is to correctly separate helper classes where they should not exist outside the context of the outer class, while requiring varying degrees of access to the members of the outer class. In Java, a nested class is by default an inner class, whereas in Kotlin, a nested class is by default static.

The Solution

In Kotlin, declaring a class inside another class by default creates a static (nested) class, meaning that this class does not have access to the members of the outer class. To gain access, the keyword inner is used.

Code example:

class Outer {
    private val secret = "outside"
    class Nested {
        fun call() = "nested: no access to Outer.secret"
    }
    inner class Inner {
        fun call() = "inner: can access $secret"
    }
}

Key features:

A nested class (class Nested) by default does not have a reference to the instance of the outer class;
An inner class (inner class Inner) has a reference and can access the members of the outer class, including private ones;
Initialization of an inner class requires an instance of the outer class.

Trick Questions.

Can a nested class access a private property of the outer class?

No, a nested class (by default) in Kotlin is static and does not contain a reference to the outer class, hence it does not have access to its properties and methods.

What is the difference between inner classes in Kotlin and Java?

In Java, a nested class is by default non-static and has a reference to the outer class. In Kotlin, on the contrary; a nested class is static, only an inner class obtains a reference to the outer instance.

Is it possible to declare an inner class in an object?

No, an inner class cannot be declared inside an object because an object cannot be instantiated.

Typical Mistakes and Anti-Patterns

Declaring an inner class where access to the outer class is not required creates excessive coupling;
Accessing members of the outer class from a nested class causes a compilation error;
Creating memory leaks due to hidden references to the outer class through inner classes.

Real-Life Example

Negative Case

A developer declares an inner class that does not use the properties of the outer class:

class Container {
    inner class Helper { fun help() = "help" }
}

Pros:

The class is easy to obtain from the outer object.

Cons:

Excessive coupling.
Possible leaks due to hidden reference to Container.

Positive Case

Using an inner class to implement access to private state of the outer class:

class Auth {
    private var token: String = ""
    inner class TokenManager {
        fun updateToken(new: String) { token = new }
    }
}