[JAVA] Branchement conditionnel avec une interface fluide

supposition

• java8 ou version ultérieure

Branchement conditionnel en question

Ce type de traitement que vous voyez souvent.

//Si la chaîne n'est pas vide et a des alphabets inférieurs
//Et
//Lorsque la catégorie de traitement est enregistrée ou modifiée
if ((StringUtils.isNotEmpty(str) && StringUtils.isAlpha(str)
        && StringUtils.isAllLowerCase(str))
        && (processDivision.isRegister() || processDivision.isChange())) {
    //Quelque chose de traitement
}

En un coup d'œil, il est difficile de dire quelles sont les conditions, et il est facile de faire des erreurs comme où mettre les parenthèses. C'est peut-être encore mieux à ce niveau, mais je désespérerai si les conditions augmentent ...

Résolu avec une interface fluide

Créez la classe suivante.

Assume.java

public final class Assume<T> {

    private T obj;

    public static <T> Assume<T> that(T obj) {

        Assume<T> assume = new Assume<>();
        assume.obj = obj;

        return assume;
    }

    public AnyMatch<T> satisfiesAnyOf(Predicate<T> method) {

        AnyMatch<T> anyOf = new AnyMatch<>(obj, method);

        return anyOf;

    }

    public AllMatch<T> satisfiesAllOf(Predicate<T> method) {

        AllMatch<T> allOf = new AllMatch<>(obj, method);

        return allOf;

    }

}

AnyMatch.java

public final class AnyMatch<T> {

    private T obj;

    private boolean match;

    protected AnyMatch(T obj, Predicate<T> checkMethod) {
        this.match = checkMethod.test(obj);
        this.obj = obj;
    }

    public AnyMatch<T> or(Predicate<T> checkMethod) {

        if (match) {
            return this;
        }

        this.match = checkMethod.test(obj);
        return this;
    }

    public boolean check() {

        return match;
    }
}

AllMatch.java

public class AllMatch<T> {

    private T obj;

    private boolean match;

    protected AllMatch(T obj, Predicate<T> checkMethod) {
        this.match = checkMethod.test(obj);
        this.obj = obj;
    }

    public AllMatch<T> and(Predicate<T> checkMethod) {

        if (!match) {
            return this;
        }

        this.match = checkMethod.test(obj);
        return this;
    }

    public boolean check() {
        return match;
    }

}

En utilisant ces trois, le processus au début peut être écrit comme suit.

//Si la chaîne n'est pas vide et a des alphabets inférieurs
//Et
//Lorsque la catégorie de traitement est enregistrée ou modifiée
if (Assume.that(str)
        .satisfiesAllOf(StringUtils::isNotEmpty)
        .and(StringUtils::isAlpha)
        .and(StringUtils::isAllLowerCase).check()
        && Assume.that(processDivision)
                 .satisfiesAnyOf(ProcessDivision::isRegister)
                 .or(ProcessDivision::isChange).check()) {
    //Quelque chose de traitement
}

La description est plus longue, mais il est plus facile de comprendre ce que vous faites. Devrait être.

Poursuite de l'amélioration

Écrire une troisième instruction If qui n'est ni une instruction if ni un opérateur ternaire Amélioration supplémentaire en référence à l'article dans.

AnyMatch.java

public final class AnyMatch<T> {
    
    ...

    public <A> Else<A> then(Supplier<A> a1) {
        return (Supplier<A> a2) -> match ? a1.get() : a2.get();
    }
}

Ajouter,

Else.java

public interface Else<A> {
    A orElse(Supplier<A> a2);
}

Si vous préparez

String hoge = Assume.that(str)
        .satisfiesAllOf(StringUtils::isNotEmpty)
        .and(StringUtils::isAlpha)
        .and(StringUtils::isAllLowerCase).then(() -> "aaa").orElse(() -> "bbb");

Vous pouvez également le faire.

référence

• Ecrire une troisième instruction If qui n'est ni une instruction if ni un opérateur ternaire