[Java] "Einstellung" mit Enum anstelle der bedingten Verzweigung durch die if-Anweisung -Strategy Enum

Die Komplexität der bedingten Verzweigung mit if-Anweisungen

Angenommen, Sie möchten feststellen, ob ein Tag Vergangenheit, Gegenwart oder Zukunft ist, und die Verarbeitung entsprechend aufteilen. Wenn dies mit der if-Anweisung implementiert wird, lautet der Code wie folgt. Tatsächlich sind die Aussichten auf dieser Ebene nicht so schlecht, aber ** wenn Sie sie weiter aufschlüsseln möchten, müssen Sie komplexe Zweige durchlesen **.

Main.java

public static void main(String[] args) {	
    //Variable:Ich möchte das vergangene Zeitsystem beurteilen
    LocalDate past =  LocalDate.of(2019, 10, 11);

    LocalDate today = LocalDate.now();  //Zur Zeit(2019-10-12)
        if(past.isBefore(today)) {
            System.out.println("Past");
        } 
        if(past.isEqual(today)) {
            System.out.println("Today");
        }
        if(past.isAfter(today)) {
	        System.out.println("After");
        }
    //Ausgabe: Past
}

"Bedingungseinstellung, die die Verarbeitung zusammenfasst" statt "bedingte Verzweigung durch if-Anweisung"

Mit Strategy Enum können Sie Bedingungen und die entsprechende Verarbeitung eins zu eins schreiben.

Definieren Sie zunächst die folgenden zwei Funktionsschnittstellen im Bereich Enum (DatePattern).

1. Bedingung: Prädikat
2. Aktion: Ausführbar

Als nächstes wird hier die Factory-Methode als Klassenmethode von () von Enum beschrieben. Die Factory-Methode ermittelt das Zeitsystem anhand des als Argument empfangenen Datums, weist die Verarbeitung entsprechend zu und gibt es als Rückgabewert zurück.

Auf diese Weise können Sie ** Bedingungen und Aktionen als Einstellungen ** schreiben.

DatePattern.java

public enum DatePattern {
    //(Bedingungen,wird bearbeitet)Einstellungen von
    Past(date -> isBeforeToday(date), () -> System.out.println("Past")),
    Today(date -> isSameToday(date), () -> System.out.println("Today")),
    Future(date -> isAfterToday(date), () -> System.out.println("Future"));

    private final Predicate<LocalDate> dateValidator; //Bedingungen
    private final Runnable function; //wird bearbeitet

    //Enum-Konstruktor
    DatePattern(Predicate<LocalDate> dateValidator, Runnable function) {
        this.dateValidator = dateValidator;
        this.function = function;
    }

    /* Factory Method　
     *Eine Bedingung, die das lokale Datum des Arguments im Feld definiert(Predicate)Nach zu urteilen
     *wird bearbeitet(Runnnable)Zurückgeben
    */ 
    public static Runnable of(LocalDate date) {
        Optional<Runnable> pattern = Stream.of(DatePattern.values())
                .filter(e -> e.dateValidator.test(date))
                .map(e -> e.function)
                .findFirst();
        return Optional.ofNullable(pattern.get()).orElseThrow(IllegalArgumentException::new);
    }

    //Beurteilung der Vergangenheit
    private static boolean isBeforeToday(LocalDate date) {
        LocalDate today = LocalDate.now();
        return date.isAfter(today);
    }
    //Urteil der Zukunft
    private static boolean isAfterToday(LocalDate date) {
        LocalDate today = LocalDate.now();
        return date.isBefore(today);
    }
    //Beurteilung des aktuellen Status
    private static boolean isSameToday(LocalDate date) {
        LocalDate today = LocalDate.now();
        return date.equals(today);
    }    
}

Aufgrund der Verwendung von Enum kann die if-Anweisung wie folgt gelöscht werden. Da es keine bedingte Verzweigung gibt, konnten wir den Ausblick verbessern. Das Hinzufügen detaillierterer Beurteilungsbedingungen wirkt sich auch nicht auf den Aufrufer dieses DatePattern aus. Anstatt die bedingte Verzweigung nacheinander durch die if-Anweisung zu wiederholen, denke ich persönlich, dass es besser ist, Bedingungen und Verarbeitung in einem Satz ** in Enum festzulegen, und dies verbessert die Wartbarkeit.

Main.java

public static void main(String[] args) {
    LocalDate past =  LocalDate.of(2019, 10, 11);  //Vergangenheit
    LocalDate today = LocalDate.of(2019, 10, 12);  //Aktuell(2019-10-12)
    LocalDate future = LocalDate.of(2019, 10, 13); //Zukunft

    Runnable past_function = DatePattern.of(past);
    Runnable today_function = DatePattern.of(today);
    Runnable futute_function = DatePattern.of(future);

    past_function.run();
    //Ausgabe: Past
    today_function.run();
    //Ausgabe: Today
    futute_function.run();
    //Ausgabe: Future
}