[JAVA] Jusqu'à ce que l'implémentation de l'interface devienne lambda

introduction

Cet article est un article de mise à niveau pour le lambda vulnérable. Nous comparerons la "classe anonyme" utilisable jusqu'à SE7 avec la fonction SE8 "expression lambda".

Comme les expressions lambda sont parfois appelées "fonctions anonymes" ou "fonctions anonymes", elles sont un concept très similaire aux classes anonymes. [^ 1]

[^ 1]: Strictement parlant, "fonction lambda" et "fonction anonyme" sont égales, et l'expression lambda est une notation de la fonction lambda.

En gros, la différence entre une classe anonyme et une expression lambda (fonction anonyme) est "classe ou méthode". Je pense qu'il n'y a presque pas de problème.

supposition

Supposons que vous ayez une interface qui dispose d'une méthode pour déterminer les nombres premiers.

Primes.java

public interface Primes {
    boolean isPrime(Integer param);
}

Classe d'implémentation ordinaire

Normalement, les outils sont comme ça.

PrimesImpl.java

public class PrimesImpl implements Primes {

    @Override
    public boolean isPrime(Integer param) {
        for (int i = 2; i < param; i++) {
            if (param % i == 0) {
                return false;
            }
        }
        return true;
    }
}

Voici comment l'appeler. Nouveau.

Main.java

public class Main {
    public static void main(String[] args) {
        System.out.println(new PrimesImpl().isPrime(7));
    }
}

Implémenté par une classe anonyme

Utilisation d'une classe anonyme:

Main.java

public class Main {
    public static void main(String[] args) {
        Primes primesInner = new Primes() {
            @Override public boolean isPrime(Integer param) {
                for (int i = 2; i < param; i++) {
                    if (param % i == 0) {
                        return false;
                    }
                }
                return true;
            }
        };
        System.out.println(primesInner.isPrime(7));
    }
}

Classe principale UNIQUEMENT car elle est implémentée lors de la création de la classe à l'intérieur.

Implémentation de style Lambda

En utilisant la formule lambda:

Main.java

public class Main {
    public static void main(String[] args) {
        Primes primesLambda = param -> {
            for (int i = 2; i < param; i++) {
                if (param % i == 0) {
                    return false;
                }
            }
            return true;
        };
        System.out.println(primesLambda.isPrime(7));
    }
}

C'est un peu omis de la classe anonyme.

Le nom de la méthode disparaît également. En effet, l'interface Primes répond aux exigences de l'interface de fonction. La méthode est explicite car "interface de fonction = toujours une méthode à implémenter".

À propos, si Primes n'est pas une interface de fonction (s'il n'y a pas une méthode à implémenter), l'expression lambda ne peut pas implémenter plusieurs méthodes et une erreur de compilation se produit.

L'inférence de type fonctionne très bien pour les arguments et les valeurs de retour.

prime

Lambda Lambda comme ça.

Main.java

public class Main {
    public static void main(String[] args) {
        Primes primesFunction = param -> IntStream.range(2, param).noneMatch(i -> (param % i) == 0);
        System.out.println(primesFunction.isPrime(7));
    }
}

N'écrivez pas parce que vous ne pouvez pas le maintenir! Celui qui se met en colère.

c'est tout Faites-moi savoir si vous faites une erreur! !! !!

référence

Résumé de l'extension de grammaire Lambda Kishida no Hatena Java8