Comment créer des exceptions personnalisées en Java? [fermé]

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

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 qui peuvent potentiellement lever 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 qui IOExceptionest capturé et relancé comme FooException. Il s'agit d'une technique courante utilisée pour encapsuler les exceptions (généralement lors de la mise en œuvre d'une API).

Parfois, il y aura des situations où vous ne voudrez pas forcer chaque méthode à déclarer votre implémentation d'exception dans sa clause throws. Dans ce cas, vous pouvez créer une exception non cochée . Une exception non cochée est toute exception qui s'étend java.lang.RuntimeException(qui elle-même est une sous-classe de java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Les méthodes peuvent lancer ou propager une FooRuntimeExceptionexception 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 désigner une erreur de programmeur, par exemple en passant un argument non valide à une méthode ou en tentant de franchir les limites d'un index de tableau.

La java.lang.Throwableclasse est la racine de toutes les erreurs et exceptions qui peuvent être levées dans Java. java.lang.Exceptionet java.lang.Errorsont tous deux des sous-classes de Throwable. Tout ce qui fait partie des sous-classes Throwablepeut être jeté ou attrapé. Cependant, il est généralement une mauvaise pratique d'attraper ou de lancer Errorcar cela est utilisé pour désigner des erreurs internes à la JVM qui ne peuvent généralement pas être "gérées" par le programmeur (par exemple OutOfMemoryError). De même, vous devez éviter d'attraper Throwable, ce qui pourrait vous amener à attraper Errors en plus de Exceptions.

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

Jetez-le comme:

 throw new MyException ("Something happened")

Catch comme:

catch (MyException e)
{
   // something
}

Pour une exception vérifiée:

public class MyCustomException extends Exception { }

Techniquement, tout ce qui s'étend Throwablepeut être levé, mais les exceptions sont généralement des extensions de la Exceptionclasse afin qu'elles soient des exceptions vérifiées (sauf RuntimeException ou les classes basées sur elle, qui ne sont pas vérifiées), par opposition à l'autre type courant de jetable, Errors qui ne sont généralement pas conçus pour être gérés avec élégance au-delà des internes de la JVM.

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

En ce qui concerne le lancement / la capture d'exceptions personnalisées, cela fonctionne comme les exceptions intégrées - throw via

throw new MyCustomException()

et attraper via

catch (MyCustomException e) { }