Implement two interfaces in an anonymous class

"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)

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()

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.