JAVA Deel 5 (Exceptions basis)
1. Inleiding
2. Try Catch
3. Finally en geneste Try blocks
 top
1. Inleiding
Deze tutorial handelt over foutafhandeling bij JAVA.
Dit houd in dat, mocht er een fout tijdens de applicatie optreden, deze niet direct word weergegeven via een slordige error, maar word omzeild.
Je vangt de fout als het ware op, en veranderd iets aan je applicatie zodat het nog altijd kan verdergaan en geeft ondertussen een mooie error.
Een leuk voorbeeld hiervan is bijvoorbeeld bij Photoshop (dit is niet met JAVA geschreven, maar om toch een voorbeeld te geven).
Als je de opacity boven de 100 zet dan geeft hij een error. Normaal gezien als je deze error niet had ingebouwt zou de applicatie afsluiten.
Dit zou het einde van je applicatie betekenen, of ambetante procedures die zich voordoen.
Zoals ik net zij kan je dus met JAVA de fout opvangen, dat ga ik hier bespreken.
2. Try Catch
Als je weet dat er een kritiek stuk code komt, dit houd in: een code waar een fout kan optreden, ga je het programma laten 'proberen' de code uit te voeren.
Dit gebeurt via het statement try.
Je zal dit bijvoorbeeld gebruiken bij invoer, als je een integer wil laten invoeren en de gebruiker vult een string in.
Als alles lukt dan gaat de code verder, als dit niet lukt ga je via de het 'catch' statement de fout opvangen (to catch) en er mee doen wat je wilt.
Even om met een voorbeeld te illustreren.
import java.io.*;
public class foutafhandeling {
public static void main(String[] args) throws IOException {
String sLeeftijd;
int iLeeftijd;
BufferedReader toetsenbord = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Geef je leeftijd in");
sLeeftijd = toetsenbord.readLine();
//conrole of leeftijd een geheel getal bevat of niet
try {
iLeeftijd = Integer.parseInt(sLeeftijd);//kan ook via Double.parseDouble of Float.parseFloat
}
catch (NumberFormatException nfe) {
//de numerieke waarde (numberformat) klopt niet
System.out.println("Err: leeftijd bevat geen numerieke waarde");
}
}
}
|
Zoals je ziet is het eigenlijk niet zo ingewikkeld. Je voert een leeftijd in, en probeert deze om te zetten naar een integer.
Mocht je dit doen zonder try dan zou hij een numberformatexception geven. Deze vang je op in de variabele nfe, en je geeft een 'eigen' error weer.
3. Finally en geneste Try blocks
Na de opvanging van een exception (via catch) kan je via finally een statement laten uitvoeren. Dit statement word ALTIJD uitgevoerd.
Je kan geen try statement op zichzelf hebben, je hebt altijd een catch nodig (voor de fout op te vangen) of een finally (om een code uit te voeren).
Een klein voorbeeld om dit te ilustreren lijkt me wel gepast.
import java.io.*;
public class exceptionFinally {
public static void main( String argumenten[] ) throws IOException {
BufferedReader toetsenbord = new BufferedReader(new InputStreamReader(System.in)); //input
try {
System.out.println("De eerste blok: try");
String gegevens = toetsenbord.readLine();
int gegs = Integer.parseInt( gegevens );
}
catch( NumberFormatException ex ) {
System.out.println("De tweede blok: catch");
System.out.println("U moet een integer ingeven");
}
finally{
System.out.println("De laatste blok: finally");
}
}
}
|
Als je het programma compileert en uitvoert zal het eerst string 'De eerste blok: try' weergeven. Vervolgens kan je een gegeven invoeren.
Als je een integer invoert zal het direct overspringen naar de finally blok en dit weergen: 'De laatste blok: finally'.
Als je echter een variabele van een ander type ingeeft (double, string, ...).
Dan gaat hij over naar de catch blok en geeft hij dit weer: 'De tweede blok: catch' 'U moet een integer ingeven' en dan de finally blok.
Er zijn vele soorten Exceptions, deze kan je opzoeken door te experimenteren. Als je tijdens het runnen van je programma plots een exception message krijgt, dan vang je deze op, door deze te kopieren en te plaats bij de catch() blok. Je kan dus bv meerdere catch blocks hebben. Iets in de aard van:
try {
//proberen
}
catch( ExceptionType1 ex ) {
//error geven over exception van type1
}
catch( ExceptionType2 ex ) {
//error geven over exception van type2
}
|
Zo kan je ook geneste Try blocks hebben. Een try block in een try block, of een catch block of een finally block.
Een voorbeeld hiervan is een rekenmachine. Je laat een getal invoeren (dit is een integer, goed! doorgaan).
Dan vraag je welke berekening => een deling.
Verdergaan, dan vraag je door welk getal. Nu kan de gebruiker 2 verschillende fouten maken: een string ingeven of 0 ingeven.
2 exceptions die je moet opvangen. Dan kan je dit met 2 catches achter elkaar doen, of een geneste try block.
<?php import java.io.*;
public class exceptionReken {
public static void main( String argumenten[] ) throws IOException {
BufferedReader toetsenbord = new BufferedReader(new InputStreamReader(System.in)); //input
int getal1;
int getal2 = 1; //voor compile errors te voorkomen, de waarde word toch direct veranderd door de input
double deling;
try {
System.out.println( "Geef het eerste getal?" );
getal1 = Integer.parseInt( toetsenbord.readLine() );
try {
System.out.println( "Geef het tweede getal?" );
getal2 = Integer.parseInt( toetsenbord.readLine() );
}
catch( NumberFormatException ex ) {
System.out.println( "Getal 2 moet geheel zijn" );
}
try {
deling = getal1 / getal2;
}
catch( ArithmeticException ex2 ) {
//een exception die wiskundige condities juist probeert na te streven, een vb. is de deling door 0
System.out.println( "Kan niet delen door 0" );
}
}
catch( NumberFormatException ex3 ) {
System.out.println( "Getal 1 moet geheel zijn" );
}
}
}
|
Dit was het dan voor deze keer.
Enkele toepassingen met JAVA zijn bv. JSP, meer info daarover: JSP Tutorials
top
|
Wat is jouw favoriete javascript framework? (S: 18, R: 2)
(4.57) 
Lees de nota's (0)