Annons

Ett undantag i programmering betyder ett exceptionellt tillstånd vid någon tidpunkt i programutförandet. Det används när det exceptionella tillståndet kan hanteras bättre någon annanstans snarare än där det stöter på. Tänk på följande exempel:

  • Underlåtenhet att öppna en konfigurationsfil kan hanteras bättre högre upp i koden, kanske genom att använda en alternativ konfigurationsfilplats.
  • Åtkomst till en matrisobjekt Hur man använder en Java ArrayListEn Java-arraylist är en grupp som kan ändras med allmänt ändamål. Den tillhandahåller de flesta av de faciliteter som vanligtvis förväntas av matriser på andra språk. I den här artikeln lär du dig att konfigurera och använda en arraylist. Läs mer utanför gränsen för matrisen betyder ett programfel. Lycklig felsökning!
  • Ett XML-parsing-fel bör läggas till användarens uppmärksamhet så att XML-filen kan korrigeras.
  • Programmet som slutar på minnet (kanske vid bearbetning av en stor fil) kan korrigeras genom att kanske öka mängden minne tillgängligt för java-processen.
instagram viewer

I alla dessa fall (och mer) bör undantaget hanteras utanför den plats där det genereras så att den underliggande orsaken kan hanteras.

Typer av undantag

Bilden nedan visar huvuddelen av Java-undantagshierarkin. Basklassen är Throwable som delas in i Undantag och Fel. Klass Undantag är för programrelaterade förhållanden som applikationer kan fånga i ett försök att rädda situationen. Klass Felå andra sidan är för att indikera allvarliga fel i Java Run-Time Miljö som applikationer inte bör fånga. Några exempel är: OutOfMemoryError och Stackoverflowerror.

Undantagshierarki

Ett Undantag igen är av två typer: kontrollerad och avmarkerad. Ett kontrollerat undantag måste hanteras med samtalskoden. Denna regel verkställs av Java-kompilatorn. Ett okontrollerat undantag kan å andra sidan spridas upp i samtalskedjan utan att behöva förklara det uttryckligen. Exemplen nedan kommer att klargöra.

Kontrollerade undantag

Följande metod försöker skapa Filereader från en fil. Byggaren kastar ett kontrollerat undantag FileNotFoundException som måste hanteras med samtalskoden eller förklaras kastas.

Följande kod kommer inte sammanställa eftersom det inte gör varken.

private void loadFile (String-filnamn) {FileReader i = nytt FileReader (filnamn); }

Ett sätt att få koden att sammanställa är att hantera undantaget (se nedan).

private void loadFile (String-filnamn) {prov {FileReader i = nytt FileReader (filnamn)); {} catch (FileNotFoundException ex) {// hantera undantag här} }

Om undantaget inte kan hanteras direkt av den som ringer måste det anges i metodsignaturen.

private void loadFile (String filnamn) kastar java.io. FileNotFoundException. {FileReader i = nytt FileReader (filnamn)); { }

Okonterade undantag

Ett underkontrollerat undantag är ett som underklassas från RuntimeException och behöver inte hanteras direkt eller deklareras som ovan. Till exempel resulterar följande kod i a NullPointerException, som är en typ av RuntimeException. Koden sammanställs dock utan fel sedan NullPointerException är ett okontrollerat undantag.

private void handleEvent () {String name = null; if (name.length ()> 0) {} }

Inpackning av undantag

Med tanke på ovanstående diskussion om markerade och okontrollerade undantag verkar det som om det är lättare att ta itu med okontrollerade undantag eftersom du inte behöver förklara dem eller hantera dem själv. Med den bekvämligheten i åtanke kan det ibland vara användbart att linda in ett kontrollerat undantag i ett okontrollerat undantag.

Följande kodexempel visade hur man slår in ett undantag. Metoden method_1 () kastar en SQLException i sin kropp. För att koden ska kunna kompileras korrekt måste undantaget förklaras kastas.

private void method_1 () kastar SQLException {... kasta ny SQLException; }

När den här metoden åberopas från en annan metod (method_2 ()), den metoden kan fånga SQLException och linda in det i ett okontrollerat undantag, så det behöver inte förklara undantaget i metodsignaturen.

private void method_2 () {try {method_1 (); } fånga (java.sql. SQLException ex) {kasta ny RuntimeException (ex); } }

Undantag Stack Trace

En undantags stackspår hänvisar till matrisen med aktiva stapelramar, som var och en representerar en metodinkallelse, fångad av JVM vid den tidpunkt då undantaget kastades. Varje stapelram innehåller platsen för metodinokallering inklusive klassnamn, metodnamn och eventuellt java-källfilens namn och radnummer i filen. Det är användbart för att spåra samtalssekvensen som orsakade felet Java-undantag: hanterar du dem rätt?Ett undantag i programmering betyder ett exceptionellt villkor i programutförandet. Det används när villkoret kan hanteras bättre någon annanstans. Tänk på följande exempel på Java-undantagshantering. Läs mer .

Här är ett typiskt stapelspår, erhållet från undantagsobjektet när det fångades.

Undantag i tråd "huvud" java.lang. IndexOutOfBoundsException: Index: 8, Storlek: 5 på java.util. ArrayList.rangeCheck (ArrayList.java: 653) på java.util. ArrayList.get (ArrayList.java: 429) på sample.sample1.main (sample1.java: 24)

Undantaget som fångas här är IndexOutOfBoundsException. Den innehåller ytterligare information om felet. Stackspåret innehåller 3 stapelramar, som var och en innehåller platsinformationen som visas.

Hantera undantag

Ett undantag kan hanteras genom att fånga det i en försök fånga blockera och vidta alla korrigerande åtgärder som krävs. De Undantag objektet erbjuder flera metoder för att extrahera information om tillståndet som orsakade det.

Följande kod loggar felmeddelandet till en loggfil.

private void loadConfig () {försök {// anropa kod som kan generera en IOException} -fångst (java.io. IOException ex) {// hantera undantag här. Kan logga in i en loggfil. log.warning (ex.getMessage ()); } }

När ett undantag är inslaget i ett annat kan du hämta det inslagna undantaget:

Kastbar orsak = ex.getCause (); log.warning ("Underliggande orsak:" + orsak.getMessage ()); 

Behöver du komma åt stapelspåret och kanske extrahera namnet på metoden som orsakade den?

StringBuilder sbuf = new StringBuilder ("Stack Trace:"); för (StackTraceElement el: ex.getStackTrace ()) {sbuf.append (el.getClassName () + "." + el.getMethodName ()). append ("\ n"); } log.warning (sbuf.toString ());

Eller kanske, logga undantaget och dra om det?

Prova {... } fånga (java.io. IOException ex) {log.warning (ex.getMessage ()); kasta ex; }

De Undantag klass ger en printStackTrace () metod som kan skriva ut stackspåret till din egen Print (eller PrintWriter).

Prova {... } fånga (java.io. IOException ex) {PrintStream out =...; out.println (ex.getMessage ()); ex.printStackTrace (ut); }

Du kan fånga flera typer av undantag i en enda Prova blockera och utför specifik hantering för varje typ av undantag.

försök {// kastar några undantag här. } fånga (java.io. IOException ex) {// IOException-specifik hantering här. } fånga (java.sql. SQLException ex) {// SQLException-specifik hantering här. }

För att fånga flera undantagstyper men använda samma hanteringskod kan du förklara a fånga blockera med flera typer enligt följande:

försök {// kastar några undantag här. } fånga (java.io. IOException | java.sql. SQLException ex) {// IOException och SQLException-specifik hantering här. } catch (SAXException ex) {// SAXException-specifik hantering här. }

Rengöring av resurser med slutligen

När man hanterar kod som kan kasta undantag är det viktigt att utföra korrekt rengöring av resurser, som öppnade filer Allt du behöver veta om filformat och deras egenskaperVi använder ordfilen omväxlande: musik, bild, kalkylblad, bildspel, och så vidare. Men vad gör en fil till en "fil" ändå? Låt oss försöka förstå denna grundläggande del av datoranvändning. Läs mer , databasanslutningar etc. Rengöring av resurser ska utföras i en till sist blockera. På detta sätt påkallas både normal utgång och exceptionell utgång från ett block rensningskod De 10 värsta programmeringsfel i historienI dess förvarade förflutna kodar också smält förstörelse. Förekomster av lite dålig kod orsakade katastrof på en större nivå. Följande är 10 av de värsta programmeringsfel i historien. Läs mer .

InputStream in = null; Prova {... in = nytt FileInputStream (filnamn);... } fånga (java.io. IOException ex) {log.warning (ex.getMessage ()); } slutligen {// -koden här exekveras vid avslutande av testblocket, // vare sig det är normalt eller på grund av ett undantag om (i! = null) in.close (); }

Try-With-Resources Block

Java 1.7 introducerade prova-med-resurser konstruera vilket underlättar resursrensning. Det ser ut så här:

prova (InputStream in = new FileInputStream (..)) {// -kod som använder InputStream. }

När koden lämnar blocket (vare sig rent eller på grund av ett undantag), Input variabel rensas automatiskt.

Rensa flera resurser genom att deklarera alla i blockets huvud.

prova (InputStream i = nytt FileInputStream (..); Anslutning con =...; ) {// -kod som använder InputStream och anslutningen. }

Alla objekt vars klass implementerar AutoCloseable gränssnittet kan städas upp på detta sätt. Följande klass utför någon specifik sanering i stänga() metod.

public class MyClass implementerar AutoCloseable {public void close () {// saneringskod här} }

Använd en instans av den här klassen i a prova-med-resurser blockera.

prova (MyClass obj = new MyClass (..)) {// -kod som använder MyClass-objektet. }

Några vanligt förekommande undantag

Låt oss nu titta på några vanliga undantag.

  • IndexOutOfBoundsException (oavkryssat): indikerar att index för elementet som åtkomst är utanför gränserna för en matris, sträng etc.
  • SQLException (markerad): kastas på grund av ett databasfel.
  • IOException (markerad): filåtkomstfel eller fel som har att göra med input och output.
  • InterruptedException (markerad): kastas när en trådkörning avbryts.
  • SAXException (markerad): kastas på grund av XML-tolkningsfel.
  • NullPointerException (avmarkerad): använder null där ett objekt krävs.

Avslutar

Undantag är den primära metoden för felrapportering och hantering i Java. Korrekt användning av undantag förbättra kodkvaliteten Skriv eller kod snabbare i din Linux Text Editor med anpassade temanDin Linux-textredigerare behöver inte vara snygg och "funktionell". Varför inte justera det för att förbättra din produktivitet, oavsett om man skriptar och kodar eller använder verktyget som markeringsredigerare? Läs mer och hjälp med att lösa problem i produktionen.

Har du några undantagsrelaterade krigshistorier att berätta? Om så är fallet, berätta om det i kommentarerna nedan.

Bildkredit: Dmitrij Nikolaev via Shutterstock.com