Question

I have done some searching on the difference in implementing a closure using an anonymous class and a local class. I am trying to figure out all the differences between the two so I know which method is better in which situations.

Correct me if I am wrong:

• The anonymous class has a class instance and object instance created each time a new instance is created.
• The local class has only an object instance create each time a new instance is created.

Therefore, is there ever a time or place where I should use an anonymous class over a local class?

EDIT: It appears there is no real difference between the two, just depends on style and if you want to reuse the class.

To clarify what I mean here is an example of what I am talking about:

public class ClosureExample {
interface Function {
    void func(int value);
}

public static void main(final String[] args) {
    final Function local1 = localClassClosure("Local1");
    final Function local2 = localClassClosure("Local2");

    final Function anonymous1 = anonymousClassClosure("Annonymous1");
    final Function anonymous2 = anonymousClassClosure("Annonymous2");

    for (int i = 0; i < 3; i++) {
        local1.func(i);
        local2.func(i);
        anonymous1.func(i);
        anonymous2.func(i);
    }
}

private static Function localClassClosure(final String text) {
    // Local class name is irrelevant in this example
    class _ implements Function {
        @Override public void func(final int value) {
            System.out.println(text + ":" + value);
        }
    }
    return new _();
}

private static Function anonymousClassClosure(final String text) {
    return new Function() {
        @Override public void func(final int value) {
            System.out.println(text + ":" + value);
        }
    };
}
}

Hopefully, someone can explain in detail this subtle difference and which method should be used in which situations.

Answer 1

I am pretty sure there is nothing like object instance, just class instance .
So yes an object is created for both local and anonymous types..
The difference however is you can’t reuse the anonymous class (except through the way you used it in your method – which works but not really maintainable), so you use it when whatever you are doing is a one off thing. For example with event listeners.

I would prefer named types to anonymous types though.

You might find this useful

EDIT:
You will find my question here useful.