Implémenter deux interfaces dans une classe anonyme

J’ai deux interfaces:

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

Je suis capable de créer des instances anonymes de classes implémentant l’une de ces interfaces comme suit:

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

ou:

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

Je veux créer une classe anonyme qui implémente les deux interfaces. Quelque chose comme (la fictive):

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

Cela donne évidemment une erreur de compilation: “B ne peut pas être résolu en un type”.

La solution de contournement est assez simple:

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

J’utilise ensuite Aggregate où j’aurais utilisé la classe anonyme.

Je me demandais s’il est même légal pour une classe anonyme d’implémenter deux interfaces.

“Une classe interne anonyme peut étendre une sous-classe ou implémenter une interface. Contrairement aux classes non anonymes (internes ou autres), une classe interne anonyme ne peut pas faire les deux. En d’autres termes, elle ne peut ni étendre une classe ni implémenter une interface. il implémente plusieurs interfaces. “( http://scjp.wikidot.com/nested-classes )

Si vous êtes déterminé à le faire, vous pouvez déclarer une troisième interface, C:

 public interface C extends A, B { }

De cette façon, vous pouvez déclarer une seule classe interne anonyme, qui est une implémentation de C.

Un exemple complet pourrait ressembler à:

 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(Ssortingng[] 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 sortie de cet exemple est la suivante:

 foo() bar() baz()

Pour enregistrer certaines séquences de touches (par exemple si les interfaces ont beaucoup de méthodes), vous pouvez utiliser

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

Remarquez que la clé consiste à déclarer l’agrégat comme résumé

Notez que vous pouvez créer une classe locale nommée qui implémente les deux interfaces:

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

Cela vous évite de faire une déclaration de classe ou de classe de niveau supérieur.

Le résultat s’appelle une classe locale . Les classes locales déclarées dans les méthodes d’instance sont également des classes internes, ce qui signifie qu’elles peuvent référencer l’instance d’object contenant.