Como uma classe anônima pode usar “extends” ou “implementements”?

Como uma classe anônima pode estender uma superclasse ou implementar uma interface?

As classes anônimas devem estender ou implementar algo, como qualquer outra classe Java, mesmo que seja apenas java.lang.Object.

Por exemplo:

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

Aqui, ré um objeto de uma classe anônima que implementa Runnable.

Uma classe anônima pode estender outra classe usando a mesma sintaxe:

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

O que você não pode fazer é implementar mais de uma interface. Você precisa de uma classe nomeada para fazer isso. Nem uma classe interna anônima, nem uma classe nomeada, entretanto, podem estender mais de uma classe.

Uma classe anônima geralmente implementa uma interface:

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

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

Se você quer dizer se pode implementar 2 ou mais interfaces, acho que não é possível. Você pode então fazer uma interface privada que combina os dois. Embora eu não possa imaginar facilmente por que você gostaria que uma classe anônima tivesse isso:

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

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

 }

As classes anônimas sempre estendem a superclasse ou implementam interfaces. por exemplo:

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

Além disso, embora a classe anônima não possa implementar várias interfaces, você pode criar uma interface que estenda outra interface e permitir que sua classe anônima a implemente.

Acho que ninguém entendeu a pergunta. Acho que o que esse cara queria era algo assim:

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

porque isso permitiria coisas como várias implementações de interface:

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

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

isso seria realmente muito bom; mas isso não é permitido em Java .

O que você pode fazer é usar classes locais dentro de blocos de método:

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

Uma classe anônima está estendendo ou implementando ao criar seu objeto. Por exemplo:

Interface in = new InterFace()
{

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

}

Aqui, a classe anônima está implementando Interface.

Class cl = new Class(){

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

}

aqui, a Classe anônima está estendendo uma Classe abstrata.