Come creare eccezioni personalizzate in Java?

Come creiamo eccezioni personalizzate in Java?

Per definire un’eccezione controllata si crea una sottoclass (o una gerarchia di sottoclassi) di java.lang.Exception . Per esempio:

 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); } } 

I metodi che possono potenzialmente lanciare o propagare questa eccezione devono dichiararlo:

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

… e il codice che chiama questo metodo deve gestire o propagare questa eccezione (o entrambi):

 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); } 

Nell’esempio precedente noterai che IOException viene catturato e FooException come FooException . Questa è una tecnica comune utilizzata per incapsulare le eccezioni (in genere quando si implementa un’API).

A volte ci sono situazioni in cui non si vuole forzare ogni metodo per dichiarare l’implementazione della propria eccezione nella sua clausola throws. In questo caso è ansible creare un’eccezione non controllata . Un’eccezione non controllata è un’eccezione che estende java.lang.RuntimeException (che a sua volta è una sottoclass di java.lang.Exception ):

 public class FooRuntimeException extends RuntimeException { ... } 

I metodi possono lanciare o propagare FooRuntimeException eccezione FooRuntimeException senza dichiararla; per esempio

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

Le eccezioni non controllate vengono in genere utilizzate per indicare un errore del programmatore, ad esempio passando un argomento non valido a un metodo o tentando di violare i limiti dell'indice dell'array.

La class java.lang.Throwable è la radice di tutti gli errori e le eccezioni che possono essere generate all'interno di Java. java.lang.Exception e java.lang.Error sono entrambe sottoclassi di Throwable . Tutto ciò che sottoclass Throwable può essere gettato o catturato. Tuttavia, è in genere una ctriggers pratica catturare o lanciare un Error poiché viene utilizzato per indicare errori interni alla JVM che di solito non possono essere "gestiti" dal programmatore (ad esempio OutOfMemoryError ). Allo stesso modo si dovrebbe evitare di prendere Throwable , che potrebbe causare la cattura di Error in aggiunta alle Exception .

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

Buttalo come:

  throw new MyException ("Something happened") 

Prendere come:

 catch (MyException e) { // something } 

Per un’eccezione controllata:

 public class MyCustomException extends Exception { } 

Tecnicamente, qualsiasi cosa che estenda Throwable può essere lanciata, ma le eccezioni sono generalmente estensioni della class Exception modo che siano controllate le eccezioni (eccetto RuntimeException o classi basate su di essa, che non sono controllate), a differenza dell’altro tipo comune di throwable, Error s che di solito non sono progettati per essere gestiti con garbo al di là degli interni di JVM.

È inoltre ansible rendere le eccezioni non pubbliche, ma in tal caso è ansible utilizzarle solo nel pacchetto che le definisce, anziché nei pacchetti.

Per quanto riguarda il lancio / cattura di eccezioni personalizzate, funziona proprio come quelle built-in – lanciare via

 throw new MyCustomException() 

e prendere via

 catch (MyCustomException e) { }