Bagaimana kelas anonim menggunakan "extends" atau "implements"?

Bagaimana kelas anonim memperluas superclass atau mengimplementasikan antarmuka?

Kelas anonim harus memperluas atau mengimplementasikan sesuatu, seperti kelas Java lainnya, meskipun itu hanya java.lang.Object.

Sebagai contoh:

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

Di sini, radalah objek dari kelas anonim yang diimplementasikan Runnable.

Kelas anonim dapat memperluas kelas lain menggunakan sintaks yang sama:

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

Apa yang tidak dapat Anda lakukan adalah menerapkan lebih dari satu antarmuka. Anda membutuhkan kelas bernama untuk melakukan itu. Baik kelas dalam anonim, maupun kelas bernama, bagaimanapun, dapat memperluas lebih dari satu kelas.

Kelas anonim biasanya mengimplementasikan antarmuka:

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

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

Jika yang Anda maksud adalah apakah Anda dapat menerapkan 2 atau lebih antarmuka, daripada yang saya pikir itu tidak mungkin. Anda kemudian dapat membuat antarmuka pribadi yang menggabungkan keduanya. Meskipun saya tidak dapat dengan mudah membayangkan mengapa Anda menginginkan kelas anonim memiliki itu:

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

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

 }

Kelas anonim selalu memperluas superclass atau mengimplementasikan antarmuka. sebagai contoh:

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

Selain itu, meskipun kelas anonim tidak dapat mengimplementasikan banyak antarmuka, Anda dapat membuat antarmuka yang memperluas antarmuka lain dan membiarkan kelas anonim Anda menerapkannya.

Saya kira tidak ada yang mengerti pertanyaan itu. Saya rasa yang diinginkan orang ini adalah seperti ini:

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

karena ini akan memungkinkan hal-hal seperti implementasi beberapa antarmuka:

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

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

ini akan sangat menyenangkan; tapi itu tidak diperbolehkan di Jawa .

Yang dapat Anda lakukan adalah menggunakan kelas lokal di dalam blok metode:

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

Kelas anonim memperluas atau mengimplementasikan saat membuat objeknya. Misalnya:

Interface in = new InterFace()
{

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

}

Di sini kelas anonim mengimplementasikan Antarmuka.

Class cl = new Class(){

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

}

di sini Kelas anonim memperluas Kelas abstrak.