Implementar dos interfaces en una clase anónima

Tengo dos interfaces:

interface A { void foo(); } interface B { void bar(); }

Puedo crear instancias anónimas de clases que implementan cualquiera de estas interfaces como así:

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

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

Quiero crear una clase anónima que implemente ambas interfaces. Algo así como (el ficticio):

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

Esto obviamente da un error de compilación: "B no se puede resolver a un tipo".

La solución es bastante simple:

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

A continuación, utilizar Aggregate donde nunca hubiera utilizado la clase anónima.

Me preguntaba si incluso es legal para una clase anónima implementar dos interfaces.

Una clase interna anónima puede extender una subclase o implementar una interfaz A diferencia de las clases no anónimas (internas o de otro tipo), una clase interna anónima no puede hacer ambas cosas, es decir, no puede extender una clase e implementar una interfaz ni tampoco Implementa más de una interfaz. "( http://scjp.wikidot.com/especial-classes )

Si está decidido a hacer esto, podría declarar una tercera interfaz, C:

 public interface C extends A, B { }

De esta manera, puede declarar una única clase interna anónima, que es una implementación de C.

Un ejemplo completo podría ser:

 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()"); } }); } }

La salida de este ejemplo es:

 foo() bar() baz()

Para guardar algunas pulsaciones de tecla (por ejemplo, si las interfaces tienen muchos métodos) puede utilizar

 abstract class Aggregate implements A,B{ } new MyObject extends Aggregate{ void foo(){} void bar(){} }

Observe que la clave es declarar el Agregado como abstracto

Tenga en cuenta que puede crear una clase local con nombre que implemente las dos interfaces:

 void method() { class Aggregate implements A, B { void foo() {} void bar() {} } A a = new Aggregate(); B b = new Aggregate(); }

Esto evita que realice una declaración de clase de nivel de clase o de nivel superior.

El resultado se llama una clase local . Las clases locales declaradas en los métodos de instancia también son clases internas, lo que significa que pueden hacer referencia a la instancia del objeto que contiene.