JavaFX Custom Exceptions

[friednoodles]

Hi,

ich habe eine Methode in der ich vier Verzweigungen habe, zwei davon sind für gewollte Umwandlungen und die anderen zwei sind für den Fall, das illegale Argumente eingegeben werden.

    public static String patternQuery(String toCheck) throws PatternQueryException {

        final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parsInToDate = new Date();

        if (toCheck.isEmpty()) {
            throw new PatternQueryException("You can´t convert from nothing!");

        } else if (Pattern.matches(DATEPATTERN, toCheck)) {
            long epochMillis;
            epochMillis = dateToEpochTime(sdf, toCheck, parsInToDate);
            return epochMillis + "";

        } else if (Pattern.matches(NUMBERPATTERN, toCheck)) {
            Calendar calendar = epochTimeToDate(Long.parseLong(toCheck));
            return sdf.format(calendar.getTime());
        }

        throw new PatternQueryException("This entry is not valid!");
    }

Falls nun illegale Argumente eingegeben werden bekomme ich in der Konsole meine hier definierten Fehlermeldungen.

Meine Klasse patternQueryException sieht so aus:

public class PatternQueryException extends IllegalArgumentException {

    private static final long serialVersionUID = 8696342062082168859L;

    /**
    * Constructs an <code>patternQueryException</code> with the specified detail
    * message.
    * @param message: the detail message.
    *
    */
    public PatternQueryException(String message) {
        super(message);
    }
}

Dazu hätte ich nun ein paar Fragen:
1. Ist es möglich ist die Nachrichten irgendwie in der PatternQueryException Klasse zu definieren?
2. Kann ich für die beiden Exceptions die ich in der ersten Methode throwe auch zwei unterschiedliche Konstruktoren in meiner Exception Klasse anlegen? Mit unterschiedlichen Namen für besseres Verständnis?
3. super(message) ruft ja einen Konstruktor auf der einen Parameter vom Typ message akzeptiert. Welcher Konstruktor wird hierfür in meinem konkreten Beispiel verwendet?
4. Ist meine Vorgehensweise bisher richtig? Oder sollte ich mich noch in das Schlüsselwort

 catch

einarbeiten?
5. Warum ist die Zeile

 private static final long serialVersionUID = 8696342062082168859L;

genau notwendig?

 

[Robat]

1. Ist es möglich ist die Nachrichten irgendwie in der PatternQueryException Klasse zu definieren?

Ja einfach als Member/Konstante der Klasse

Kann ich für die beiden Exceptions die ich in der ersten Methode throwe auch zwei unterschiedliche Konstruktoren in meiner Exception Klasse anlegen? Mit unterschiedlichen Namen für besseres Verständnis?

Konstruktoren müssen so heißen wie die Klasse. Du kannst aber mehrere Konstruktoren mit unterschiedlichen Parameterlisren anlegen

3. super(message) ruft ja einen Konstruktor auf der einen Parameter vom Typ message akzeptiert. Welcher Konstruktor wird hierfür in meinem konkreten Beispiel verwendet?

super() ruft den Konstruktor mit der passenden Parameterliste der Oberklasse (in dem Fall IllegalArgumentException) auf

4. Ist meine Vorgehensweise bisher richtig? Oder sollte ich mich noch in das Schlüsselwort

catch brauchst du hier nicht - du willst ja die Exceptions werfen und nicht behandeln

5. Warum ist die Zeile

Notwendig ist die Zeile nicht für dich. eclipse möchte das nur so haben. Wenn du wissen willst wozu man die Zeile braucht schau dir mal Serialisierung in Java an

 

[mihe7]

Prinzipiell würde ich mir überlegen, ob ich das überhaupt per Exceptions lösen will. Falsche Benutzereingaben sind so gesehen keine Ausnahme, sondern etwas, mit dem man rechnen sollte.

Wenn man sich dann tatsächlich zu Exceptions entschließt, wäre die nächste Frage, welchen Sinn es macht, diese noch großartig nach Typ zu unterscheiden. Was habe ich von der Unterscheidung in IllegalArgumentException und PatternQueryException?

Abgesehen von diesen Überlegungen folgen ein paar Antworten auf Deine Fragen:
1. Ja, das ist z. B. per enum möglich. Du kannst in Deiner Exception-Klasse z. B. einfach einen Aufzählungstyp definieren:

public enum Reason {
    EMPTY_QUERY,  INVALID_QUERY
}
//oder auch
public enum Reason {
    EMPTY_QUERY("You can not..."),  
    INVALID_QUERY("Invalid ...");
    private String text;
    Reason(String text) { this.text = text; }
    public String getText() { return text; }
}

2. Nein. Möglich wären aber z. B. Factory-Methoden:

private PatternQueryException(String message) {
    super(message);
}

public static PatternQueryException invalidQuery() {
    return new PatternQueryException("Invalid...");
}
public static PatternQueryException emptyQuery() {
    return new PatternQueryException("You can not...");
}

Kann man natürlich mit enums kombinieren, aber da der Konstruktor hier eh private ist, kann man sich das sparen. Würdest Du den Konstruktor dagegen z. B. public machen, könnten sich enums wieder lohnen.

Im Endeffekt: alles Overkill.

3., 4. und 5. s. Antwort von @Robat

 

[friednoodles]

Was habe ich von der Unterscheidung in IllegalArgumentException und PatternQueryException?

Soweit ich das verstanden habe hat man von der Unterscheidung nichts. Bei dem Problem geht es eigentlich nur darum, dass ich verstehe wie man mit Custom Exceptions richtig umgeht.

public enum Reason {
    EMPTY_QUERY("You can not..."), 
    INVALID_QUERY("Invalid ...");
    private String text;
    Reason(String text) { this.text = text; }
    public String getText() { return text; }
}

Wie kann ich diese Enums an meine "throw new PatternQueryException" aus der Methode vom 1. Post anheften?
Egal was ich versuche, ohne Fehler akzeptiert wird nur meine eigene bisherige Methode die ich auch im ersten Beitrag schon beschrieben habe.

 

[mihe7]

Spoiler: PatternQueryException.java

public class PatternQueryException extends Exception {
    public enum Reason {
        EMPTY_QUERY("Query was empty"),
        INVALID_QUERY("Query was invalid");

        private String text;

        Reason(String text) { this.text = text; }
        public String getText() { return text; }
    };

    private Reason reason;

    public PatternQueryException(Reason reason) {
        super(reason.getText());
        this.reason = reason;
    }

    public Reason getReason() { return reason; }
}

Spoiler: Test.java

public class Test {
    public static void main(String[] args) {
        try {
            throw new PatternQueryException(
                    PatternQueryException.Reason.EMPTY_QUERY);
        } catch (PatternQueryException ex) {
            System.out.println("Reason was: " + ex.getReason());
        }
    }
}

 

[mrBrown]

Soweit ich das verstanden habe hat man von der Unterscheidung nichts.

Von der Unterscheidung hast du das gleiche, wie von den Enums

Der Unterschied zwischen den Fehlern ist nicht nur anhand der Nachricht erkennbar, sondern auch an dem Typ, was manchmal nötig ist.