Instantiating anonymous inner classes in Java with additional interface implementation

Question

Let's say I have the following two class/interface definitions:

public abstract class FooClass {
    public abstract void doFoo();
}

and

public interface BarInterface {
    public void doBar();
}

If I want to make an anonymous inner class that extends/implements both, do I need to do this:

public abstract class BothClass extends FooClass implements BarInterface {}

...

new BothClass() {
    public void doFoo() {
        System.out.println("Fooooooooo!!!!");
    }

    public void doBar() {
        System.out.println("Baaaaaaaar!!!!");
    }
}.doBar();

Or is there a short-cut that allows me to not define BothClass? Something like this, maybe:

new (FooClass implements BarInterface)() {
    public void doFoo() {
        System.out.println("Fooooooooo!!!!");
    }

    public void doBar() {
        System.out.println("Baaaaaaaar!!!!");
    }
}.doBar();

(This idea gives me several errors, none of which are helpful here)

Make `FooClass` implement `BarInterface`? I'm not sure what you mean. — Josh M, Feb 02 '14 at 20:21
@JoshM: Let's say I can't/don't want to make `FooClass` implement `BarInterface`. — Markus A., Feb 02 '14 at 20:23
See http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.9 — Andreas Fester, Feb 02 '14 at 20:26
@MarkusA. Anonymous classes are implementations of existing class definitions. If you wanted both, you'd need a class defined with both as in your first example. — Brian Roach, Feb 02 '14 at 20:26

score 9 · Accepted Answer · answered Feb 02 '14 at 20:26

Let's go to the JLS:

An anonymous class declaration is automatically derived from a class instance creation expression by the Java compiler.

where a class instance creation expression is

ClassInstanceCreationExpression:
    new TypeArgumentsopt TypeDeclSpecifier TypeArgumentsOrDiamondopt
                                                            ( ArgumentListopt ) ClassBodyopt
    Primary . new TypeArgumentsopt Identifier TypeArgumentsOrDiamondopt
                                                            ( ArgumentListopt ) ClassBodyopt

TypeArgumentsOrDiamond:
    TypeArguments
    <> 

ArgumentList:
    Expression
    ArgumentList , Expression

So, no, the Java language specification does not allow any shortcuts for making your anonymous class implement more interfaces than the type you're sub-typing.

So, to determine the type of the anonymous class

If the class instance creation expression ends in a class body, then the class being instantiated is an anonymous class. Then:

If T denotes an interface, then an anonymous direct subclass of Object that implements the interface named by T is declared.

[...]

Let T be the type named by the Identifier and any type arguments. An anonymous direct subclass of the class named by T is declared. The body of the subclass is the ClassBody given in the class instance creation expression.

Your alternative is the way to do it.

You can also use local classes.

score 0 · Answer 2 · answered Feb 02 '14 at 21:38

An anonymous class

FooClass f = new FooClass() {
  public void doFoo() {}
};

is just a convenient shorthand for a local class definition with a generated name

class $anon extends FooClass {
  public void doFoo() {}
}
FooClass f = new $anon();

If you want to implement interfaces just write the local class definition explicitly

class LocalFoo extends FooClass implements BarInterface {
  // method declarations here
}
LocalFoo lf = new LocalFoo();

Instantiating anonymous inner classes in Java with additional interface implementation

2 Answers2

Linked