Java Vang Meerdere Uitzonderingen, Gooi Uitzondering Opnieuw

In Java 7 is het catch-blok verbeterd om meerdere uitzonderingen in één catch-blok af te handelen. Als je meerdere uitzonderingen opvangt en ze hebben vergelijkbare code, zal het gebruik van deze functie code duplicatie verminderen. Laten we de functie van het vangen van meerdere uitzonderingen in Java begrijpen aan de hand van een voorbeeld.

Vang meerdere uitzonderingen in Java

Voor Java 7 vingen we meerdere uitzonderingen één voor één op, zoals hieronder getoond.

catch (IOException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
catch (SQLException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

In Java 7 kunnen we beide uitzonderingen in één catch-blok opvangen als volgt:

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Als een catch-blok meerdere uitzonderingen afhandelt, kun je ze scheiden met een pijp (|) en in dit geval is de uitzonderingsparameter (ex) definitief, dus je kunt deze niet wijzigen. De bytecode gegenereerd door deze functie is kleiner en vermindert de code redundantie.

Java gooi uitzondering opnieuw

Nog een verbetering is gedaan in de compileranalyse van opnieuw gegooiden uitzonderingen. Java opnieuw gooien van uitzondering stelt je in staat om meer specifieke uitzonderingstypen te specificeren in de throws-clausule van een methodeverklaring. Laten we dit zien aan de hand van een klein voorbeeld:

package com.journaldev.util;

public class Java7MultipleExceptions {

	public static void main(String[] args) {
		try{
			rethrow("abc");
		}catch(FirstException | SecondException | ThirdException e){
			//onderstaande opdracht zal een compileerfout veroorzaken omdat e definitief is
			//e = new Exception();
			System.out.println(e.getMessage());
		}
	}

	static void rethrow(String s) throws FirstException, SecondException,
			ThirdException {
		try {
			if (s.equals("First"))
				throw new FirstException("First");
			else if (s.equals("Second"))
				throw new SecondException("Second");
			else
				throw new ThirdException("Third");
		} catch (Exception e) {
			//onderstaande toewijzing schakelt de verbeterde herwerping van uitzonderingstypencontrole van Java 7 uit
			// e=new ThirdException();
			throw e;
		}
	}

	static class FirstException extends Exception {

		public FirstException(String msg) {
			super(msg);
		}
	}

	static class SecondException extends Exception {

		public SecondException(String msg) {
			super(msg);
		}
	}

	static class ThirdException extends Exception {

		public ThirdException(String msg) {
			super(msg);
		}
	}

}

Zoals u kunt zien, vangt het catch-blok in de methode rethrow uitzondering op, maar het maakt geen deel uit van de throws-clausule. De compiler van Java 7 analyseert het volledige probeer-blok om te controleren welke soorten uitzonderingen worden gegenereerd en vervolgens opnieuw worden uitgegooid vanuit het catch-blok. Let op: deze analyse is uitgeschakeld als u het argument van het catch-blok wijzigt. Verdere lezing: Uitzonderingsafhandeling in Java.