Algemene Java-uitzonderingen

1. Inleiding

Deze tutorial richt zich op enkele veelvoorkomende Java-uitzonderingen.

We beginnen met te bespreken wat in feite een uitzondering is. Later zullen we verschillende soorten aangevinkte en niet-aangevinkte uitzonderingen in detail bespreken.

2. Uitzonderingen

Een uitzondering is een abnormale toestand die optreedt in een codereeks tijdens de uitvoering van een programma. Deze abnormale toestand doet zich voor wanneer een programma tijdens runtime bepaalde beperkingen overtreedt.

Alle uitzonderingstypen zijn subklassen van de klasse Uitzondering. Deze klasse wordt vervolgens onderverdeeld in gecontroleerde uitzonderingen en niet-gecontroleerde uitzonderingen. We zullen ze in de volgende secties in detail bespreken.

3. Gecontroleerde uitzonderingen

Gecontroleerde uitzonderingen zijn verplicht om af te handelen. Het zijn directe subklassen van de klas Uitzondering.

Er is een debat over hun belang dat het bekijken waard is.

Laten we enkele gecontroleerde uitzonderingen in detail definiëren.

3.1. IOException

Een methode gooit een IOException of een directe subklasse ervan wanneer een Input / Output-bewerking mislukt.

Typische toepassingen van deze I / O-bewerkingen zijn onder meer:

  • Werken met het bestandssysteem of datastromen met java.io pakket
  • Netwerktoepassingen maken met java.net pakket

FileNotFoundException

FileNotFoundException is een veelvoorkomend type IOException tijdens het werken met het bestandssysteem:

probeer {nieuwe FileReader (nieuw bestand ("/ invalid / file / location")); } catch (FileNotFoundException e) {LOGGER.info ("FileNotFoundException gevangen!"); }

Onjuist gevormdeURLException

Bij het werken met URL's kunnen we tegenkomen Onjuist gevormdeURLException - als onze URL's ongeldig zijn.

probeer {nieuwe URL ("malformedurl"); } catch (MalformedURLException e) {LOGGER.error ("MalformedURLException gevangen!"); }

3.2. ParseException

Java gebruikt tekstparsing om een ​​object te maken op basis van een gegeven Draad.Als het parseren een fout veroorzaakt, wordt een ParseException.

We zouden bijvoorbeeld kunnen vertegenwoordigen Datum op verschillende manieren b.v. dd / mm / jjjj of dd, mm, jjjj, maar probeer een draad met een ander formaat:

probeer {nieuwe SimpleDateFormat ("MM, dd, jjjj"). parse ("invalid-date"); } catch (ParseException e) {LOGGER.error ("ParseException gevangen!"); }

Hier de Draad is misvormd en veroorzaakt een ParseException.

3.3. InterruptedException

Telkens wanneer een Java-thread aanroept join (), slaap () of wacht() het gaat in ofwel de AAN HET WACHTEN staat of de TIMED_WAITING staat.

Bovendien kan een thread een andere thread onderbreken door een andere thread aan te roepen onderbreken() methode.

Bijgevolg, de thread gooit een InterruptedException als een andere thread deze onderbreekt terwijl deze zich in de AAN HET WACHTEN of in de TIMED_WAITING staat.

Beschouw het volgende voorbeeld met twee threads:

  • De hoofddraad begint de kinderdraad en onderbreekt deze
  • De onderliggende thread begint en roept slaap()

Dit scenario resulteert in een InterruptedException:

klasse ChildThread breidt Thread {public void run () {probeer {Thread.sleep (1000); } catch (InterruptedException e) {LOGGER.error ("InterruptedException gevangen!"); }}} public class MainThread {public static void main (String [] args) gooit InterruptedException {ChildThread childThread = new ChildThread (); childThread.start (); childThread.interrupt (); }}

4. Ongecontroleerde uitzonderingen

Voor ongecontroleerde uitzonderingen controleert de compiler niet tijdens het compilatieproces. Daarom is het niet verplicht voor de methode om met deze uitzonderingen om te gaan.

Alle niet-aangevinkte uitzonderingen breiden de klasse uit RuntimeException.

Laten we enkele ongecontroleerde uitzonderingen in detail bespreken.

4.1. NullPointerException

Als een applicatie probeert te gebruiken nul waar het eigenlijk een objectinstantie vereist, zal de methode een NullPointerException.

Er zijn verschillende scenario's waarin illegaal gebruik van nul oorzaken NullPointerException. Laten we er een paar bekijken.

Een methode van de klasse aanroepen die geen objectinstantie heeft:

String strObj = null; strObj.equals ("Hallo wereld"); // gooit NullPointerException.

Ook als een toepassing probeert toegang te krijgen tot een instantievariabele of deze te wijzigen met een nul referentie, we krijgen een NullPointerException:

Persoon personObj = null; Tekenreeksnaam = personObj.personName; // Toegang tot het veld van een null-object personObj.personName = "Jon Doe"; // Het veld van een null-object wijzigen

4.2. ArrayIndexOutOfBoundsException

Een array slaat zijn elementen op een aaneengesloten manier op. We hebben dus toegang tot de elementen via indices.

Echter, als een stuk code probeert toegang te krijgen tot een illegale index van een array, gooit de respectievelijke methode een ArrayIndexOutOfBoundException.

Laten we een paar voorbeelden bekijken die gooien ArrayIndexOutOfBoundException:

int [] nums = new int [] {1, 2, 3}; int numFromNegativeIndex = nums [-1]; // Proberen toegang te krijgen tot een negatieve index int numFromGreaterIndex = nums [4]; // Proberen toegang te krijgen tot een grotere index int numFromLengthIndex = nums [3]; // Proberen toegang te krijgen tot een index die gelijk is aan de grootte van de array

4.3. StringIndexOutOfBoundsException

De Draad klasse in Java biedt de methoden om toegang te krijgen tot een bepaald teken van de tekenreeks of om een ​​tekenreeks uit de Draad. Wanneer we deze methoden gebruiken, converteert het intern de Draad in een tekenreeks.

Nogmaals, er kan een illegaal gebruik van indexen op deze array zijn. In dergelijke gevallen zijn deze methoden van de Draad klasse gooit de StringIndexOutOfBoundsException.

Deze uitzondering geeft aan dat de index groter is dan of gelijk is aan de grootte van de Draad.StringIndexOutOfBoundsException strekt zich uit IndexOutOfBoundsException.

De methode charAt (index) van de klas Draad genereert deze uitzondering wanneer we proberen toegang te krijgen tot een teken in de index gelijk aan de String's lengte of een andere illegale index:

String str = "Hallo wereld"; char charAtNegativeIndex = str.charAt (-1); // Proberen toegang te krijgen tot een negatieve index char charAtLengthIndex = str.charAt (11); // Proberen toegang te krijgen tot een index die gelijk is aan de grootte van de tekenreeks 

4.4. NumberFormatException

Vaak eindigt een applicatie met numerieke gegevens in een Draad. Om deze gegevens als numeriek te interpreteren, staat Java de conversie toe van Draad naar numerieke typen. De wrapper-klassen zoals Geheel getal, Float, etc. bevat hiervoor hulpprogramma's.

Echter, als het Draad heeft tijdens de conversie geen geschikt formaat, gooit de methode een NumberFormatException.

Laten we eens kijken naar het volgende fragment.

Hier verklaren we een Draad met alfanumerieke gegevens. Verder proberen we de methoden van de Geheel getal wrapper-klasse om deze gegevens als numeriek te interpreteren.

Dit resulteert dus in NumberFormatException:

String str = "100ABCD"; int x = Geheel getal.parseInt (str); // Gooit NumberFormatException int y = Integer.valueOf (str); // Gooit NumberFormatException

4.5. ArithmeticException

Wanneer een programma een rekenkundige bewerking evalueert en het resulteert in een uitzonderlijke toestand, gooit het ArithmeticException. Daarnaast, ArithmeticException geldt alleen voor int en lang gegevenstypen.

Als we bijvoorbeeld een geheel getal door nul proberen te delen, krijgen we een ArithmeticException:

int illegaleOperation = 30/0; // Gooit ArithmeticException

4.6. ClassCastException

Java maakt typecasting tussen de objecten mogelijk om overerving en polymorfisme te ondersteunen. We kunnen een object naar boven of naar beneden werpen.

Bij upcasting werpen we een object naar zijn supertype. En bij downcasting casten we een object naar een van zijn subtypen.

Echter, als de code tijdens runtime een object probeert te downcasten naar een subtype waarvan het geen instantie is, gooit de methode een ClassCastException.

De runtime-instantie is wat er echt toe doet bij typecasting. Beschouw de volgende erfenis tussen Dier, Hond en leeuw:

klas Dier {} klas Hond breidt Dier uit {} Klasse Leeuw breidt Dier uit {} 

Verder casten we in de chauffeursklasse de Dier referentie met een exemplaar van Leeuw in een Hond.

Tijdens de runtime merkt de JVM dat exemplaar echter op Leeuw is niet compatibel met het subtype van de klas Hond.

Dit resulteert in ClassCastException:

Dierlijk dier = nieuwe leeuw (); // Tijdens runtime is de instantie Lion Dog tommy = (Dog) animal; // Gooit ClassCastException

4.7. IllegalArgumentException

Een methode gooit een IllegalArgumentException als we het noemen met een aantal illegale of ongepaste argumenten.

Bijvoorbeeld de slaap() methode van de Draad klasse verwacht een positieve tijd en we geven een negatief tijdsinterval als argument door. Dit resulteert in IllegalArgumentException:

Thread.currentThread (). Sleep (-10000); // Gooit IllegalArgumentException

4.8. IllegalStateException

IllegalStateException geeft aan dat een methode is gebruikt op een illegaal of ongepast moment.

Elk Java-object heeft een toestand (instantievariabelen) en een bepaald gedrag (methoden). Dus, IllegalStateException betekent dat het illegaal is om het gedrag van dit object aan te roepen met de huidige toestandsvariabelen.

Met enkele verschillende toestandsvariabelen kan het echter legaal zijn.

We gebruiken bijvoorbeeld een iterator om een ​​lijst te herhalen. Telkens wanneer we er een initialiseren, stelt deze intern zijn statusvariabele in lastRet tot -1.

Met deze context probeert het programma het verwijderen methode op de lijst:

// Geïnitialiseerd met index op -1 Iterator intListIterator = nieuwe ArrayList (). Iterator (); intListIterator.remove (); // IllegalStateException 

Intern is het verwijderen methode controleert de statusvariabele lastRet en als het kleiner is dan 0, wordt gegooid IllegalStateException. Hier wijst de variabele nog steeds naar de waarde -1.

Als resultaat krijgen we een IllegalStateException.

5. Conclusie

In dit artikel hebben we eerst besproken wat uitzonderingen zijn. Een uitzondering is een gebeurtenis die optreedt tijdens de uitvoering van een programma en die de normale stroom van de programma-instructies verstoort.

Vervolgens hebben we de uitzonderingen gecategoriseerd in de gecontroleerde uitzonderingen en de niet-gecontroleerde uitzonderingen.

Vervolgens hebben we verschillende soorten uitzonderingen besproken die kunnen optreden tijdens het compileren of tijdens de runtime.

We kunnen de code voor dit artikel vinden op GitHub.