Como uma classe anônima pode estender uma superclasse ou implementar uma interface?
Como uma classe anônima pode estender uma superclasse ou implementar uma interface?
Respostas:
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.
SomeClass
. Ainda é anônimo, devido ao {...}
.
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.