CKTIS / Java
Classes anónimas em Java
Uma classe anónima permite definir a implementação de uma interface ou uma subclasse e criar uma instância na mesma expressão.
Versão: Java SE 21
Sintaxe
Anonymous implementation: new InterfaceType() { /* member declarations */ }
Anonymous subclass: new BaseType(constructorArguments) { /* member declarations */ }
In a variable declaration, end the declaration with a semicolon after the closing brace.Em Java SE 21, new Interface() { ... } declara uma classe anónima e cria uma instância dessa classe. Interface representa o nome de uma interface existente e ... representa as declarações no corpo da classe. O objeto pertence à classe que implementa a interface, não à própria interface. Cada avaliação cria um novo objeto; cada ocorrência distinta desta forma declara uma classe diferente.
A forma new BaseType(args) { ... } cria uma instância de uma subclasse, desde que seja possível estender BaseType e invocar um construtor adequado. Os argumentos são passados ao construtor da superclasse. Não é possível declarar explicitamente um construtor para a classe anónima, mas o seu corpo pode conter campos, métodos e blocos de inicialização de instância.
A classe tem de implementar todos os métodos abstratos exigidos. As implementações de Action.perform(), Runnable.run() e Executor.execute(Runnable) têm de ser public. Usa @Override para que o compilador detete erros de assinatura, como sobrecarregar um método por engano em vez de o redefinir.
Num método de instância da classe anónima, this refere-se ao objeto anónimo. Uma expressão lambda não introduz um this próprio e precisa de uma interface funcional como tipo de destino. Ambas as formas só podem capturar variáveis locais final ou efetivamente finais, como label, à qual não se volta a atribuir um valor.
new Executor() { public void execute(Runnable r) ... } é um esquema de uma implementação anónima de Executor, não uma forma de criar um conjunto de threads. Aqui, execute chama diretamente r.run(), pelo que a tarefa corre de forma síncrona na thread que fez a chamada. Outras implementações de Executor podem usar outra thread ou um conjunto de threads.
Exemplos
import java.util.concurrent.Executor;
public class AnonymousClassDemo {
interface Action {
void perform();
}
public static void main(String[] args) {
Action open = new Action() {
@Override
public void perform() { System.out.println("Open"); }
};
Action close = new Action() {
@Override
public void perform() { System.out.println("Close"); }
};
Executor direct = new Executor() {
@Override
public void execute(Runnable r) {
r.run();
}
};
String label = "Task ";
Runnable[] tasks = {
new Runnable() {
@Override
public void run() { System.out.println(label + "1"); }
},
new Runnable() {
@Override
public void run() { System.out.println(label + "2"); }
},
new Runnable() {
@Override
public void run() { System.out.println(label + "3"); }
},
new Runnable() {
@Override
public void run() { System.out.println(label + "4"); }
}
};
open.perform();
for (Runnable task : tasks) {
direct.execute(task);
}
close.perform();
}
}Resultado
Open Task 1 Task 2 Task 3 Task 4 Close
Duas classes anónimas distintas implementam `Action` e outras quatro implementam `Runnable`. `Open` aparece antes das linhas `Task 1` a `Task 4`, e `Close` depois das quatro tarefas, porque cada chamada a `execute` aguarda que a chamada direta a `run()` termine.
Lições relacionadas
- Java · Lição 25 · Avançado · Versão: 2
- Java · Lição 8 · Intermédio · Versão: 2
- Java · Lição 51 · Intermédio · Versão: 2
Fontes
- Java Language Specification, Java SE 21 — §15.9 Class Instance Creation Expressions
- Java Language Specification, Java SE 21 — §15.9.5 Anonymous Class Declarations
- Java Language Specification, Java SE 21 — §8.1.3 Inner Classes and Enclosing Instances
- Java Language Specification, Java SE 21 — §8.4.8.3 Requirements in Overriding and Hiding
- Java Language Specification, Java SE 21 — §15.27 Lambda Expressions
- Executor (Java SE 21 & JDK 21)
- Runnable (Java SE 21 & JDK 21)