J'écrirai un extrait de ce que j'ai trouvé intéressant en lisant Effective Java 3rd Edition

J'écrirai un extrait de ce que j'ai trouvé intéressant en lisant Effective Java 3rd Edition. Le livre lui-même est toujours en cours de lecture, il pourra donc être ajouté ultérieurement. Dans ce cas, il est indécis de mettre à jour cet article ou d'écrire un nouvel article.

Item 42 : Prefer lambdas to anonymous classes La méthode d'écriture consistant à avoir une implémentation de méthode unique pour chaque instance d'énumération, qui a été introduite dans «Élément 34: imiter une énumération extensible avec une interface» dans Effective Java 2nd edition, a été remplacée par une utilisant lambda. Cliquez ici pour savoir comment écrire dans la deuxième édition.

EnumFunctionV2.java

public enum EnumFunctionV2 {
    PLUS("+") {
        @Override
        public double apply(double x, double y){ return x + y; }
    },
    MINUS("-") {
        @Override
        public double apply(double x, double y){ return x - y; }
    },
    TIMES("*") {
        @Override
        public double apply(double x, double y){ return x * y; }
    },
    DEVIDE("/") {
        @Override
        public double apply(double x, double y){ return x / y; }
    };

    private final String symbol;

    //constructeur
    EnumFunctionV2(String symbol) {
        this.symbol = symbol;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public abstract double apply(double x, double y);
}

C'est un moyen de définir une méthode abstraite et de remplacer chaque instance d'énumération. C'est pratique, mais c'est un peu difficile à voir ... Cliquez ici pour savoir comment écrire dans la 3e édition.

EnumFunctionV3.java

import java.util.function.DoubleBinaryOperator;

public enum EnumFunctionV3 {
    PLUS("+", (x, y) -> x + y),
    MINUS("-", (x, y) -> x - y),
    TIMES("*", (x, y) -> x * y),
    DEVIDE("/", (x, y) -> x / y);

    private final String symbol;
    private final DoubleBinaryOperator op;

    //constructeur
    EnumFunctionV3(String symbol, DoubleBinaryOperator op) {
        this.symbol = symbol;
        this.op = op;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public double apply(double x, double y) {
        return op.applyAsDouble(x, y);
    }
}

l'abstrait a disparu. Ayez DoubleBinaryOperator dans le deuxième argument du constructeur, et utilisez lambda pour créer la méthode J'écris directement l'implémentation. Le contenu est le même que dans la deuxième édition, mais je pense que c'est plus propre et plus facile à voir. Les deux sont appelés de la même manière.

EnumFunctionTest.java

public class EnumFunctionTest {
    public static void main(String... args) {
        //Appelez la 2e édition
        System.out.println("【v2】");
        //Appeler des méthodes sur toutes les instances pendant la boucle
        for (EnumFunctionV2 func2: EnumFunctionV2.values()) {
            System.out.print(func2 + ":");
            System.out.println(func2.apply(1, 2));
        }
        //Si vous souhaitez appeler la méthode de chaque instance individuellement, cela ressemble à ceci
        System.out.println(EnumFunctionV2.PLUS.apply(1, 2));

        //Appelez la 3e édition
        System.out.println("【v3】");
        //Appeler des méthodes sur toutes les instances pendant la boucle
        for (EnumFunctionV3 func3: EnumFunctionV3.values()) {
            System.out.print(func3 + ":");
            System.out.println(func3.apply(1, 2));
        }
        //Si vous souhaitez appeler la méthode de chaque instance individuellement, cela ressemble à ceci
        System.out.println(EnumFunctionV3.PLUS.apply(1, 2));
    }
}

Résultat d'exécution 【v2】 +:3.0 -:-1.0 *:2.0 /:0.5 3.0 【v3】 +:3.0 -:-1.0 *:2.0 /:0.5 3.0

c'est tout. J'ai été surpris de savoir comment utiliser lambda, alors je l'ai noté.

en conclusion

Comme je l'ai écrit au début, je lis actuellement Effective Java 3rd Edition (2 mai 2019). De plus, comme je ne l'ai pas lu depuis le début, j'ai écrit à propos de l'élément 42 cette fois (2 mai 2019), mais il est possible que j'ajoute à propos de l'élément 1 après cela. La troisième édition contient les articles 1 à 90. Effective Java est un livre qui a longtemps été considéré comme un chef-d'œuvre de Java, je pense donc que les utilisateurs de Java devraient le lire une fois. La troisième édition est sortie le 6 janvier 2018 pour la version anglaise et le 30 octobre 2018 pour la version japonaise. Je pense qu'il peut être utilisé pendant un certain temps, donc si vous êtes intéressé, veuillez le lire.

Les références

Effective Java (3rd Edition)