¿Cómo puede una clase anónima usar "extiende" o "implementa"?

¿Cómo puede una clase anónima extender una superclase o implementar una interfaz?

Las clases anónimas deben extender o implementar algo, como cualquier otra clase de Java, incluso si es solo java.lang.Object.

Por ejemplo:

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

Aquí, rhay un objeto de una clase anónima que implementa Runnable.

Una clase anónima puede extender otra clase usando la misma sintaxis:

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

Lo que no puede hacer es implementar más de una interfaz. Necesita una clase con nombre para hacer eso. Sin embargo, ni una clase interna anónima ni una clase con nombre pueden extender más de una clase.

Una clase anónima generalmente implementa una interfaz:

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

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

Si te refieres a si puedes implementar 2 o más interfaces, creo que eso no es posible. A continuación, puede crear una interfaz privada que combine los dos. Aunque no puedo imaginar fácilmente por qué querrías que una clase anónima tuviera eso:

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

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

 }

Las clases anónimas siempre extienden la superclase o implementan interfaces. por ejemplo:

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

Además, aunque la clase anónima no puede implementar múltiples interfaces, puede crear una interfaz que amplíe otra interfaz y dejar que su clase anónima la implemente.

Supongo que nadie entendió la pregunta. Supongo que lo que quería este tipo era algo como esto:

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

porque esto permitiría cosas como múltiples implementaciones de interfaz:

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

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

esto sería realmente bueno; pero eso no está permitido en Java .

Lo que puede hacer es usar clases locales dentro de bloques de métodos:

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 clase anónima se está ampliando o implementando mientras crea su objeto. Por ejemplo:

Interface in = new InterFace()
{

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

}

Aquí la clase anónima está implementando Interface.

Class cl = new Class(){

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

}

aquí la clase anónima está ampliando una clase abstracta.