Accueil / Language / Des classes anonymes aux lambdas et références de méthodes
Language Débutant

Des classes anonymes aux lambdas et références de méthodes

Remplacez les classes anonymes à méthode unique par des lambdas et des références de méthodes concises.

Functional Programming Interfaces
Comparaison de Code
✕ Anonymous class 
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent event) {
        save(event);
    }
});
✓ Java 8+ 
button.addActionListener(this::save);
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
⚡

Moins de code répétitif

Supprime la déclaration de classe et le cérémonial de redéfinition.

👁

Meilleure lisibilité

Maintient l'attention sur l'opération effectuée.

🔒

Toujours sûr au niveau du typage

Le compilateur vérifie la signature de l'interface fonctionnelle cible.

Ancienne Approche
Classe anonyme
Approche Moderne
Référence de méthode
Depuis JDK
8
Difficulté
Débutant
Support JDK
Des classes anonymes aux lambdas et références de méthodes
Disponible

Disponible depuis JDK 8 (mars 2014).

Comment ça fonctionne

Les interfaces fonctionnelles peuvent être implémentées avec des lambdas ou des références de méthodes. Cela élimine le cérémonial des classes anonymes tout en préservant le typage statique et le même contrat de callback.

Documentation Associée
Lambda Expressions ↗ Method References ↗
Preuve
Voir la preuve source ↗
Patterns associés
Language Intermédiaire

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 { ... }
Survolez pour voir le moderne ➜
JDK 8+ →
Streams Débutant

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());
Survolez pour voir le moderne ➜
JDK 11+ →
Collections Débutant

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);
Survolez pour voir le moderne ➜
JDK 8+ →