Anonymous Inner Class in Java

Sometimes you need a class for exactly one use: a special discount for one sale, or a sort order for one list. Writing a named class in its own place for that feels like too much ceremony. An anonymous class declares the class and creates its single object in one expression, right where it's needed. It has no name, so it can't be reused, and that's the point.

Two Anonymous Classes

import java.util.Arrays;
import java.util.Comparator;
 
public class Anon {
    abstract static class Discount {
        final String name;
        Discount(String name) { this.name = name; }
        abstract long apply(long amount);
    }
 
    public static void main(String[] args) {
        Discount festival = new Discount("Festival 10%") {
            long apply(long amount) { return amount - amount / 10; }
        };
        System.out.println(festival.name + ": Rs. " + festival.apply(2000));
 
        String[] names = {"Srihitha", "Navika", "Advitha"};
        Arrays.sort(names, new Comparator<String>() {
            public int compare(String a, String b) {
                return Integer.compare(a.length(), b.length());
            }
        });
        System.out.println(Arrays.toString(names));
 
        Arrays.sort(names, (a, b) -> b.compareTo(a));
        System.out.println(Arrays.toString(names));
        System.out.println(festival.getClass().getName());
    }
}

Festival 10%: Rs. 1800
[Navika, Advitha, Srihitha]
[Srihitha, Navika, Advitha]
Anon$1

How it works

1. new Discount("Festival 10%") { ... } creates an object of a new, unnamed subclass of Discount. The argument goes to Discount's constructor, and the body implements the abstract method.
2. new Comparator<String>() { ... } creates an object of an unnamed class that implements Comparator, here sorting names by length.
3. The third sort uses a lambda, (a, b) -> b.compareTo(a), which is a much shorter way to implement an interface with a single abstract method (lambdas get their own lessons later in the course).
4. The compiler names the first anonymous class Anon$1.

The Rules

Capturing a local variable that changes later is a compile error:

public class Eff {
    void run() {
        int count = 0;
        Runnable r = new Runnable() {
            public void run() { System.out.println(count); }
        };
        count++;
    }
}

Eff.java:5: error: local variables referenced from an inner class must be final or effectively final
            public void run() { System.out.println(count); }
                                                   ^
1 error

The anonymous object gets a copy of count; if count could change afterwards, the copy and the original would disagree, so Java forbids it.

Anonymous Class or Lambda?

Common Mistakes

Changing a captured local variable. Use a final copy, or a field.

Long anonymous classes buried inside method calls. If it's longer than a few lines, give it a name.

Expecting extra methods to be callable from outside. festival.extraMethod() doesn't compile: the variable's type is Discount.

Interview Corner

Practice

1. Easy: Create a Runnable with an anonymous class that prints "Backup started for Navika", and run it with r.run().
2. Harder: Sort an array of prices in descending order twice: once with an anonymous Comparator<Integer> and once with a lambda.

Key Takeaways