Anonymous Class in Java

Last Updated on December 28, 2023 by Ankit Kochar

Java, a versatile and widely-used programming language, boasts numerous features that aid developers in creating efficient and robust applications. Among these features is the concept of anonymous classes, a powerful tool that allows for the creation of on-the-fly implementations of interfaces and classes.
In this article, we will delve into the intricacies of anonymous classes in Java. We’ll explore what they are, how they are used, their advantages, and various scenarios where they prove to be beneficial in Java programming. By understanding anonymous classes, developers can leverage this functionality to write more concise and readable code while enhancing the flexibility of their applications.

What is Anonymous Class in Java?

In Java, an anonymous class is a way of creating a class that does not have a name and is defined and instantiated in a single expression. They are often used when you need to create a one-time use subclass of an existing class or interface. Anonymous classes can implement an interface or extend a class and provide their own implementation of methods. They are useful when creating a class with a simple implementation that is only used once. However, they can make your code harder to read and maintain if overused, so it’s important to use them wisely. Overall, anonymous classes are a powerful tool in Java that can help you write more concise and expressive code.

Syntax of Anonymous Class in Java

new SuperclassOrInterface() {
   // Fields, methods and constructors go here
}

Explanation of Anonymous Class in Java
The syntax starts with the new keyword, followed by the name of the superclass or interface that the anonymous class is extending or implementing. Then, you enclose the class body inside curly braces. The class body contains the fields, methods, and constructors that define the behavior of the anonymous class.

Example of Anonymous Class in Java

Runnable r = new Runnable() {
    public void run() {
        System.out.println("Hello, World!");
    }
};

Explanation of Anonymous Class in Java
In an anonymous example, It implements the Runnable interface and defines a run() method that prints "Hello, World!" to the console. The anonymous class is assigned to a variable r, which can be used to execute the run() method.

How many Anonymous Classes can be Created

In Java, anonymous classes can be created in two ways:

• Subclass of a Class: An anonymous class can be created as a subclass of a class or an abstract class. This is done by extending the base class and defining the class body, all in a single expression.

  Example for Subclass of a class:

  /* Creating an anonymous class as a subclass of Thread class */
  
  Thread thread = new Thread() {
      public void run() {
          // Thread code here
      }
  };
  thread.start();

  Explanation of subclass of a class:
  In the subclass of a class example, we have created an anonymous class that implements the thread interface and defines the implementation of the run method. This anonymous class is used to create a new Thread object and start a new thread of execution.

• Implementation of an Interface: An anonymous class can also be created as an implementation of an interface. This is done by defining the interface and the class body, all in a single expression.

  Example for Implementation of an interface:

  /* Creating an anonymous class as an implementation of Runnable interface*/
  
  Runnable runnable = new Runnable() {
      public void run() {
          // Runnable code here
      }
  };
  Thread thread = new Thread(runnable);
  thread.start();

  Explanation of Implementation of an interface:
  In the implementation of an interface example, we have created an anonymous class that implements the Runnable interface and defines the implementation of the run method. This anonymous class is used to create a new Thread object and start a new thread of execution.

Types of Anonymous Classes in Java

In Java, there are two types of anonymous classes in java:

• Anonymous Inner Class: An anonymous inner class is a class that is defined and instantiated inside another class, without giving it a name. Anonymous inner classes are used when we need to implement an interface or extend a class with a single-use implementation that is not reused in other parts of the code.

• Lambda Expression: A lambda expression is a concise way to represent a single-method interface using an expression. It is similar to an anonymous inner class in that it allows us to implement an interface or extend a class with a single-use implementation, but it is more concise and easier to read.

Advantages of Anonymous Classes in Java

Some advantages of anonymous classes in Java are:

• Easy implementation of callbacks
• Flexibility and reusability
• Encapsulation of code
• Conciseness and readability

Disadvantages of Anonymous Classes in Java

Some disadvantages of anonymous classes in Java are:

• They cannot be reused in other parts of the codebase, leading to code duplication and reduced maintainability.
• They are only accessible within the method or scope in which they are defined, making it difficult to use them in other parts of the codebase.
• It cannot be extended or subclassed, which limits its flexibility and makes it harder to evolve the code over time.

Conclusion
Anonymous classes in Java provide a flexible mechanism for creating quick, inline implementations of classes and interfaces. They offer a convenient way to reduce boilerplate code and enhance the readability of code by encapsulating implementations closer to where they are used. By understanding the nuances and best practices related to anonymous classes, Java developers can harness this feature to build more efficient and concise applications.

FAQs on Anonymous Classes in Java:

Here are some FAQs related to Anonymous Classes in Java.

1. What are anonymous classes in Java?
Anonymous classes in Java are local classes without a name that allow for the creation of an instance of a class or an implementation of an interface in a single expression.

2. How are anonymous classes different from regular classes in Java?
Unlike regular classes, anonymous classes do not have a name. They are defined and instantiated simultaneously in the same place where they are used.

3. When are anonymous classes useful in Java programming?
Anonymous classes are particularly useful when you need to create a class or interface implementation that is used only once in your code, avoiding the need for a separate named class.

4. Can anonymous classes extend classes or implement interfaces?
Yes, anonymous classes can extend a class or implement an interface. They are commonly used to create instances of abstract classes or to provide implementations for interfaces without the need for a named subclass.

5. How do you create an anonymous class in Java?
An anonymous class is created by using the new keyword with either an interface or a class, followed by a set of curly braces defining the class body.

6. Can anonymous classes access local variables of the enclosing scope?
Yes, but the local variables accessed by an anonymous class must be declared as final or effectively final. From Java 8 onwards, effectively final variables can be accessed within local classes and anonymous classes.

7. What are the limitations of anonymous classes in Java?
Anonymous classes cannot have explicit constructors and cannot be static. They are also limited in terms of reusability since they can only be used at the specific location where they are defined.

8. Are lambda expressions the same as anonymous classes?
While both lambda expressions and anonymous classes can be used to create instances of interfaces, lambda expressions are more concise and are primarily used for functional interfaces (interfaces with a single abstract method).

9. How do anonymous classes contribute to code readability and maintainability?
Anonymous classes help in writing more compact code by defining implementations inline, especially when the implementation is small and not needed elsewhere. However, excessive use of anonymous classes might reduce readability, so their usage should be balanced for code maintainability.