Tell about nested classes and in what cases they are…

Nested classes in Java are classes defined within another class. They are divided into two types: static nested classes and inner classes.

Static Nested Classes

Declared with the static modifier.
Have access only to static members of the outer class (even hidden ones).
Do not have access to non-static members of the outer class.

To create an instance of a static nested class, an instance of the outer class is not required:

// Outer class
class Outer {
    static int outerStaticField;
    int outerInstanceField;

    // Static nested class
    static class StaticNested {
        void accessOuter() {
            // Access to static field of outer class
            System.out.println(Outer.outerStaticField);
            // No access to outerInstanceField
            // System.out.println(outerInstanceField); // Compilation error
        }
    }
}

// Using static nested class
class Main {
    public static void main(String[] args) {
        Outer.StaticNested nestedObject = new Outer.StaticNested();
        nestedObject.accessOuter();
    }
}

Inner Classes

Not declared with the static modifier.
Have full access to all members of the outer class (static and non-static, even hidden).
An instance of an inner class cannot exist without an instance of the outer class.

To create an instance of an inner class, an instance of the outer class is required:

// Outer class
class Outer {
    static int outerStaticField;
    int outerInstanceField;

    // Inner class
    class Inner {
        void accessOuter() {
            // Access to static field of outer class
            System.out.println(Outer.outerStaticField);
            // Access to non-static field of outer class
            System.out.println(outerInstanceField);
        }
    }
}

// Using inner class
class Main {
    public static void main(String[] args) {
        Outer outerObject = new Outer();
        Outer.Inner innerObject = outerObject.new Inner();
        innerObject.accessOuter();
    }
}

Inner classes are subdivided into:

Regular inner classes: Defined directly within the body of the outer class.

Local inner classes: Defined within methods, constructors, or initialization blocks and are visible only within that block.

class Outer {
    void display() {
        class LocalInner { // Local inner class
            void message() {
                System.out.println("Local inner class");
            }
        }
        LocalInner obj = new LocalInner();
        obj.message();
    }
}

Anonymous inner classes: Classes without a name, used to create an instance of a class or interface and immediately provide their implementation. Often used with event listeners.

interface Greeting {
    void sayHello();
}

class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() { // Anonymous inner class
            @Override
            public void sayHello() {
                System.out.println("Hello!");
            }
        };
        greeting.sayHello();
    }
}

When are nested classes used:

Logical grouping: When a class is only a part of another class and it makes sense to group them together. This improves code readability and maintainability.
Encapsulation: Nested classes can access members of the outer class, providing a tighter coupling and hiding implementation details.
More readable code: When a small, simple class is used only in one place, nesting it can make the code cleaner.
Efficient resource usage: Inner classes have access to outer class members without needing to pass them explicitly, which can simplify code. An example is implementing iterators.
Implementing interfaces or extending classes in context: Anonymous inner classes are often used to provide a compact implementation of interfaces or abstract classes "on the fly".
Hiding implementation: Hiding a class inside another class, making it invisible outside.

Comparison of static nested and inner classes:

Parameter	Static Nested Class	Inner Class
`static` modifier	Yes	No
Access to outer class members	Only static (even private)	All members (static and non-static, private)
Requires an instance of the outer class to create	No	Yes
Connection to an instance of the outer class	No	Yes

The choice between static nested and inner class depends on whether the nested class needs access to non-static members of the outer class. If it does, use an inner class. If not, a static nested class is more suitable, as it is not tied to an instance of the outer class and can be more efficient.

Tell about nested classes and in what cases they are used.