Implement two interfaces in an anonymous class

Question

I have two interfaces:

interface A {
    void foo();
}

interface B {
    void bar();
}

I am able to create anonymous instances of classes implementing either of these interfaces like so:

new A() {
    void foo() {}
}

or:

new B() {
    void bar() {}
}

I want to create an anonymous class that implements both interfaces. Something like (the fictitious):

new A implements B {
    void foo() {}
    void bar() {}
}

This obviously gives a compile error: "B cannot be resolved to a type".

The workaround is quite simple:

class Aggregate implements A, B {
    void foo() {}
    void bar() {}
}

I then use Aggregate where ever I would have used the anonymous class.

I was wondering if it is even legal for an anonymous class to implement two interfaces.

See [why-an-anonymous-class-cant-implement-multiple-interfaces-directly](http://stackoverflow.com/questions/4774168/why-an-anonymous-class-cant-implement-multiple-interfaces-directly) — nawfal, Jun 30 '14 at 05:35

score 70 · Accepted Answer · edited Nov 17 '11 at 14:39

70

"An anonymous inner class can extend one subclass or implement one interface. Unlike non-anonymous classes (inner or otherwise), an anonymous inner class cannot do both. In other words, it cannot both extend a class and implement an interface, nor can it implement more than one interface. " (http://scjp.wikidot.com/nested-classes)

edited Nov 17 '11 at 14:39

masted

1,211
2
8
14

answered Nov 17 '11 at 08:05

dbf

6,399
2
38
65

J Steven Perry · Answer 2 · 2014-01-24T14:29:21.607

If you are determined to do this, you could declare a third interface, C:

public interface C extends A, B {
}

In this way, you can declare a single anonymous inner class, which is an implementation of C.

A complete example might look like:

public class MyClass {

  public interface A {
    void foo();
  }

  public interface B {
    void bar();
  }

  public interface C extends A, B {
    void baz();
  }

  public void doIt(C c) {
    c.foo();
    c.bar();
    c.baz();
  }

  public static void main(String[] args) {
    MyClass mc = new MyClass();

    mc.doIt(new C() {
      @Override
      public void foo() {
        System.out.println("foo()");
      }

      @Override
      public void bar() {
        System.out.println("bar()");
      }

      @Override
      public void baz() {
        System.out.println("baz()");
      }
    });
  }

}

The output of this example is:

foo()
bar()
baz()

score 7 · Answer 3 · edited Aug 24 '21 at 14:44

7

For save some keystrokes (for example if the interfaces have a lot of methods) you can do this:

abstract class Aggregate implements A, B {
}

new MyObject extends Aggregate {
   void foo() {}
   void bar() {}
}

Notice the key is to declare the Aggregate as abstract.

edited Aug 24 '21 at 14:44

Lii

11,553
8
64
88

answered Feb 09 '12 at 15:09

Addev

31,819
51
183
302

16

Another alternative is to make Aggregate an interface itself: `interface Aggregate extends A, B {}`. – Jesse Merriman Feb 28 '12 at 14:11
8

in what language this compiles? – nachokk Jan 11 '14 at 02:19
5

In Java, for example? – Jakub Kozłowski Mar 13 '16 at 17:12

Lii · Answer 4 · 2019-11-01T15:39:54.013

Note that you can make a named local class that implements the two interfaces:

void method() {
    class Aggregate implements A, B {
        void foo() {}
        void bar() {}
    }

    A a = new Aggregate();
    B b = new Aggregate();
}

This save you from doing a class-level or top-level class declaration.

The result is called a local class. Local classes declared in instance methods are also inner classes, which means that they can reference the containing object instance.

Implement two interfaces in an anonymous class

4 Answers4

Linked