Implémentez deux interfaces dans une classe anonyme

J'ai deux interfaces:

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

Je peux créer des instances anonymes de classes impliquant l'une ou l'autre de ces interfaces:

  • Activité de démarrage d'Android depuis le service
  • InApp Billing Security and Remote Method Invocation
  • Dagger 2, Gradle Plugins et Jack - Instructions requises
  • Android - ListView glisse vers la gauche / droite comme contact de Samsung ListView
  • La vidéo ne joue qu'une seule fois dans la vue sur le Web d'Android
  • Comment diviser en néon intrinsèque par un numéro de flotteur
  •  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 (le fictif):

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

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

    La solution de contournement est assez simple:

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

    Ensuite, j'utilise Aggregate où j'aurais utilisé la classe anonyme.

    Je me demandais s'il est même légitime pour une classe anonyme de mettre en œuvre deux interfaces.

    4 Solutions collect form web for “Implémentez deux interfaces dans une classe anonyme”

    "Une classe intérieure anonyme peut étendre une sous-classe ou implémenter une interface. Contrairement aux classes non anonymes (internes ou non), une classe interne anonyme ne peut pas faire les deux. En d'autres termes, elle ne peut pas non seulement étendre une classe et implémenter une interface, ni Il implémente plus d'une interface. "( 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 intérieure 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(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 sortie de cet exemple est:

     foo() bar() baz() 

    Pour enregistrer certaines frappes (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(){} } 

    Notez que la clé est de 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 empêche de faire une déclaration de classe ou 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 faire référence à l'instance d'objet contenant.

    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.