web-dev-qa-db-fra.com

Comment créer des exceptions personnalisées en Java?

Comment créer des exceptions personnalisées en Java?

javaexception
147
Suresh Chaganti

Pour définir une exception cochée , vous créez une sous-classe (ou une hiérarchie de sous-classes) de Java.lang.Exception . Par exemple:

_public class FooException extends Exception {
  public FooException() { super(); }
  public FooException(String message) { super(message); }
  public FooException(String message, Throwable cause) { super(message, cause); }
  public FooException(Throwable cause) { super(cause); }
}
_

Les méthodes pouvant potentiellement lancer ou propager cette exception doivent la déclarer:

_public void calculate(int i) throws FooException, IOException;
_

... et le code appelant cette méthode doit gérer ou propager cette exception (ou les deux):

_try {
  int i = 5;
  myObject.calculate(5);
} catch(FooException ex) {
  // Print error and terminate application.
  ex.printStackTrace();
  System.exit(1);
} catch(IOException ex) {
  // Rethrow as FooException.
  throw new FooException(ex);
}
_

Vous remarquerez dans l'exemple ci-dessus que IOException est intercepté et rediffusé en tant que FooException. Il s'agit d'une technique courante utilisée pour encapsuler les exceptions (généralement lors de l'implémentation d'une API).

Il peut arriver que vous ne vouliez pas forcer chaque méthode à déclarer l'implémentation de votre exception dans sa clause throws. Dans ce cas, vous pouvez créer une exception non contrôlée . Une exception non contrôlée est une exception qui s'étend Java.lang.RuntimeException (qui est elle-même une sous-classe de Java.lang.Exception ):

_public class FooRuntimeException extends RuntimeException {
  ...
}
_

Les méthodes peuvent lever ou propager l'exception FooRuntimeException sans la déclarer. par exemple.

_public void calculate(int i) {
  if (i < 0) {
    throw new FooRuntimeException("i < 0: " + i);
  }
}
_

Les exceptions non vérifiées sont généralement utilisées pour signaler une erreur de programmation, par exemple en transmettant un argument non valide à une méthode ou en tentant de violer les limites d'un index de tableau.

La classe Java.lang.Throwable est la racine de toutes les erreurs et exceptions pouvant être générées dans Java. Java.lang.Exception et Java.lang.Error sont les deux sous-classes de Throwable . Tout ce qui est sous-classe Throwable peut être lancé ou attrapé. Cependant, il est généralement déconseillé d’attraper ou de lancer Error , car cela sert à désigner des erreurs internes à la machine virtuelle qui ne peuvent généralement pas être "traitées" par le programmeur (par exemple, OutOfMemoryError ). De même, vous devriez éviter de capturer Throwable , ce qui pourrait entraîner votre capture Error s en plus de Exception s.

281
Adamski
public class MyException extends Exception {
        // special exception code goes here
}

Jetez-le comme:

 throw new MyException ("Something happened")

Catch en tant que:

catch (MyException e)
{
   // something
}
25
laura

Pour une exception vérifiée:

public class MyCustomException extends Exception { }

Techniquement, tout ce qui étend Throwable peut être levé, mais les exceptions sont généralement des extensions de la classe Exception de sorte qu'elles soient vérifiées comme exceptions (à l'exception de RuntimeException ou des classes basées sur celle-ci, qui ne sont pas vérifiées), contrairement aux autres types courants de jetables, Errors, qui ne sont généralement pas conçus pour être traités avec élégance au-delà des éléments internes de la JVM.

Vous pouvez également rendre des exceptions non publiques, mais vous ne pouvez ensuite les utiliser que dans le package qui les définit, par opposition à plusieurs packages.

Pour ce qui est de lancer/intercepter des exceptions personnalisées, cela fonctionne comme les exceptions intégrées - jeter via

throw new MyCustomException()

et attraper via

catch (MyCustomException e) { }
4
Amber