Throwable, meerdere uitzonderingen, uitzonderingen binnen de afwerkmethode

"Ah. Daar ben je. Ik heb naar je gezocht."

"Is er iets gebeurd?"

"Nee, maar we studeren nog."

"Oké. Ik luister."

"Ik wil je nog een paar dingen vertellen over uitzonderingen:"

"In Java 7 werd de try-catch- constructie enigszins uitgebreid door de toevoeging van meerdere catch- blokken. Kijk naar dit voorbeeld:"

try
{
  …
}
 catch (IOException ex)
{
 logger.log(ex);
 throw ex;
}
 catch (SQLException ex)
{
 logger.log(ex);
 throw ex;
}

try
{
  …
}
 catch (IOException | SQLException ex)
{
 logger.log(ex);
 throw ex;
}

"Dus nu kunnen we meerdere uitzonderingen schrijven, gescheiden door OR-operators ('|' is binaire OR)?"

"Dat klopt. Is dat niet handig?"

"Hmm. Maar wat is het type uitzonderingsobject in het catch-blok?"

"Een IOException heeft tenslotte zijn methoden en een SQLException heeft zijn methoden."

"Het uitzonderingstype is dat van hun gemeenschappelijke voorouderklasse."

"Ah. Met andere woorden, het zal hoogstwaarschijnlijk Exeption of RuntimeException zijn . Waarom schrijf je dan niet gewoon catch(Exception e)?"

"Soms is het bij het afzonderlijk afhandelen van fouten handig om ze te groeperen, sommige fouten naar een logboek te schrijven, andere opnieuw te genereren en andere op een andere manier af te handelen."

"Met andere woorden, dit schema wordt erkend als het oplossen van het probleem van dubbele catch-blokken voor het afhandelen van verschillende fouten."

"Ah. Ik snap het. Bedankt, Ellie."

"Dat is niet alles. Ik wil je nog wat meer vertellen over de laatste blokkering."

"Zoals je waarschijnlijk al weet, wordt dit blok altijd uitgevoerd."

"En als ik zeg altijd, dan bedoel ik absoluut altijd ."

"Bijvoorbeeld:"

try
{
 return 1;
}
 finally
{
 return 0;
}

"Hier is er een return in het try- blok en een return in het final- blok. Dus de returnwaarde van deze methode is het getal 0."

"Het final- blok wordt uitgevoerd, wat er ook gebeurt. En de return- instructie overschrijft de andere return-waarde met zijn eigen waarde."

"Ik zie."

" Een methode kan echter een waarde retourneren of een uitzondering genereren. "

"Dus als een waarde wordt geretourneerd in een try-blok, maar het final- blok een uitzondering genereert , dan is het resultaat een uitzondering . "

"Wat als er een uitzondering wordt gegenereerd in het try- blok, maar het final- blok een return-instructie heeft?"

"Dan is het alsof de methode goed heeft gewerkt en wordt de waarde in het return statement teruggegeven.

try
{
 return 1;
}
 finally
{
 return 0;
}

try
{
 return 1;
}
 finally
{
 throw new RuntimeException();
}

try
{
 throw new RuntimeException();
}
 finally
{
 return 0;
}

try
{
 throw new RuntimeException();
}
 finally
{
 throw new IOException();
}

"De enige reden waarom de methode final niet wordt uitgevoerd, is de onmiddellijke beëindiging van het programma door een aanroep van de methode System.exit() ;."

try
{
 System.exit(0);
 return 1;
}
 finally
{
 return 0;
}

"Ik zie."

"Houd er rekening mee dat over al deze onderwerpen meestal wordt gevraagd in interviews, dus het zou goed voor je zijn om ze te begrijpen en te onthouden."