Anonymous inner class

Anonymous inner class

An anonymous inner class in Java is a class without a name that's defined and instantiated in a single expression. It's often used to create instances of classes that implement interfaces or extend classes without explicitly defining a new class.

Here's an example:

public class Main {

    interface Greeting {

        void greet();

    }

    public static void main(String[] args) {

        // Creating an anonymous inner class that implements the Greeting interface

        Greeting greeting = new Greeting() {

            @Override

            public void greet() {

                System.out.println("Hello from anonymous inner class!");

            }

        };

        // Invoking the method defined in the anonymous inner class

        greeting.greet();

    }

}

Explanation:

- In the example above, an anonymous inner class is created that implements the `Greeting` interface.

- The `greet()` method is overridden within the anonymous inner class to provide custom behavior.

- An instance of the anonymous inner class is created and assigned to a reference variable of the `Greeting` interface.

- Finally, the `greet()` method of the anonymous inner class instance is invoked.

Nested Class Vs Inner Class vs Anonymous inner class

Anonymous inner classes are particularly useful for event handling and callbacks in GUI programming, where you need to provide implementations for listener interfaces without defining separate named classes. They're concise and handy for one-off implementations of interfaces or subclasses of existing classes.

Nested Class:

- A nested class in Java is a class defined within another class.

- It can be static or non-static (also called inner class).

- A nested class has access to all members (fields and methods) of its enclosing class, including private members.

- It can access static members of the enclosing class directly.

- Nested classes are mainly used for logical grouping and better organization of code.

Inner Class:

- An inner class is a non-static nested class defined within another class.

- It has access to the instance variables and methods of its enclosing class.

- Inner classes can be of four types: member inner class, local inner class, anonymous inner class, and static nested class (which is technically an inner class but often referred to separately).

- They are useful for implementing callbacks, event handling, and providing encapsulation.

Anonymous Inner Class:

- An anonymous inner class is a type of inner class without a name and is declared and instantiated in a single expression.

- It's typically used for one-time use where a class definition is not needed.

- It's often used to override methods of a class or implement interfaces without explicitly defining a new named class.

- Anonymous inner classes are concise and useful for event handling and implementing interfaces with minimal code.

Comparison:

- Nested classes can be static or non-static, while inner classes are always non-static.

- Inner classes have access to the instance variables of their enclosing class, while nested classes do not.

- Anonymous inner classes are a special type of inner class that do not have a name and are declared and instantiated in a single expression.

- Nested classes and inner classes are explicitly defined in code, while anonymous inner classes are typically used for one-time implementations of interfaces or subclasses without defining a separate class.