Java Anonymous Class

A Java Anonymous Class is an inner class that is declared and instantiated at the same time without giving it a name. It is mainly used when you need to override a method or implement an interface for one-time use. Anonymous classes help reduce unnecessary code by eliminating the need to create a separate class file.

Anonymous classes are commonly used in event handling, GUI programming, callback methods, and situations where an object is required only once. They make programs shorter and easier to understand when used appropriately.

What is an Anonymous Class in Java?

An anonymous class is a local inner class without a name. It is declared and instantiated in a single expression. Since it has no name, you cannot create another object from it later.

Anonymous classes can extend a class or implement an interface. They are useful when you need a simple implementation that will be used only once.

Why Use an Anonymous Class?

Creating a separate class for small tasks increases the amount of code in a project. Anonymous classes provide a simple solution by allowing developers to create and use an object immediately without defining another class.

Syntax of Anonymous Class

ClassName obj = new ClassName() {
    // Override methods here
};

Example: Anonymous Class Extending a Class

In this example, the anonymous class extends the Animal class and overrides its sound() method.

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}
public class Main  {
    public static void main(String[] args) {
        Animal obj = new Animal() {
            void sound() {
                System.out.println("Dog barks");
            }
        };
        obj.sound();
    }
}

In the above example, no separate subclass is created. Instead, the anonymous class overrides the sound() method and immediately creates an object of that class.

Example: Anonymous Class Implementing an Interface

Anonymous classes can also implement interfaces. This approach is commonly used when only one implementation of an interface is required. Instead of creating a separate class that implements the interface, you can write the implementation directly while creating the object.

interface Greeting {
    void message();
}
public class Main {
    public static void main(String[] args) {
        Greeting obj = new Greeting() {
            public void message() {
                System.out.println("Welcome to CodingRoute");
            }
        };
        obj.message();
    }
}

Advantages of Anonymous Classes

Anonymous classes offer a simple way to create one-time objects without defining additional classes. They are especially useful when the implementation is short and will not be reused elsewhere in the application.

Limitations of Anonymous Classes

Although anonymous classes simplify many programming tasks, they also have a few limitations. They are not suitable for large or reusable implementations.

When Should You Use an Anonymous Class?

Anonymous classes are useful when a class is required only once and creating a separate class would unnecessarily increase the size of the project. They are commonly used in Swing applications, event listeners, callback functions, and simple interface implementations.

Important Points About Anonymous Classes

Summary

Java Anonymous Classes provide a quick and efficient way to create one-time objects without defining separate classes. They are widely used for extending classes, implementing interfaces, and handling events in Java applications. While they reduce code size and improve readability for small tasks, they should be used carefully because large anonymous class implementations can make code difficult to understand. Learning anonymous classes is important for writing clean and efficient Java programs.