Home / Language / Dalle classi anonime alle lambda e ai riferimenti a metodo
Language Principiante

Dalle classi anonime alle lambda e ai riferimenti a metodo

Sostituisci le classi anonime con un solo metodo con lambda e riferimenti a metodo concisi.

Functional Programming Interfaces
Confronto Codice
✕ Anonymous class 
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent event) {
        save(event);
    }
});
✓ Java 8+ 
button.addActionListener(this::save);
Vedi un problema con questo codice? Faccelo sapere.
Perché vince l'approccio moderno
⚡

Meno boilerplate

Elimina la dichiarazione della classe e la cerimonia dell'override.

👁

Migliore leggibilità

Mantiene l'attenzione sull'operazione eseguita.

🔒

Sempre type-safe

Il compilatore verifica la firma dell'interfaccia funzionale di destinazione.

Approccio Vecchio
Classe anonima
Approccio Moderno
Riferimento a metodo
Dal JDK
8
Difficoltà
Principiante
Supporto JDK
Dalle classi anonime alle lambda e ai riferimenti a metodo
Disponibile

Disponibile dal JDK 8 (marzo 2014).

Come funziona

Le interfacce funzionali possono essere implementate con lambda o riferimenti a metodo. Ciò elimina la verbosità delle classi anonime, preservando la tipizzazione statica e lo stesso contratto di callback.

Documentazione Correlata
Lambda Expressions ↗ Method References ↗
Prova
Vedi sorgente di prova ↗
Pattern correlati
Language Intermedio

Default interface methods

Java 7
// Need abstract class to share behavior
public abstract class AbstractLogger {
    public void log(String msg) {
        System.out.println(
            timestamp() + ": " + msg);
    }
    abstract String timestamp();
}

// Single inheritance only
public class FileLogger
    extends AbstractLogger { ... }
Java 8+
public interface Logger {
    default void log(String msg) {
        IO.println(
            timestamp() + ": " + msg);
    }
    String timestamp();
}

// Multiple interfaces allowed
public class FileLogger
    implements Logger, Closeable { ... }
Passa il mouse per vedere il moderno ➜
JDK 8+ →
Streams Principiante

Predicate.not() for negation

Java 8
List<String> nonEmpty = list.stream()
    .filter(s -> !s.isBlank())
    .collect(Collectors.toList());
Java 11+
List<String> nonEmpty = list.stream()
    .filter(Predicate.not(String::isBlank))
    .collect(Collectors.toList());
Passa il mouse per vedere il moderno ➜
JDK 11+ →
Collections Principiante

Collection bulk operations instead of mutation loops

Iterator mutation loop
for (Iterator<Order> it = orders.iterator(); it.hasNext();) {
    if (it.next().cancelled()) {
        it.remove();
    }
}
Java 8+
orders.removeIf(Order::cancelled);
Passa il mouse per vedere il moderno ➜
JDK 8+ →