The Project | About Us | Contribute | Donations | License

HOME

Anonymous classes in Java are a way to define and instantiate a class at the same time. They are used when you need to create a class that will be instantiated only once, typically for implementing interfaces or extending classes with minimal code.

Key Concepts

Definition: An anonymous class is a local class without a name.
Usage: Commonly used for event handling, callbacks, and implementing interfaces or abstract classes on the fly.
Syntax: Defined and instantiated in a single expression.

Syntax and Structure

Basic Syntax

interface Greeting {
    void sayHello();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello, World!");
            }
        };
        greeting.sayHello();
    }
}

Explanation

Interface: Greeting is an interface with a single method sayHello().
Anonymous Class: new Greeting() { ... } creates an anonymous class that implements the Greeting interface.
Method Override: The sayHello() method is overridden within the anonymous class.
Instantiation: The anonymous class is instantiated and assigned to the greeting variable.

Practical Examples

Example 1: Implementing an Interface

interface MathOperation {
    int operate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        MathOperation addition = new MathOperation() {
            @Override
            public int operate(int a, int b) {
                return a + b;
            }
        };
        System.out.println("Addition: " + addition.operate(5, 3));
    }
}

Example 2: Extending a Class

abstract class Animal {
    abstract void makeSound();
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal() {
            @Override
            void makeSound() {
                System.out.println("Woof!");
            }
        };
        dog.makeSound();
    }
}

Practical Exercises

Exercise 1: Implementing a Runnable Interface

Task: Create an anonymous class that implements the Runnable interface and prints "Running in a thread" when executed.

Solution:

public class Main {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Running in a thread");
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

Exercise 2: Extending a Class

Task: Create an anonymous class that extends the TimerTask class and prints "Timer task executed" when run.

Solution:

import java.util.Timer;
import java.util.TimerTask;

public class Main {
    public static void main(String[] args) {
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Timer task executed");
            }
        };
        Timer timer = new Timer();
        timer.schedule(task, 1000); // Schedules the task to run after 1 second
    }
}

Common Mistakes and Tips

Scope: Anonymous classes can access final variables from the enclosing scope.
Readability: Overusing anonymous classes can make code harder to read. Use them judiciously.
Complexity: For complex logic, consider defining a named class instead of an anonymous class.

Summary

Anonymous Classes: Useful for creating one-off implementations of interfaces or abstract classes.
Syntax: Defined and instantiated in a single expression.
Use Cases: Event handling, callbacks, and simple interface implementations.
Exercises: Practice implementing interfaces and extending classes using anonymous classes.

By understanding and practicing the use of anonymous classes, you can write more concise and readable code for specific scenarios where a full class definition is unnecessary.

Anonymous Classes

Key Concepts

Syntax and Structure

Basic Syntax

Explanation

Practical Examples

Example 1: Implementing an Interface

Example 2: Extending a Class

Practical Exercises

Exercise 1: Implementing a Runnable Interface

Exercise 2: Extending a Class

Common Mistakes and Tips

Summary

Java Programming Course

Module 1: Introduction to Java

Module 2: Control Flow

Module 3: Object-Oriented Programming

Module 4: Advanced Object-Oriented Programming

Module 5: Data Structures and Collections

Module 6: Exception Handling

Module 7: File I/O

Module 8: Multithreading and Concurrency

Module 9: Networking

Module 10: Advanced Topics

Module 11: Java Frameworks and Libraries

Module 12: Building Real-World Applications