Comment une classe anonyme peut-elle utiliser «extend» ou «implements»?

Comment une classe anonyme peut-elle étendre une superclasse ou implémenter une interface?

Les classes anonymes doivent étendre ou implémenter quelque chose, comme toute autre classe Java, même si c'est juste java.lang.Object.

Par exemple:

Runnable r = new Runnable() {
   public void run() { ... }
};

Voici run objet d'une classe anonyme qui implémente Runnable.

Une classe anonyme peut étendre une autre classe en utilisant la même syntaxe:

SomeClass x = new SomeClass() {
   ...
};

Ce que vous ne pouvez pas faire, c'est implémenter plus d'une interface. Vous avez besoin d'une classe nommée pour cela. Cependant, ni une classe interne anonyme, ni une classe nommée ne peuvent étendre plus d'une classe.

Une classe anonyme implémente généralement une interface:

new Runnable() { // implements Runnable!
   public void run() {}
}

JFrame.addWindowListener( new WindowAdapter() { // extends  class
} );

Si vous voulez dire si vous pouvez implémenter 2 interfaces ou plus, je pense que ce n'est pas possible. Vous pouvez ensuite créer une interface privée qui combine les deux. Bien que je ne puisse pas facilement imaginer pourquoi vous voudriez qu'une classe anonyme ait cela:

 public class MyClass {
   private interface MyInterface extends Runnable, WindowListener { 
   }

   Runnable r = new MyInterface() {
    // your anonymous class which implements 2 interaces
   }

 }

Les classes anonymes étendent toujours la superclasse ou implémentent des interfaces. par exemple:

button.addActionListener(new ActionListener(){ // ActionListener is an interface
    public void actionPerformed(ActionEvent e){
    }
});

De plus, bien que la classe anonyme ne puisse pas implémenter plusieurs interfaces, vous pouvez créer une interface qui étend une autre interface et laisser votre classe anonyme l'implémenter.

Je suppose que personne n'a compris la question. Je suppose que ce que ce gars voulait, c'était quelque chose comme ça:

return new (class implements MyInterface {
    @Override
    public void myInterfaceMethod() { /*do something*/ }
});

car cela permettrait des choses comme les implémentations d'interfaces multiples:

return new (class implements MyInterface, AnotherInterface {
    @Override
    public void myInterfaceMethod() { /*do something*/ }

    @Override
    public void anotherInterfaceMethod() { /*do something*/ }
});

ce serait vraiment bien; mais ce n'est pas autorisé en Java .

Ce que vous pouvez faire est d'utiliser des classes locales dans des blocs de méthodes:

public AnotherInterface createAnotherInterface() {
    class LocalClass implements MyInterface, AnotherInterface {
        @Override
        public void myInterfaceMethod() { /*do something*/ }

        @Override
        public void anotherInterfaceMethod() { /*do something*/ }
    }
    return new LocalClass();
}

// The interface
interface Blah {
    void something();
}

...

// Something that expects an object implementing that interface
void chewOnIt(Blah b) {
    b.something();
}

...

// Let's provide an object of an anonymous class
chewOnIt(
    new Blah() {
        @Override
        void something() { System.out.println("Anonymous something!"); }
    }
);

Une classe anonyme étend ou implémente lors de la création de son objet Par exemple:

Interface in = new InterFace()
{

..............

}

Ici, une classe anonyme implémente Interface.

Class cl = new Class(){

.................

}

ici la classe anonyme étend une classe abstraite.