Anonymous Class in Java

In Java, an anonymous class is a class without a name, defined and instantiated in a single expression. It allows you to create and instantiate a class simultaneously, typically used for implementing interfaces or abstract classes. 

Anonymous classes provide a more concise and readable approach to code, especially for event handling and callbacks.

This tutorial explores the concept of anonymous classes in Java, their syntax, practical examples, and best practices to help you write cleaner and more efficient code.

Improve your Java programming skills with our Software Development courses — take the next step in your learning journey! 

Understanding the Anonymous Class in Java

What makes anonymous classes in Java unique is that they can directly access variables and methods of the enclosing class (including final or effectively final variables)

This makes them particularly useful in situations like event listeners or as arguments to methods that expect an interface implementation.

For example, when working with UI frameworks like Swing or JavaFX, anonymous classes are frequently used to implement event listeners such as button click handlers.

Here are some of the benefits of using anonymous classes:

• Concise Code: Anonymous classes help reduce the amount of code needed for one-off implementations.
• Improved Readability: They make the code more readable and less cluttered, especially when implementing simple interfaces.
• Immediate Use: They can be instantiated and used immediately without needing to create a separate class.

You should use anonymous classes when:

• You need a simple one-off implementation of an interface or abstract class.
• You’re handling event listeners or callbacks where creating a separate class is unnecessary.
• You need to extend an abstract class or interface for temporary use.

Anonymous classes follow a very specific syntax:

ClassName obj = new ClassName() {
    // Methods and variables of the anonymous class
};

Here, ClassName is an interface or an abstract class, and the class body contains the necessary method implementations or overrides.

Example: Basic Anonymous Class Implementation

// Define a simple interface
interface Animal {
    void sound();
}

public class Main {
    public static void main(String[] args) {
        // Anonymous class implementing the Animal interface
        Animal cat = new Animal() {
            @Override
            public void sound() {
                System.out.println("Meow");
            }
        };
        
        // Call the method in the anonymous class
        cat.sound(); // Output: Meow
    }
}

Explanation: In this example, you define an interface Animal with a method sound(). 

You then create an anonymous class that implements the Animal interface and provides an implementation of the sound() method. 

The output is "Meow" when the method is called.

Output:

Meow

Also Read: What is Inner Class in Java? 

Anonymous Class with Interfaces

Anonymous classes are often used to provide a quick implementation for interfaces. Let’s see an example with the Runnable interface.

Java Anonymous Class Example: Using Anonymous Class with an Interface

public class Main {
    public static void main(String[] args) {
        // Anonymous class implementing Runnable interface
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Running in a thread!");
            }
        };
        
        // Create a thread and start it
        Thread thread = new Thread(myRunnable);
        thread.start(); // Output: Running in a thread!
    }
}

Explanation: Here, an anonymous class implements the Runnable interface, which requires a run() method. 

The run() method simply prints a message when the thread starts. You then create a Thread object and pass the anonymous class as its argument.

Output:

Running in a thread!

Anonymous Class with Abstract Classes

Anonymous classes can also be used to extend abstract classes. 

Here’s how they can be used to extend an abstract class and override its methods.

Example: Using Anonymous Class with an Abstract Class

abstract class Animal {
    abstract void sound();
}

public class Main {
    public static void main(String[] args) {
        // Anonymous class extending the abstract Animal class
        Animal dog = new Animal() {
            @Override
            void sound() {
                System.out.println("Woof");
            }
        };
        
        dog.sound(); // Output: Woof
    }
}

Explanation: In this example, you define an abstract class Animal with an abstract method sound(). 

Then, you create an anonymous class that extends Animal and provides an implementation for the sound() method. The result is "Woof" when the sound() method is invoked.

Output:

Woof

You’ve seen how anonymous classes simplify code by eliminating the need for separate class declarations. They are especially useful in situations like event handling and threading. 

Also Read: Master Abstract Class and Method in Java for Clear OOP

Now that you've learned the basics of anonymous classes, let’s move on to some practical examples. This will help you see how to apply anonymous classes in real-world scenarios, such as event handling and multi-threading.

Practical Examples of Anonymous Classes

Anonymous classes allow you to implement interfaces, extend abstract classes, and handle events with minimal code. In this section, we’ll explore real-world scenarios where anonymous classes simplify tasks like event handling, multi-threading, and inline interface implementations, making your code more concise and efficient.

Java Anonymous Class Example 1: Using Anonymous Class with an Interface

Anonymous classes are ideal for quickly implementing interfaces, especially when the implementation is required in a single place and doesn’t justify creating a separate class. This is commonly seen in scenarios like event handling or simple callbacks.

For example, let's say you need to implement a simple interface to log messages.

Code Example: Using Anonymous Class with an Interface

// Define a simple interface
interface Logger {
    void log(String message);
}

public class Main {
    public static void main(String[] args) {
        // Anonymous class implementing the Logger interface
        Logger consoleLogger = new Logger() {
            @Override
            public void log(String message) {
                System.out.println("Log: " + message);
            }
        };
        
        // Using the anonymous class
        consoleLogger.log("This is a log message.");  // Output: Log: This is a log message.
    }
}

Explanation: In this example, you define a Logger interface with a method log(). The anonymous class implements this interface and provides an implementation for the log() method. You then use the anonymous class to print a log message to the console.

Output:

Log: This is a log message.

Java Anonymous Class Example 2: Using Anonymous Class with an Abstract Class

Anonymous classes can also extend abstract classes to provide implementations for their abstract methods directly, without needing to define a full class. This is particularly useful when you only need a one-time implementation. 

Here’s how you can use an anonymous class to extend an abstract class and provide implementations for abstract methods.

Code Example: Using Anonymous Class with an Abstract Class

abstract class Shape {
    abstract void draw();
}

public class Main {
    public static void main(String[] args) {
        // Anonymous class extending the abstract class Shape
        Shape circle = new Shape() {
            @Override
            void draw() {
                System.out.println("Drawing a circle.");
            }
        };
        
        circle.draw();  // Output: Drawing a circle.
    }
}

Explanation: 

Here, Shape is an abstract class with an abstract method draw(). 

You create an anonymous class that extends Shape and provides a concrete implementation of the draw() method. When circle.draw() is called, it prints "Drawing a circle".

Output:

Drawing a circle.

Also Read: Exploring the 14 Key Advantages of Java: Why It Remains a Developer's Top Choice in 2025

Java Anonymous Class Example 3: Event Handling with Anonymous Classes

Anonymous classes are especially useful in event handling scenarios, such as GUI development, where you need to quickly implement listeners for user interactions like button clicks. 

Instead of creating separate listener classes, you can define the event handler directly within the method, making your code more concise and easier to maintain.

Code Example: Event Handling with Anonymous Classes

import javax.swing.*;
import java.awt.event.*;

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Anonymous Class Example");
        JButton button = new JButton("Click Me");
        
        // Using an anonymous class for handling button click
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button clicked!");
            }
        });
        
        frame.add(button);
        frame.setSize(200, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Explanation: In this example, you create a JFrame and a JButton. 

You use an anonymous class to implement the ActionListener interface, providing an actionPerformed() method that prints "Button clicked!" when the button is pressed. This is a typical use case of anonymous classes for handling events in GUIs.

Output: When the button is clicked, the console will print:

Button clicked!

Java Anonymous Class Example 4: Anonymous Class in Multi-threading

Anonymous classes are useful in multi-threading scenarios when you need to implement the Runnable interface or extend the Thread class for a simple, one-time task. 

Instead of creating a separate class or defining a full-fledged Runnable implementation, you can use an anonymous class directly to define the task and run it in a thread.

This is especially helpful for tasks that don’t need to be reused or don't justify the creation of a new class.

Code Example: Anonymous Class in Multi-threading

public class Main {
    public static void main(String[] args) {
        // Anonymous class implementing Runnable interface for threading
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running!");
            }
        };
        
        // Create and start the thread
        Thread thread = new Thread(task);
        thread.start();  // Output: Thread is running!
    }
}

Explanation: In this example, you use an anonymous class to implement the Runnable interface. The run() method simply prints "Thread is running!" to the console. You then create a Thread object and pass the anonymous class to it, starting the thread immediately.

Output:

Thread is running!

These practical examples show how anonymous classes can be effectively used in different scenarios such as implementing interfaces, handling events, and managing threads.

Also Read: Careers in Java: How to Make a Successful Career in Java in 2025

Now that you’ve seen how anonymous classes work in practice, it’s time to look at their advantages and limitations.

Advantages and Limitations of Anonymous Classes

Anonymous classes offer several benefits, especially in situations that require quick, localized implementations of interfaces or abstract classes. They help streamline code, eliminate boilerplate, and make applications more concise. 

However, like any tool, anonymous classes come with their own set of limitations that can impact their usability in certain scenarios.

Understanding both the strengths and drawbacks of anonymous classes will help you decide when and where to use them effectively.

Let’s break down the key advantages and limitations:

Also Read: Difference between Abstract Class and Interface

After understanding the pros and cons of anonymous classes, let’s explore some of the best practices for using them. This will guide you in writing clean, efficient, and maintainable code while avoiding common mistakes.

Best Practices for Using Anonymous Classes

While anonymous classes are a powerful tool in Java, it’s essential to apply them strategically. When used correctly, they can reduce boilerplate code and make your applications more concise and efficient. 

However, misuse or overuse of anonymous classes can lead to harder-to-maintain code, performance bottlenecks, and confusion. By following these best practices, you can harness the full potential of anonymous classes while avoiding common pitfalls that might arise when using them incorrectly.

When to Avoid Anonymous Classes

Though anonymous classes are convenient, they’re not always the best choice. There are several situations where using them could lead to poor design and harder-to-maintain code:

• Complex Logic: If the logic inside the anonymous class is complex, it’s better to define a named class. This improves readability and simplifies debugging.
• Reuse Needs: If you anticipate needing the class in multiple places, consider creating a named class to avoid code duplication.
• Inheritance Needs: Anonymous classes can extend only one class or implement one interface. If you need to extend multiple classes or work with more than one interface, anonymous classes aren’t the best choice.

In these cases, creating a regular, named class will improve long-term maintainability and flexibility.

Performance Considerations

Anonymous classes come with minimal overhead, but there are certain performance implications that you should consider:

• Memory Usage: Anonymous classes have an implicit reference to the outer class, which can lead to higher memory consumption. This is typically minor unless you’re creating numerous anonymous classes in a memory-sensitive environment.
• Reflection and Serialization: Since anonymous classes don’t have names, using reflection or serialization on them can be more cumbersome and less efficient than working with named classes.
• Inlining Code: The JVM may optimize some anonymous classes, but since they often contain closures (references to local variables), there could be performance costs associated with capturing those variables.

In general, the performance impact of anonymous classes is negligible for most applications, but for high-performance or resource-constrained environments, consider alternatives like named inner classes or lambdas (for functional interfaces).

Code Maintainability and Readability

One of the key reasons to use anonymous classes is to write more concise code, but this comes at the expense of maintainability and readability in some cases. Here's how you can strike the right balance:

• Keep It Simple: Anonymous classes are best suited for simple, one-off implementations. For more complex logic, create a named class to improve readability and debugging.
• Limit Nesting: Avoid deeply nested anonymous classes. If you find yourself using an anonymous class inside another anonymous class, it's often a sign that you should refactor the code into a named class.
• Use Meaningful Names: Even though anonymous classes don’t have a name, ensure that variables and methods within them are clearly named to describe their functionality, especially when handling events or callbacks.

By following these guidelines, you’ll be able to keep your code concise and readable while avoiding pitfalls that could make future maintenance more difficult.

Also Read: What is Composition in Java With Examples

To solidify your understanding of Anonymous in Java, test your knowledge with a quiz. It’ll help reinforce the concepts discussed throughout the tutorial and ensure you're ready to apply them in your projects.

Quiz to Test Your Knowledge on Anonymous Classes in Java

Assess your understanding of anonymous classes, their advantages, limitations, and best practices by answering the following multiple-choice questions. Test your knowledge now!

1. What is an anonymous class in Java?

a) A class that has no methods

b) A class without a name, created and instantiated in a single expression

c) A class used exclusively for event handling

d) A class with a fixed, predefined implementation

2. When is using an anonymous class most beneficial?

a) For reusable, complex functionality

b) For quick, one-off implementations of interfaces or abstract classes

c) When you need a named class

d) When you want to extend multiple classes

3. What is a limitation of anonymous classes?

a) They cannot implement interfaces

b) They can only extend one class or implement one interface

c) They can be reused like regular classes

d) They cannot be used in event-driven programming

4. Which of the following is NOT a benefit of anonymous classes?

a) Reduced boilerplate code

b) Simplified event handling

c) Improved debugging

d) Compact code

5. What is one key disadvantage of anonymous classes related to debugging?

a) They increase the compilation time

b) Stack traces can be harder to interpret due to the lack of class names

c) They can't be used in multi-threaded applications

d) They make the code slower to execute

6. How do anonymous classes impact memory usage?

a) They use less memory than regular classes

b) They implicitly hold a reference to the outer class, increasing memory usage

c) They never use any memory

d) They use more memory only when performing complex tasks

7. Which of the following scenarios would be most suitable for using an anonymous class?

a) Extending multiple classes

b) Implementing a one-time event handler in a GUI application

c) Creating a complex mathematical function

d) Sharing functionality between multiple classes

8. Which of the following is a best practice when using anonymous classes?

a) Use them for complex, reusable code

b) Limit their use to simple, one-off implementations

c) Always use them inside loops to handle multiple tasks

d) Avoid using them when implementing interfaces

9. What should you consider when using an anonymous class in a multi-threaded environment?

a) They are always the most efficient choice for threading

b) They may cause memory leaks due to references to the outer class

c) They perform better than regular thread implementations

d) They are incompatible with the Runnable interface

10. What is one of the key limitations of using anonymous classes for event handling?

a) They cannot implement more than one interface

b) They do not allow access to event parameters

c) They can lead to unclear, difficult-to-debug code if the logic is too complex

d) They are slower than named classes for event handling

This quiz will help you evaluate your understanding of anonymous classes, how they work, and their impact on your Java code. 

Also Read: Top 8 Reasons Why Java Is So Popular and Widely Used in 2025

You can also continue expanding your skills in Java with upGrad, which will help you deepen your understanding of advanced Java concepts and real-world applications.

Upskill with upGrad to Stay Ahead of Industry Trends 

upGrad’s courses provide expert training in Java programming, with a focus on anonymous classes, their practical applications, and best practices. Learn how to optimize your Java applications and write clean, maintainable code using this powerful feature of Java.

Below are some relevant upGrad courses:

• Core Java Basics
• JavaScript Basics from Scratch
• Learn Basic Python Programming
• Data Structures & Algorithms
• AI-Powered Full Stack Development Course by IIITB

You can also get personalized career counseling with upGrad to guide your career path, or visit your nearest upGrad center and start hands-on training today! 

Similar Reads:

• Step by Step Java Tutorial Concepts - From Beginner to Pro
• What is Java? Java Programming Language Explained
• History of Java
• Java Tutorial for Beginners
• How Java Program Works?
• What is Java JDK? Java Development Kit
• C++ Vs Java: Choosing the Right Language for Your Project
• Difference between Python and Java
• Difference Between Java and JavaScript
• C++ Vs Java: Choosing the Right Language for Your Project
• Difference between Python and Java
• Difference Between Java and JavaScript
• From Java Source Code to Executable
• Java Installation on Linux: A Beginner-Friendly Guide
• Step-by-Step Guide: Installing Java on Windows 10
• Java Hello World Program: Your First Step into Java Programming

FAQs

1. How do anonymous classes impact code readability in larger applications?

Anonymous classes can make code more concise, but if overused in large applications, they can hinder readability. It’s important to avoid embedding too many complex operations within them. Using them sparingly helps keep your code clean and understandable.

2. Can anonymous classes be used in lambda expressions?

No, anonymous classes and lambda expressions are different constructs in Java. While both can be used for functional programming, lambda expressions are more concise and flexible than anonymous classes, particularly when implementing functional interfaces.

3. Are anonymous classes thread-safe?

Anonymous classes themselves don’t guarantee thread safety. If the anonymous class accesses shared resources, you need to manage synchronization manually to ensure thread safety, as it behaves like any regular class in multi-threaded environments.

4. How can anonymous classes help in GUI programming?

In GUI programming, anonymous classes are frequently used to handle events like button clicks or mouse movements. They allow you to define event listeners directly where needed, minimizing the boilerplate and keeping event handling logic close to the GUI component.

5. What are the memory considerations when using anonymous classes?

Since anonymous classes capture local variables from their enclosing scope, they hold references to them. If not used carefully, this can increase memory usage, especially if the anonymous class is frequently instantiated or retains unnecessary references.

6. Can an anonymous class access private members of the enclosing class?

Yes, anonymous classes can access the private members of the enclosing class, as long as they are within the same scope. This feature is helpful when you need to create a concise class implementation that interacts closely with the enclosing class.

7. Why would you choose an anonymous class over a regular inner class?

You would choose an anonymous class when you need to implement a class with minimal code for a one-time task, such as handling an event or performing a quick calculation. If you need more extensive functionality or reuse, a regular inner class would be a better option.

8. How can I manage exceptions effectively within an anonymous class?

Managing exceptions inside an anonymous class is similar to handling them in regular classes. You can use try-catch blocks to handle exceptions, but be cautious not to overload the anonymous class with too many complex error-handling logic, as this can make it harder to debug.

9. What challenges arise when debugging anonymous classes?

Since anonymous classes don't have explicit names, stack traces can be harder to interpret. Debugging can become tricky when the logic inside the anonymous class is complex. One way to address this is to refactor the anonymous class into a named class during development if debugging becomes difficult.

10. What performance overheads should I be aware of when using anonymous classes?

Anonymous classes may incur a small performance overhead due to the need to store references to the enclosing class, especially if they capture local variables. In performance-critical applications, consider using named classes or lambdas to avoid this overhead.

11. Are there any limitations when using anonymous classes with Java's functional interfaces?

Although anonymous classes can implement functional interfaces, they lack the conciseness of lambda expressions. Lambdas are preferred for functional interfaces because they provide a cleaner and more compact syntax, whereas anonymous classes tend to introduce unnecessary boilerplate.

Take the Free Quiz on Java

Answer quick questions and assess your Java knowledge

Start Quiz