Invoking a method of an anonymous class

Question

I learned the other day that you can do this

new Object() {
    void hello() {
        System.out.println("Hello World!");
    }
}.hello();

This seems really weird to me. Surely the static type of the object created is Object, so there isn't a method hello()? Isn't it almost completely pointless (it isn't possible to invoke hello twice for example).

I have 2 questions about this.

1. Can somebody point me to the part of the specification that addresses this?
2. Am I right in thinking that the only way you can invoke hello is immediately like this. What about reflection?

Thanks

Answer 1

Can somebody point me to the part of the specification that addresses this?

This will mostly be defined in the section concerning Method invocation expressions:

The first step in processing a method invocation at compile time is to figure out the name of the method to be invoked and which class or interface to search for definitions of methods of that name.

For the class or interface to search, there are six cases to consider, depending on the form that precedes the left parenthesis of the MethodInvocation:

• [...]
• If the form is Primary . [TypeArguments] Identifier, then let T be the type of the Primary expression. The class or interface to search is T if T is a class or interface type, or the upper bound of T if T is a type variable.

Here, the Primary expression is the class instance creation expression. So the type to search is the anonymous type.

Am I right in thinking that the only way you can invoke hello is immediately like this. What about reflection?

As long as an expression evaluates to the anonymous type T, whether through direct access like you have, or through generics, you have access (regular access rules apply) to the members that T declares. This isn't limited to methods. You can access fields or types, though it's not as useful for types. For example,

Object var = new Object() {
    class Nested {
    }
}.new Nested();

Since there's no way to refer to the nested type without the enclosing type, you can't declare a variable of that nested type. The usefulness declines very quickly. (Presumably, that's also why you can't have a static nested type within this anonymous class.)

Reflection also exposes this method. The generated anonymous class contains this method, so you can retrieve it and invoke it. The process is the same. The fact that the instance is from an anonymous class doesn't matter. The same strategy as presented in How do I invoke a Java method when given the method name as a string? applies.

For example,

Object ref = new Object() {
    public void method() {
        System.out.println("hidden");
    }
};
Class<?> anonymousClass = ref.getClass();
Method method = anonymousClass.getMethod("method");
method.invoke(ref, new Object[0]);

_{Don't ever write code like this.}

Answer 2

As posted, there isn't a way to get the anonymous methods from the Object instance. And, it makes Anonymous classes look pointless. But, you could (and I usually would) use it to implement an interface. Something like,

static interface Hello {
    void hello();
}
public static void main(String[] args) {
    Hello o = new Hello() {
        public void hello() {
            System.out.println("Hello World!");
        }
    };
    o.hello();
}

Or, more commonly, for call-backs with JFC/Swing and ActionListener.

Answer 3

Adding to Sotirios' answer, here's how to invoke the method through reflection:

Object o = new Object() {
    void hello() {
        System.out.println("Hello World!");
    }
};

Method hello = o.getClass().getDeclaredMethod("hello");
hello.invoke(o);

This allows you to call the method more than once, but other than that, makes little sense.

Answer 4

Anonymous class is for the benefit of lazy programmers - naming things is too hard :)

Anonymous class is very much like a local class. If a local class is just for creating one object, which is then used only as a supertype, we can create an anonymous class instead which is more succinct.

Anonymous class is undenotable (to programmer), which is fine because we don't need to reference it again. However, to the compiler, the class is very much named, and there is no reason to treat it differently from explicitly named classes. The static type of the expression is the concrete subclass, and the members of the object is the members of that class. Is this feature (being able to call hello()) pointless? Only if you consider local class pointless (and indeed local class is rarely used). Here's an example where I used that feature (for fun).

Although the type is undenotable, the type can survive as itself through APIs. For example,

    Objects.requireNonNull( new Object(){ void hello(){} } ).hello();

Even though we cannot name the type, it does not need to be named where it can be inferred.

    Collections.singleton( new Object(){ void hello(){} } )
      .forEach( o->{ o.hello(); o.hello(); } );

And we can create puzzlers for people who didn't expect the static type

    Collections.singleton( new Object(){} ).add( new Object() ); // does not compile! why?