Fehler in Java ausdrücken

Einführung

Es ist überraschend schwierig, Fehler im Umgang mit Java auszudrücken. Optional ist in Java 8 erschienen und es ist viel einfacher zu handhaben, aber es wird immer noch mit anderen Sprachen verglichen. Ich habe mir die ganzen Tage Sorgen gemacht, deshalb hier eine Zusammenfassung, wie ich mit meinen eigenen Fehlern umgehe.

Umgebung

Java 8 oder höher (spätere Version ist besser)

Mit Null umgehen

Apropos königliche Straße, es ist ein Muster, das Null zurückgibt, wenn es nicht erhalten werden kann. Bis Optional in Java8 erschien, war es natürlich, Null zu überprüfen, aber es scheint, dass sich Optional geändert hat. Ich versuche, es in Null nicht zu sehr als Rückgabewert in der Anwendung zu behandeln.

Ich kann nicht anders, als viel alte Verarbeitung zu belassen, also behandle ich sie mit Null bis zu dem Tag, an dem sie überarbeitet werden kann.

Main.java

public class Main {
    public static void main(String[] args) {
        String first = getFirstArg(args);
        if(first == null) {
            System.out.println("Es gibt kein Argument");
            return;
        }
        
        System.out.print("Das erste Argument ist[ " + first + "]ist");
    }
    
    private static String getFirstArg(String[] args) {
        if(args == null || args.length == 0) {
            return null;
        }
        return args[0];
    }
}

Mit Boolean umgehen

Dies ist auch eine königliche Straße. Ich denke, es drückt oft "ist" hat "kann" aus. In diesem Fall wird häufig der primitive Typ "Boolean" anstelle des Objekttyps "Boolean" verwendet. Da es anstelle von Vorhandensein oder Nichtvorhandensein von Daten durch "wahr" falsch ausgedrückt werden kann, wird diese Prüfung verwendet, da sie in Zukunft bestehen bleibt.

Main.java

public class Main {
    public static void main(String[] args) {
        if(hasFirstArg(args)) {
            System.out.println("Es gibt ein Argument");
        } else {
            System.out.println("Es gibt kein Argument");
        }
    }
    
    private static boolean hasFirstArg(String[] args) {
        return args != null && 0 < args.length;
    }
}

Express mit Ausnahme

Es ist auch möglich, einen Fehler auszudrücken, indem eine Ausnahme ausgelöst wird. Wenn der Zweck der Methode nicht erreicht werden kann, wenn der Prozess als externe Bibliothek erstellt wird, wird er verwendet, ansonsten wird er nicht häufig verwendet. Wenn es kein Problem zu sein scheint, werfe ich es oft von unten und werfe es so wie es ist, aber ich achte darauf, es am Ende nicht wegzuwerfen.

Ich denke, es ist ein schwieriger Ausdruck, weil er weggeworfen wird oder so, aber ich möchte ihn gut verwenden. Die Schwierigkeit ist, dass die Fehlerkontrolle schwierig ist, aber ...

Main.java

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Das erste Argument ist[" + getFirstArg(args) + "]ist");
        } catch(NullPointerException e) {
            System.out.println("Argument ist null");
        } catch(IllegalArgumentException e) {
            System.out.println("Illegales Argument");
        }
    }

    private static String getFirstArg(String[] args) {
        if(args == null) {
            throw new NullPointerException();
        }
        if(args.length == 0) {
            throw new IllegalArgumentException();
        }
        return args[0];
    }
}

Wenn Sie dies in einer Bewertung veröffentlichen, können Sie sich nicht beschweren, selbst wenn Sie gestochen werden.

Als optional ausgedrückt

Ich denke, dass der optionale Ausdruck, der früher herauskam, Standard ist, wenn es sich um die aktuelle Grundfunktion von Java handelt. Die Funktion ist, dass es leicht zu verstehen ist, dass dieser Rückgabewert bei Verwendung von Optional möglicherweise nicht vorhanden ist. Mit den bisherigen Ausdrücken ist es nicht möglich, auf einen Blick zu erkennen, ob sie erfolgreich oder nicht erfolgreich sind, und es ist nicht bekannt, bis Null aktiviert ist. Wenn Sie vergessen, Null zu überprüfen und darauf zuzugreifen, werden alle "NullPointerException" lieben. Wir freuen uns sehr, mit dem Aufkommen von Optinal aus dieser Situation herauszukommen.

Einzelheiten finden Sie im Artikel über Qiita. https://qiita.com/tasogarei/items/18488e450f080a7f87f3 https://qiita.com/tasogarei/items/f289d125660af6fe5ba6

Main.java

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> arg = getFirstArg(args);
        arg.ifPresent(first ->System.out.print("Das erste Argument ist[ " + first + "]ist"));
    }
    
    private static Optional<String> getFirstArg(String[] args) {
        if(args == null || args.length == 0) {
            return Optional.empty();
        }
        return Optional.ofNullable(args[0]);
    }
}

Da jedoch "ifPresentOrElse" in Java8 nicht vorhanden ist, kann die Verarbeitung möglicherweise nicht ausgedrückt werden, wenn sie erfolgreich ist und wenn sie fehlschlägt (erstmals in Java9 angezeigt). Im Fall von Java8 müssen Sie das Traurige tun, indem Sie die Existenz mit "isPresent" überprüfen und den Prozess mit "if" schreiben.

arg.ifPresentOrElse(first -> System.out.println("Das erste Argument ist[ " + first + "]ist"),
            () -> System.out.println("Keine Argumente"));

Alternativ können Sie map und orElse (Get) verwenden, um zur Verarbeitung in einen bestimmten Typ zu konvertieren. Es ist schwieriger als Sie denken, dies gut zu schreiben, da eine Übertreibung die Lesbarkeit in Optional Nested Hell beeinträchtigen kann.

Main.java

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> arg = getFirstArg(args);
        System.out.println(arg.map(first -> "Das erste Argument ist[" + first + "]ist").orElse("Keine Argumente"));
    }
    
    private static Optional<String> getFirstArg(String[] args) {
        if(args == null || args.length == 0) {
            return Optional.empty();
        }
        return Optional.ofNullable(args[0]);
    }
}

Mit entweder ausdrücken

Mit dem Aufkommen von Optional ist es möglich geworden, sich von Null zu lösen, aber Optional kann feststellen, ob es erfolgreich oder nicht erfolgreich ist, kann aber nicht erklären, warum. Hier kommt entweder beides ins Spiel.

Beides wird in einigen Fällen von der Sprache unterstützt, aber leider nicht von Java. Obwohl es sich um eine Ebene handelt, die selbst implementiert werden kann, ist sie in einer Bibliothek namens vavr implementiert (es gibt viele andere Funktionen, aber dieses Mal werde ich sie für den Zweck von Entweder verwenden).

【offiziell】 http://www.vavr.io/

Fügen wir also eine Abhängigkeit zu pom.xml hinzu und implementieren sie.

pom.xml

    <dependency>
        <groupId>io.vavr</groupId>
        <artifactId>vavr</artifactId>
        <version>0.9.2</version>
    </dependency>

Main.java

import java.util.Optional;

import io.vavr.control.Either;

public class Main {
    public static void main(String[] args) {
        Either<Integer,String> arg = getFirstArg(args);
        if(arg.isRight()) {
            System.out.println("Das erste Argument ist[" + arg.get() + "]ist");
        } else {
            System.out.println("Argument Fehler. Art" + arg.getLeft());
        }
    }

    private static Either<Integer,String> getFirstArg(String[] args) {
        if(args == null) {
            return Either.left(1);
        }
        if(args.length == 0) {
            return Either.left(2);
        }
        return Either.right(args[0]);
    }
}

Beides ist erfolgreich, wenn der Wert in Rechts vorhanden ist, und schlägt fehl, wenn der Wert in Links vorhanden ist. Da es nur in einem von ihnen einen Wert haben darf, ist es kein Problem, wenn Sie bestätigen können, welcher den Wert hat.

In Java gibt es jedoch kein Scala-Match. Daher macht es mich traurig auszudrücken, mit welchem Wert if einen Wert hat. Vielleicht kannst du etwas Ähnliches machen, aber ich weiß es noch nicht.

Jetzt ist es jedoch möglich, die Art des Fehlers auszudrücken, wodurch es einfach ist, den Prozess zu ändern, den Wert abzurufen, während der Fehler ausgedrückt wird, und so weiter.

Schließlich

Vor kurzem habe ich begonnen, Entweder hauptsächlich mit Optional zu verwenden, und ich implementiere es, während ich mich um verschiedene Dinge kümmere. Es ist schwierig, einen Fehler auszudrücken, aber bitte lassen Sie mich wissen, ob es eine gute Implementierungsmethode gibt.