Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Classi anonime in Java

Una classe anonima permette di definire un’implementazione di un’interfaccia o una sottoclasse e di crearne un’istanza nella stessa espressione.

Versione: Java SE 21

Sintassi

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.

In Java SE 21, new Interface() { ... } dichiara una classe anonima e ne crea un’istanza. Interface indica il nome di un’interfaccia esistente e ... le dichiarazioni nel corpo della classe. L’oggetto è un’istanza della classe che implementa l’interfaccia, non dell’interfaccia stessa. Ogni valutazione crea un nuovo oggetto; ogni occorrenza distinta di questa forma dichiara una classe diversa.

La forma new BaseType(args) { ... } crea un’istanza di una sottoclasse, purché sia possibile estendere BaseType e chiamare un costruttore adatto. Gli argomenti vengono passati al costruttore della superclasse. Non puoi dichiarare esplicitamente un costruttore per la classe anonima, ma il suo corpo può contenere campi, metodi e blocchi di inizializzazione di istanza.

La classe deve implementare tutti i metodi astratti richiesti. Le implementazioni di Action.perform(), Runnable.run() e Executor.execute(Runnable) devono essere public. Usa @Override per far rilevare al compilatore gli errori di firma, ad esempio un sovraccarico involontario invece di una ridefinizione.

In un metodo di istanza della classe anonima, this indica l’oggetto anonimo. Una lambda non introduce un proprio this e richiede un’interfaccia funzionale come tipo di destinazione. Entrambe le forme possono catturare solo variabili locali final o effettivamente finali, come label, a cui non viene riassegnato un valore.

new Executor() { public void execute(Runnable r) ... } rappresenta un’implementazione anonima di Executor, non la creazione di un pool di thread. Qui execute chiama direttamente r.run(), quindi il compito viene eseguito in modo sincrono sul thread chiamante. Altre implementazioni di Executor possono usare un altro thread o un pool.

Esempi

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();
    }
}

Risultato

Open
Task 1
Task 2
Task 3
Task 4
Close

Due classi anonime distinte implementano `Action` e altre quattro implementano `Runnable`. `Open` appare prima delle righe da `Task 1` a `Task 4` e `Close` dopo tutti e quattro i compiti, perché ogni chiamata a `execute` attende che termini la chiamata diretta a `run()`.

Lezioni correlate

  • Java · Lezione 25 · Avanzato · Versione: 2
  • Java · Lezione 8 · Intermedio · Versione: 2
  • Java · Lezione 51 · Intermedio · Versione: 2

Fonti