Come può una classe anonima utilizzare "extends" o "implements"?

Come può una classe anonima estendere una superclasse o implementare un'interfaccia?

Le classi anonime devono estendere o implementare qualcosa, come qualsiasi altra classe Java, anche se è solo java.lang.Object.

Per esempio:

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

Ecco run oggetto di una classe anonima che implementa Runnable.

Una classe anonima può estendere un'altra classe utilizzando la stessa sintassi:

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

Quello che non puoi fare è implementare più di un'interfaccia. Hai bisogno di una classe con nome per farlo. Né una classe interna anonima, né una classe denominata, tuttavia, possono estendere più di una classe.

Una classe anonima di solito implementa un'interfaccia:

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

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

Se intendi se puoi implementare 2 o più interfacce, penso che non sia possibile. È quindi possibile creare un'interfaccia privata che combini i due. Anche se non riesco a immaginare facilmente perché vorresti che una classe anonima avesse questo:

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

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

 }

Le classi anonime estendono sempre la superclasse o implementano le interfacce. per esempio:

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

Inoltre, sebbene la classe anonima non possa implementare più interfacce, è possibile creare un'interfaccia che estende un'altra interfaccia e consentire alla classe anonima di implementarla.

Credo che nessuno abbia capito la domanda. Immagino che quello che voleva questo ragazzo fosse qualcosa del genere:

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

perché ciò consentirebbe cose come più implementazioni dell'interfaccia:

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

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

questo sarebbe davvero bello davvero; ma non è consentito in Java .

Quello che puoi fare è usare le classi locali all'interno dei blocchi del metodo:

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

Una classe anonima si sta estendendo o implementando durante la creazione del suo oggetto Ad esempio:

Interface in = new InterFace()
{

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

}

Qui la classe anonima sta implementando Interface.

Class cl = new Class(){

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

}

qui la classe anonima sta estendendo una classe astratta.