Java Language Lancer une exception


Exemple

L'exemple suivant montre les bases de la création d'une exception:

public void checkNumber(int number) throws IllegalArgumentException {
    if (number < 0) {
        throw new IllegalArgumentException("Number must be positive: " + number);
    }
}

L'exception est lancée sur la 3ème ligne. Cette déclaration peut être divisée en deux parties:

  • new IllegalArgumentException(...) crée une instance de la classe IllegalArgumentException , avec un message décrivant l'erreur IllegalArgumentException par une exception.

  • throw ... lance ensuite l'objet exception.

Lorsque l'exception est levée, les instructions englobantes se terminent anormalement jusqu'à ce que l'exception soit gérée . Ceci est décrit dans d'autres exemples.

Il est recommandé de créer et de lancer l’objet exception dans une seule instruction, comme indiqué ci-dessus. Il est également recommandé d'inclure un message d'erreur significatif dans l'exception pour aider le programmeur à comprendre la cause du problème. Cependant, ce n'est pas nécessairement le message que vous devez montrer à l'utilisateur final. (Pour commencer, Java ne prend pas en charge directement l’internationalisation des messages d’exception.)

Il y a encore quelques points à faire:

  • Nous avons déclaré le checkNumber comme throws IllegalArgumentException . Ce n'était pas strictement nécessaire, car IllegalArgumentException est une exception vérifiée; voir Hiérarchie des exceptions Java - Exceptions non vérifiées et vérifiées . Toutefois, il est conseillé de le faire et d'inclure les exceptions renvoyant les commentaires javadoc d'une méthode.

  • Code immédiatement après une instruction de throw est inaccessible . D'où si nous avons écrit ceci:

     throw new IllegalArgumentException("it is bad");
     return;
    

    le compilateur signalerait une erreur de compilation pour l'instruction return .

Chaîne d'exception

De nombreuses exceptions standard ont un constructeur avec un deuxième argument de cause en plus de l'argument de message conventionnel. La cause vous permet d'enchaîner les exceptions. Voici un exemple.

Tout d'abord, nous définissons une exception non vérifiée que notre application va lancer lorsqu'elle rencontre une erreur non récupérable. Notez que nous avons inclus un constructeur qui accepte un argument de cause .

    public class AppErrorException extends RuntimeException {
        public AppErrorException() {
            super();
        }

        public AppErrorException(String message) {
            super(message);
        }

        public AppErrorException(String message, Throwable cause) {
            super(message, cause);
        }
    }

Ensuite, voici un code qui illustre le chaînage des exceptions.

    public String readFirstLine(String file) throws AppErrorException {
        try (Reader r = new BufferedReader(new FileReader(file))) {
            String line = r.readLine();
            if (line != null) {
                return line;
            } else {
                throw new AppErrorException("File is empty: " + file);
            }
        } catch (IOException ex) {
            throw new AppErrorException("Cannot read file: " + file, ex);
        }
    }

Le throw dans le bloc try détecte un problème et le signale via une exception avec un message simple. En revanche, le throw dans le bloc catch gère l'exception IOException l' IOException dans une nouvelle exception (cochée). Cependant, il ne rejette pas l'exception d'origine. En faisant passer l’ IOException tant que cause , nous l’enregistrons pour qu’elle puisse être imprimée dans la trace de la pile, comme expliqué dans la section Création et lecture de chaînes de caractères .