Comment créer nos propres exceptions en java

Question

Salut quelqu'un pls peut-il me exemple simple pour la création et l’utilisation UserDefined Exceptions en java

Merci d’avance SS

Answer 1

Pour définir un checked exception que 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); }
}

Des méthodes qui peuvent potentiellement jeter ou de propager cette exception doit le déclarer:

public void calculate(int i) throws FooException, IOException;

... et le code de l'appel de cette méthode doit prendre en charge ou de 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 que dans l'exemple ci-dessus que l' IOException il est capturé et renvoyé en tant que FooException. C'est une technique courante utilisée pour encapsuler des exceptions (généralement lors de l'implémentation d'une API).

Parfois il y aura des situations où vous ne voulez pas la force de chaque méthode afin de déclarer vos exception de l'application dans ses lancers de la clause. Dans ce cas, vous pouvez créer un décoché exception. Un décoché exception est toute exception qui s'étend java.lang.RuntimeException (qui est une sous-classe de la java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Les méthodes peuvent jeter ou de propager FooRuntimeException d'exception, sans le déclarer, par exemple;

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

Décoché les exceptions sont généralement utilisés pour désigner un programmeur d'erreur, par exemple en passant un argument non valide pour une méthode ou tenter de violer un index de tableau de limites.

Le java.lang.Throwable classe est la racine de toutes les erreurs et les exceptions qui peuvent être levées à l'intérieur de Java. java.lang.Exception et java.lang.Erreur sont à la fois des sous-classes d' Throwable. Rien que les sous-classes Throwable peut être jeté ou capturés. Cependant, il est généralement une mauvaise pratique de l'attraper ou de jeter Error comme ce est utilisé pour indiquer les erreurs internes de la machine qui ne peut généralement pas être "manipulés" par le programmeur (par exemple OutOfMemoryError). De même, vous devriez éviter d'attraper Throwable, ce qui pourrait avoir pour résultat la capture Errors en plus de Exceptions.

Answer 2

<pre><code></code><p>Le jeter comme :</p><pre><code></code></pre><p>Des captures :</p><pre><code></code></pre></pre>

Answer 3

Pour un checked exception:

public class MyCustomException extends Exception { }

Techniquement, tout ce qui s'étend au - Throwable peut être levée, mais les exceptions sont généralement des extensions de l' Exception de la classe afin qu'ils soient vérifiés exceptions (à l'exception RuntimeException ou de classes, qui ne sont pas vérifiées), contrairement à l'autre type commun de throwable, Errors qui ne sont généralement pas quelque chose conçu pour être gracieusement traitées au-delà de la JVM des éléments internes.

Vous pouvez également faire des exceptions à la non-public, mais ensuite vous pouvez les utiliser uniquement dans le paquet qui les définit, par opposition à travers les paquets.

Aussi loin que de lancer/attraper personnalisé exceptions, il fonctionne exactement comme le haut-ceux - lancer via

throw new MyCustomException()

et de l'attraper par

catch (MyCustomException e) { }