Att slå in ett undantag

3. Undantag för omslag

Kontrollerade undantag verkade coolt i teorin, men visade sig vara en enorm frustration i praktiken.

Anta att du har en superpopulär metod i ditt projekt. Det kallas från hundratals platser i ditt program. Och du bestämmer dig för att lägga till ett nytt markerat undantag till det. Och det kan mycket väl vara så att detta kontrollerade undantag är riktigt viktigt och så speciellt att bara main()metoden vet vad den ska göra om den fångas.

Det betyder att du måste lägga till det markerade undantaget till throwsklausulen för varje metod som anropar din superpopulära metod . Samt i throwsklausulen av alla metoder som kallar dessa metoder. Och av metoderna som kallar dessa metoder.

Som ett resultat throwsfår klausulerna i hälften av metoderna i projektet ett nytt kontrollerat undantag. Och naturligtvis omfattas ditt projekt av tester, och nu kompileras inte testerna. Och nu måste du redigera kastsatserna i dina tester också.

Och sedan måste all din kod (alla ändringar i hundratals filer) granskas av andra programmerare. Och vid det här laget frågar vi oss själva varför vi gjorde så många blodiga förändringar i projektet? Arbetsdag(ar?) och trasiga tester - allt för att lägga till ett markerat undantag?

Och naturligtvis finns det fortfarande problem relaterade till arv och metodöverstyrning. Problemen som kommer från kontrollerade undantag är mycket större än nyttan. Summan av kardemumman är att nu är få människor som älskar dem och få människor använder dem.

Det finns dock fortfarande mycket kod (inklusive standard Java-bibliotekskod) som innehåller dessa markerade undantag. Vad ska man göra med dem? Vi kan inte ignorera dem, och vi vet inte hur vi ska hantera dem.

Java-programmerare föreslog att linda in kontrollerade undantag i RuntimeException. Med andra ord, fånga alla markerade undantag och skapa sedan omarkerade undantag (till exempel ) RuntimeExceptionoch kasta dem istället. Att göra det ser ut ungefär så här:

try
{
   // Code where a checked exception might occur
}
catch(Exception exp)
{
   throw new RuntimeException(exp);
}

Det är inte en särskilt snygg lösning, men det finns inget brottsligt här: undantaget var helt enkelt stoppat i en RuntimeException.

Om så önskas kan du enkelt hämta den därifrån. Exempel:

try
{
   // Code where we wrap the checked exception
   // in a RuntimeException
}
catch(RuntimeException e)
{
   Throwable cause = e.getCause();
   if (cause instanceof Exception)
   {
      Exception exp = (Exception) cause;
      // Exception handling code goes here
   }
}