Wie kann eine anonyme Klasse "Erweitern" oder "Implementieren" verwenden?

Wie kann eine anonyme Klasse eine Oberklasse erweitern oder eine Schnittstelle implementieren?

Anonyme Klassen müssen wie jede andere Java-Klasse etwas erweitern oder implementieren, auch wenn es nur so ist java.lang.Object.

Beispielsweise:

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

Hier rist ein Objekt einer anonymen Klasse, die implementiert Runnable.

Eine anonyme Klasse kann eine andere Klasse mit derselben Syntax erweitern:

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

Was Sie nicht tun können, ist mehr als eine Schnittstelle zu implementieren. Dazu benötigen Sie eine benannte Klasse. Weder eine anonyme innere Klasse noch eine benannte Klasse können jedoch mehr als eine Klasse erweitern.

Eine anonyme Klasse implementiert normalerweise eine Schnittstelle:

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

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

Wenn Sie meinen, ob Sie 2 oder mehr Schnittstellen implementieren können, dann denke ich, dass das nicht möglich ist. Sie können dann eine private Schnittstelle erstellen, die beide kombiniert. Obwohl ich mir nicht leicht vorstellen kann, warum Sie möchten, dass eine anonyme Klasse das hat:

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

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

 }

Anonyme Klassen erweitern immer Superklassen oder implementieren Schnittstellen. beispielsweise:

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

Obwohl anonyme Klassen nicht mehrere Schnittstellen implementieren können, können Sie eine Schnittstelle erstellen, die andere Schnittstellen erweitert, und Ihre anonyme Klasse diese implementieren lassen.

Ich denke, niemand hat die Frage verstanden. Ich denke, was dieser Kerl wollte, war so etwas:

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

weil dies Dinge wie mehrere Schnittstellenimplementierungen ermöglichen würde:

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

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

das wäre wirklich schön; aber das ist in Java nicht erlaubt .

Was Sie können tun ist verwenden lokale Klassen innerhalb Methode blockiert:

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

Eine anonyme Klasse wird beim Erstellen ihres Objekts erweitert oder implementiert. Beispiel:

Interface in = new InterFace()
{

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

}

Hier implementiert eine anonyme Klasse Interface.

Class cl = new Class(){

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

}

hier erweitert anonyme Klasse eine abstrakte Klasse.