Hur man hanterar Java undantag på rätt sätt

Som programmering nybörjare Hur man läser programmering utan all stress Hur man lär sig programmering utan all stress Kanske har du bestämt dig för att förfölja programmeringen, vare sig du är för en karriär eller bara som en hobby. Bra! Men kanske börjar du känna dig överväldigad. Inte så bra. Här är hjälp för att underlätta din resa. Läs mer, begreppet undantagshantering kan vara svårt att sätta på huvudet runt. Inte så att begreppet i sig är svårt, men terminologin kan göra det verkade mer avancerat än det är. Och det är så kraftfullt att det är benäget för missbruk och missbruk.

I den här artikeln lär du dig vilka undantag, varför de är viktiga, hur man använder dem och vanliga misstag att undvika. De flesta moderna språk 6 enklaste programmeringsspråk att lära sig för nybörjare 6 enklaste programmeringsspråk att lära sig för nybörjare Att lära sig att programmera handlar om att hitta rätt språk lika mycket som det handlar om uppbyggnadsprocessen. Här är de sex bästa enklaste programmeringsspråk för nybörjare. Läs mer har någon form av undantagshantering, så om du någonsin går vidare från Java 7 Användbara tricks för att behärska ett nytt programmeringsspråk 7 Användbara tricks för att behärska ett nytt programmeringsspråk Det är okej att vara överväldigad när du lär dig att koda. Du kommer noga att glömma saker så fort du lär dig dem. Dessa tips kan hjälpa dig att bättre behålla all den nya informationen. Läs mer, du kan ta de flesta av dessa tips med dig.

Förstå Java Undantag

I Java, en undantag är ett objekt som indikerar något onormalt (eller “exceptionell”) inträffade under programmets körning. Sådana undantag är kastas, vilket i grunden betyder att ett undantagsobjekt skapas (liknar hur fel är “upphöjd”).

Skönheten är det du kan fånga kastade undantag, som låter dig hantera det onormala tillståndet och låta din ansökan fortsätta springa som om ingenting gick fel. Till exempel, medan en nollpekare i C kan krascha din ansökan låter du Java kasta och fånga NullPointerExceptions innan en nollvariabel har en chans att orsaka en krasch.

Kom ihåg, ett undantag är bara ett objekt, men med en viktig egenskap: det måste utökas från Undantag klass eller någon underklass av Undantag. Medan Java har alla typer av inbyggda undantag kan du också skapa din egen om du vill. Några av de vanligaste Java-undantagen är:

• NullPointerException
• NumberFormatException
• IllegalArgumentException
• RuntimeException
• IllegalStateException

Så vad händer när du kastar ett undantag?

Först ser Java ut inom den omedelbara metoden för att se om det finns kod som hanterar vilken typ av undantag du kastade. Om en handlare inte existerar, ser den på den metod som kallas den aktuella metoden för att se om ett handtag finns där. Om inte, ser det på den metod som kallas den där metod, och sedan nästa metod, etc. Om undantaget inte fångas, skriver programmet ett stackspår och kraschar sedan. (Det är faktiskt mer nyanserat än att bara krascha, men det är ett avancerat ämne utöver den här artikelns omfattning.)

en stack spår är en lista över alla metoder som Java gick igenom medan man letade efter en undantagshanterare. Här ser du hur en stackspår ser ut:

Undantag i tråd "main" java.lang.NullPointerException på com.example.myproject.Book.getTitle (Book.java:16) på com.example.myproject.Author.getBookTitles (Author.java:25) på com.example. myproject.Bootstrap.main (Bootstrap.java:14)

Vi kan ta mycket av det här. Först var det kastade undantaget a NullPointerException. Det hände i getTitle () metod på rad 16 i Book.java. Den metoden kallades från getBookTitles () på rad 25 av Author.java. Den där Metoden heter från main () på rad 14 i Bootstrap.java. Som du kan se är det lättare att känna till allt detta.

Men igen, den sanna fördelen med undantag är att du kan “hantera” det onormala villkoret genom att fånga undantaget, ställa in saker rätt och återuppta ansökan utan att krascha.

Använda Java-undantag i kod

Låt oss säga att du har someMethod () som tar ett heltal och utför någon logik som kan brytas om heltalet är mindre än 0 eller större än 100. Det kan vara ett bra ställe att göra ett undantag:

public void someMethod (int värde) if (value < 0 || value > 100) släng nytt IllegalArgumentException();  // //

För att fånga detta undantag måste du gå till var someMethod () kallas och använder provkroppsblock:

offentligt ogiltigt callMethod () försök someMethod (200); someOtherMethod ();  fånga (IllegalArgumentException e) // hantera undantaget här // ...

Allt inom Prova block kommer att utföras i ordning tills ett undantag kastas. Så snart ett undantag kastas, hoppas alla efterföljande uttalanden och applikationslogiken hoppar omedelbart till fånga blockera.

I vårt exempel går vi in ​​i provblocket och ringer omedelbart someMethod (). Eftersom 200 inte är mellan 0 och 100, an IllegalArgumentException kastas. Detta slutar omedelbart utförandet av someMethod (), hoppar över resten av logiken i försöksblocket (someOtherMethod () kallas aldrig), och återupptas utförande inom fångstblocket.

Vad skulle hända om vi ringde someMethod (50) istället? De IllegalArgumentException skulle aldrig kastas. someMethod () skulle genomföras som vanligt. Försöksblocket skulle utföras som vanligt, ringer someOtherMethod () när someMethod () fullbordar. När someOtherMethod () slutar, fångstblocket skulle hoppas över och callingMethod () skulle fortsätta.

Observera att du kan ha flera fångstblock per försöksblock:

offentligt ogiltigt callMethod () försök someMethod (200); someOtherMethod ();  fångst (IllegalArgumentException e) // hantera undantaget här fånga (NullPointerException e) // hantera undantaget här // ...

Observera också att en valfri till sist block finns också:

offentlig tomgångsmetod () försök // ... fånga (Undantag e) // ... äntligen // ...

Koden inom ett slutligt block är alltid exekverad oavsett vad. Om du har ett returmeddelande i försöksblocket, slutfördes slutligen blocket innan du återvänder från metoden. Om du kastar ett annat undantag i fångstblocket exekveras slutligen blocket innan undantaget kastas.

Du ska använda slutligen blocket när du har föremål som behöver rengöras innan metoden slutar. Om du till exempel öppnade en fil i försöksblocket och senare slängde ett undantag låter du slutligen låsa filen innan du lämnar metoden.

Observera att du kan få ett slutligt block utan ett fångstblock:

public void-metod () försök // ... äntligen // ...

Det här gör att du kan göra eventuell rengöring samtidigt som du tillåter borttagna undantag för att sprida upp metodinställningsstacken (det vill säga att du inte vill hantera undantaget här men du behöver fortfarande städa upp först).

Kontrollerad vs Undantagna undantag i Java

Till skillnad från de flesta språk skiljer sig Java mellan kontrollerade undantag och obekanta undantag (t ex har C # endast obekanta undantag). Ett kontrollerat undantag måste fångas i den metod där undantaget kastas, annars kommer koden inte att kompileras.

För att skapa ett kontrollerat undantag sträcker du från Undantag. För att skapa ett okontrollerat undantag, sträck från RuntimeException.

Varje metod som kastar ett kontrollerat undantag måste ange detta i metodens signatur med hjälp av kastar nyckelord. Eftersom Java är inbyggd IOException är ett kontrollerat undantag, kommer följande kod inte att kompilera:

public void wontCompile () // ... om (someCondition) kasta ny IOException ();  // //

Du måste först förklara att det kastar ett kontrollerat undantag:

public void willCompile () kasta IOException // ... if (someCondition) kasta ny IOException ();  // //

Observera att en metod kan förklaras som att kasta ett undantag men aldrig faktiskt kasta ett undantag. Ändå behöver undantaget fortfarande fångas, annars kommer koden inte att kompileras.

När ska du använda markerade eller obekanta undantag?

Den officiella Java-dokumentationen har en sida om denna fråga. Det sammanfattar skillnaden med en kortfattad tumregel: “Om en kund rimligen kan förväntas återhämta sig från ett undantag, gör det ett kontrollerat undantag. Om en klient inte kan göra något för att återhämta sig från undantaget, gör det ett obekant undantag.”

Men denna riktlinje kan vara föråldrad. Å andra sidan resulterar kontrollerade undantag i mer robust kod 10 Tips för att skriva renare och bättre kod 10 Tips för att skriva renare och bättre kod Skriva ren kod ser lättare ut än vad den egentligen är, men fördelarna är värda det. Så här kan du börja skriva renare kod idag. Läs mer . Å andra sidan har inget annat språk kontrollerat undantag på samma sätt som Java, vilket visar två saker: en, funktionen är inte användbar för att andra språk ska stjäla det och två, du kan absolut leva utan dem. Plus, kontrollerade undantag spelar inte bra med lambda-uttryck införda i Java 8.

Riktlinjer för användning av Java-undantag

Undantag är användbara men lätt missbrukas och missbrukas. Här är några tips och bästa metoder för att hjälpa dig att undvika att göra en röra av dem.

• Föredragna specifika undantag för allmänna undantag. Använda sig av NumberFormatException över IllegalArgumentException när det är möjligt, använd annars IllegalArgumentException över RuntimeException när det är möjligt.
• Fånga aldrig Throwable! De Undantag klassen sträcker sig faktiskt Throwable, och fångstblocket fungerar faktiskt med Throwable eller någon klass som sträcker sig Throwable. Men Fel klassen sträcker sig också Throwable, och du vill aldrig fånga en Fel därför att Fels indikerar allvarliga oåterkalleliga problem.
• Fånga aldrig Undantag! InterruptedException sträcker Undantag, så vilket block som fångar Undantag kommer också att fånga InterruptedException, och det är ett väldigt viktigt undantag som du inte vill röra med (speciellt i multi-threaded applikationer) om du inte vet vad du gör. Om du inte vet vilket undantag att fånga istället, överväga inte att fånga någonting.
• Använd beskrivande meddelanden för att underlätta felsökning. När du lägger ett undantag kan du ge en Sträng meddelande som ett argument. Detta meddelande kan nås i fångstblocket med hjälp av Exception.getMessage () metod, men om undantaget aldrig fångas kommer meddelandet också att visas som en del av stapelspåret.
• Försök att inte fånga och ignorera undantag. För att ta itu med besväret med kontrollerade undantag, kommer många nybörjare och lat programmerare att skapa ett fångstblock men lämna det tomt. Dålig! Hantera alltid det graciöst, men om du inte kan, utskrift åtminstone en stackspår så du vet att undantaget var kastat. Du kan göra detta med hjälp av Exception.printStackTrace () metod.
• Akta dig för överutnyttja undantag. När du har en hammare ser allt ut som en spik. När du först lär dig om undantag kan du känna dig skyldig att göra allt till ett undantag ... till den punkt där det mesta av din ansökans kontrollflöde hamnar i undantagshantering. Kom ihåg att undantag är avsedda för “exceptionell” förekomster!

Nu borde du vara bekväm nog med undantag för att förstå vad de är, varför de används och hur man införlivar dem i din egen kod. Om du inte helt förstår konceptet, så är det okej! Det tog mig ett tag för det “klick” i mitt huvud så känner du inte att du behöver skynda på det 6 Tecken på att du inte är avsedd att vara programmerare 6 Tecken på att du inte är avsedd att vara programmerare Inte alla är utklippta för att vara programmerare. Om du inte är helt säker på att du är avsedd att vara programmerare, här är några tecken som kan peka dig i rätt riktning. Läs mer . Ta din tid.

Har du några frågor? Vet du om några andra undantagsrelaterade tips som jag saknade? Dela dem i kommentarerna nedan!

Utforska mer om: Java.