Tell us about your experience with nested classes and…

Nested classes in Java are classes declared within another class.

They are divided into two types:

Static Nested Classes: Declared with the static keyword. They behave like static members of the outer class. They can only access static members of the outer class.

class Outer {
    static int outerStaticField = 1;
    int outerInstanceField = 2;

    static class StaticNested {
        void accessOuter() {
            // Access to the static field of the outer class
            System.out.println(outerStaticField);
            // Cannot access outerInstanceField directly
        }
    }
}

Inner Classes: Not declared with the static keyword. Each instance of an inner class is associated with an instance of the outer class. They have access to both static and non-static members of the outer class.

Inner classes are subdivided into:

Member Inner Classes: Declared directly inside the outer class, not inside a method or block.

class Outer {
    int outerInstanceField = 2;

    class MemberInner {
        void accessOuter() {
            // Access to the outer class's instance field
            System.out.println(outerInstanceField);
        }
    }
}

Local Classes: Declared inside a method, constructor, or initialization block. Visible only within that block.

class Outer {
    void method() {
        class LocalInner {
            void print() {
                System.out.println("Local class");
            }
        }
        LocalInner local = new LocalInner();
        local.print();
    }
}

Anonymous Classes: Classes without a name, used to create objects "on the fly", usually for implementing interfaces or extending classes.

interface MyInterface {
    void doSomething();
}

class Outer {
    void useAnonymous() {
        MyInterface anonymous = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Anonymous class implementation");
            }
        };
        anonymous.doSomething();
    }
}

Uses of nested classes:

Grouping related functionalities: Nested classes are logically related to the outer class and used only by it. This makes the code more readable.

// Example: Shape class with a nested Point class
class Shape {
    private static class Point { // Point is used only inside Shape
        int x, y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    private Point center;

    Shape(int x, int y) {
        center = new Point(x, y);
    }
}

Encapsulation: Nested classes can access private members of the outer class, allowing to hide implementation details.

Implementation of callbacks and listeners: Anonymous inner classes are often used to create listener objects or implement interfaces in a compact form.

// Example: Button listener in Swing
JButton button = new JButton("Click Me");
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked!");
    }
});

Development of collections and iterators: Inner classes are often used to implement interfaces like Iterator for accessing elements of an outer collection.
Efficient resource usage: Inner classes allow access to outer class members without needing to pass references to those members.
Implementation of the "Builder" pattern: Static nested classes are often used to implement builders for creating complex objects.

Tell us about your experience with nested classes and when they are used.