PowerPoint-presentatie

Hoofdstuk 15:
Exception Handling
JAVA -- H15
1
1. Inleiding
Exception:
• ongewone of foutieve situatie, bv. delen door nul bij het
werken met gehele getallen -> console-applicatie mislukt ;
applet geeft fout in het console-venster ; GUI-applicatie kan
eveneens verder gezet worden, maar ze verkeren in een
onstabiele toestand-> kunnen verkeerde resultaten geven
• kan onderschept en afgehandeld worden.
• = een object van de klasse Throwable, gegenereerd
door de programmeur, een bibliotheekmethode (bv.
parseInt) of door het systeem, d.m.v. een throw-opdracht
vb. throw new NumberFormatException()
JAVA -- H15
2
2. Exception handling - overzicht

Gebruikmaken van exception handling



Wanneer een methode zijn taak niet kan
voltooien.
Wanneer componenten van een programma
niet in staat zijn om de exceptions die
optreden onmiddellijk af te handelen.
Om exceptions op een uniforme wijze af te
handelen in grote projecten.
JAVA -- H15
3
2. Exception handling – overzicht (vervolg)
Mogelijke oplossingen:
• helemaal niets, geen speciale code in het programma ->
systeemfoutboodschap (1)
• afhandeling op de plaats waar de fout optreedt (duidelijk
en vlugger) -> try-catch-finally-statement (2)
• afhandeling op een andere plaats -> impliciete of
expliciete exception propagation (3)
JAVA -- H15
4
2. Exception handling – overzicht (vervolg)
Voorbeeld: systeemfoutboodschap (1)
public class Zero
{ public static void main(String[] args)
{ int teller = 10, noemer = 0;
System.out.println( teller / noemer);
}
} -> SYSTEEMFOUTBOODSCHAP:
java.lang.ArithmeticException: / by zero
at Zero.main (Zero.java:4)
JAVA -- H15
5
2. Exception handling – overzicht (vervolg)
try-catch-finally-statement (2):
• alle instructies waarin zich fouten kunnen voordoen
en alle instructies die niet mogen uitgevoerd worden
wanneer een exception optreedt : try-block
• als er een fout optreedt in het try-block, dan wordt
er een instantie van een exception-class gemaakt en
deze kan opgevangen worden in 0 of meerdere
catch-blocks; elk verwerkt een bepaald soort fout:
catch-block
• code die hoe dan ook moet uitgevoerd worden (bv.
vrijgeven van resources) : finally-block [optioneel]
JAVA -- H15
6
2. Exception handling – overzicht (vervolg)


Het try-catch-finally statement:
try
{ // code dat mag falen
}
catch (Exception e)
{ // afhandelen Exception
// meerdere catchers mogelijk
}
[finally
{
// code die altijd uitgevoerd wordt
}]
Let op:
1. in een catch-blok kan je geen gebruikmaken van objecten gedeclareerd in
het corresponderende try-blok!
7
2. Tussen de catchers en het try-blok kan geen andere code staan!
Voorbeeld 1
try
{ int a[]= new int[2];
a[5] = 1;
}
catch(ArrayIndexOutOfBoundsException fout)
{ System.out.println(“Fout:” + fout );}
JAVA -- H15
8
Voorbeeld 2: 2 getallen inlezen, som berekenen
import java.io.*;
public class Som
{ public static void main( String[] args)
{ int get1 = Gebruiker_Lees.getInteger("Geef een getal: ");
int get2 = Gebruiker_Lees.getInteger("Geef een 2°getal: ");
System.out.println("Som = " + (get1 + get2));
}
}
JAVA -- H15
9
class Gebruiker_lees
{ public static int getInteger(String prompt)
{ BufferedReader stdin = new BufferedReader
(new InputStreamReader(System.in));
int getal = 0;
boolean geldig = false;
while (! geldig)
{ System.out.print(prompt); //geen nieuwe lijn
System.out.flush();
JAVA -- H15
10
try
{ getal = Integer.parseInt(stdin.readLine());
geldig = true; // uit de lus!
}
catch (NumberFormatException exception)
{ System.out.println("Ongeldige invoer. Opnieuw!"); }
catch (IOException exception) // de meest algemene class
// aan het eind zetten
{ System.out.println("Invoerprobleem. Stop!");
System.exit(0);
}
}// einde while-lus
return getal;
}// einde functie
}
JAVA -- H15
11
Voorbeeld 2 : Eenvoudiger oplossing voor input met
swing-functies
import javax.swing.*;
class Gebruiker_lees
{ public static int getInteger(String prompt)
{ int getal = 0;
boolean geldig = false;
String input;
while (! geldig)
{ input = JOptionPane.showInputDialog(prompt);
enz...
JAVA -- H15
12
Voorbeeld 3: een geheel getal ingeven in een
tekstvak en de dubbele waarde tonen in een
ander tekstvak na een enterhit
public class ExceptionDemo extends JApplet
implements ActionListener
{
private JTextField invoerVak;
private JTextField resultaat;
private JLabel resultLabel, tekstLabel;
JAVA -- H15
13
public void init()
{
Container c = getContentPane(); c.setLayout(new FlowLayout());
tekstLabel = new JLabel("Geef een geheel getal: ");
resultLabel = new JLabel("Antwoord ");
invoerVak = new JTextField(20);
resultaat = new JTextField(30);
resultaat.setEditable(false); // niet wijzigen!
c.add(tekstLabel); c.add(invoerVak);
invoerVak.addActionListener(this); // enterhit!
c.add(resultLabel); c.add(resultaat);
}
JAVA -- H15
14
public void actionPerformed (ActionEvent event)
{ if (event.getSource() == invoerVak)
{ try
{ int getal = Integer.parseInt(invoerVak.getText());
resultaat.setText("Verdubbelde waarde is " + (2 * getal));
}
catch (NumberFormatException e)
{ resultaat.setText("Fout in getal: herbegin "); }
finally {invoerVak.setText(""); invoerVak.requestFocus(); }
} // einde if
} // einde actionPerformed
} // einde klasse
JAVA -- H15
15
2. Exception handling – overzicht (vervolg)
• Het throw statement (expliciet of impliciet)
– duidt aan dat er een exception is voorgekomen
– de operand kan van elke klasse zijn die afgeleid is van de klasse
Throwable
• Subklassen van Throwable
– Class Exception
•Problemen die opgevangen moeten worden -> programma
robuster!
– Class Error
•Ernstige exceptions, die niet moeten opgevangen worden
• Wanneer een exception optreedt in een try block, dan wordt deze blok
verlaten (zelfs als het throw punt in een geneste blok zit) en wordt
verdergegaan met het corresponderende catch block
JAVA -- H15
16
2. Exception handling – overzicht (vervolg)
• Een catch-blok handelt een bepaalde soort exceptie af.
• Elk catch-blok start met het keyword catch, gevolgd door
een parameterlijst met één parameter, die aangeeft welk soort
exceptie kan opgevangen worden.
• Het programma stopt als er geen geschikte handler is.
• Eén catcher kan meerdere exceptions afhandelen:
catch (Exception e) { // ….} // “catch-all” handler
JAVA -- H15
17
2. Exception handling – overzicht (vervolg)
• De eerste catcher na een try-blok die overeenkomt met het
exception-type wordt uitgevoerd; alle andere worden
genegeerd!
• Zet nooit een catcher van een superklasse object vóór een
catcher van een subklasse object!
• Een exception kan op verschillende wijzen afgehandeld
worden.
• Het is niet mogelijk om nog terug te keren naar het throw
punt!
JAVA -- H15
18
2. Exception handling – overzicht (vervolg)
impliciete of expliciete exception propagation (3):
• een throws-clausule in een methode-definitie geeft aan welke
exceptions de methode gooit; deze clausule staat achter de
parameterlijst en voor de body van de methode; meerdere
soorten worden gescheiden door komma’s:
void f(int x) throws IOException, NumberFormatException
{ // …}
• dergelijke exceptions kunnen gegooid worden door statements
in de methode-body of door methoden die in de body
aangeroepen worden = throw punt
JAVA -- H15
19
2. Exception handling – overzicht (vervolg)
De throws-clausule
• Algemeen :
returntype functionName( paramterList ) throws
ExceptionType1, ExceptionType2,…
{
// method body
}
• Deze methode kan zowel objecten van de aangegeven klassen
gooien als objecten van hun subklassen!
• het is niet noodzakelijk om alle exceptions en errors, die door de
methode kunnen gegooid worden, in de lijst op te nemen!
JAVA -- H15
20
2. Exception handling – overzicht (vervolg)
•Errors en unchecked RuntimeExceptions moeten niet
expliciet gepropageerd worden d.m.v. een throws-clausule!
–ArrayIndexOutOfBoundsException
–NullPointerException, …
• Alle checked exceptions moeten in de throws-clausule
voorkomen, m.a.w. ze moeten expliciet gepropageerd
worden!
• Wanneer we een methode met throws-clausule uit de
superklasse in een subklasse opnieuw definiëren, dan moet
deze nieuwe versie dezelfde lijst van excepties hebben of
een deelverzameling van de lijst!
JAVA -- H15
21
3. Voorbeeld : de exceptie “delen door 0”
afhandelen
• Standaard gooit Java een exception van de klasse
ArithmeticException wanneer er door nul wordt gedeeld bij
integers! Delen door nul is in Java toegelaten bij floatingpoint variabelen.
• In het volgende voorbeeld wensen we echter de gebruiker
van ons programma er op te wijzen dat hij door nul probeert
te delen (ook bij floating-point)!
• Het systeem gooit een exceptie, wanneer we door nul
delen bij integers.
JAVA -- H15
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Fig. 15.1: DivideByZeroTest.java
// Controle op een divide-by-zero-error.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
8. Voorbeeld : de exceptie “delen door 0”
afhandelen (2)
public class DivideByZeroTest extends JFrame implements ActionListener
{
private JTextField inputField1, inputField2, outputField;
private int number1, number2, result;
// set up GUI
public DivideByZeroTest()
{
super( "Demonstrating Exceptions" );
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( new GridLayout( 3, 2 ) );
// set up label and inputField1
container.add( new JLabel( "Enter numerator ", SwingConstants.RIGHT ) );
inputField1 = new JTextField( 10 );
container.add( inputField1 );
JAVA -- H15
23
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// set up label and inputField2; register listener
container.add( new JLabel( "Enter denominator and press Enter ", SwingConstants.RIGHT ) );
inputField2 = new JTextField( 10 );
container.add( inputField2 );
inputField2.addActionListener( this );
8. Voorbeeld : de exceptie “delen door 0”
afhandelen (2)
// set up label and outputField
container.add( new JLabel( "RESULT ", SwingConstants.RIGHT ) );
outputField = new JTextField();
container.add( outputField );
setSize( 425, 100 );
setVisible( true );
} // einde constructor
// process GUI events
public void actionPerformed( ActionEvent event )
{
outputField.setText( "" ); // clear outputField
// read two numbers and calculate quotient
try {
number1 = Integer.parseInt( inputField1.getText() );
number2 = Integer.parseInt( inputField2.getText() );
result = quotient( number1, number2 );
outputField.setText( String.valueOf( result ) );
}
JAVA -- H15
24
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
// de catcher die uitgevoerd wordt, wanneer de input van een verkeerd formaat is
catch ( NumberFormatException numberFormatException )
{
JOptionPane.showMessageDialog( this, "You must enter two integers",
"Invalid Number Format",JOptionPane.ERROR_MESSAGE );
}
8. Voorbeeld : de exceptie “delen door 0”
afhandelen (2)
// de catcher die uitgevoerd wordt, wanneer er door nul wordt gedeeld
catch ( ArithmeticException arithmeticException )
{ JOptionPane.showMessageDialog( this, arithmeticException.toString(),
"Arithmetic Exception", JOptionPane.ERROR_MESSAGE );
}
}
// methode quotient gooit een exceptie wanneer een divide-by-zero error optreedt
public int quotient( int numerator, int denominator ) throws ArithmeticException
{
return numerator / denominator;
}
JAVA -- H15
25
81
82
83
84
85
86
87
88
89 }
// execute application
public static void main( String args[] )
{
DivideByZeroTest application = new DivideByZeroTest();
8. Voorbeeld : de exceptie “delen door 0”
afhandelen (2)
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
// end class DivideByZeroTest
JAVA -- H15
26
4. Java Exception Hiërarchie
•Exception: kan onderschept en afgehandeld worden.
•Error kan niet hersteld worden (interne fouten in de run-time omgeving
van JVM)
Klassenhiërarchie van de belangrijkste errors en exceptions:
Throwable (= superklasse)
Error (unchecked)
LinkageError
NoClassDefFoundError
IncompatibleClassChangeError
NoSuchFieldError,….
VirtualMachineError
OutOfMemoryError
StackOverflowError,….
JAVA -- H15
27
4. Java Exception Hiërarchie (vervolg)
Exception (allemaal checked, behalve RunTimeException)
RunTimeException (unchecked)
NullPointerException
ArithmeticException
IndexOutOfBoundsException
ArrayIndexOutOfBoundsException
IllegalArgumentException
NumberFormatException
IOException (checked)
FileNotFoundException
MalformedURLException
InterruptedException (checked)
JAVA -- H15
28
4. Java Exception Hiërarchie (vervolg)

Unchecked (RuntimeException, Error)





Worden niet gecontroleerd door de compiler.
Kan overal in de code voorkomen, deze altijd
afhandelen is onmogelijk.
Je kan ze afhandelen als je dat wil!
Geven een fout aan in het programma.
Checked (al de andere)


Worden gecontroleerd door de compiler.
Moeten afgehandeld worden!
JAVA -- H15
29
Oefening 1
Schrijf een applicatie die een temperatuur in
Fahrenheit omzet in een temperatuur in Celsius. De
temperatuur in Fahrenheit wordt via het toetsenbord
ingevoerd (JTextField). Via een JLabel wordt de
geconverteerde temperatuur afgedrukt.
Zorg ervoor dat een foutieve input (= niet numeriek,
buiten de grenzen van het interval [-10°C,40°C])
wordt gemeld met een duidelijke foutboodschap in
een dialoogvenster. Wanneer dit venster wordt
gesloten, moet het inputveld terug leeg zijn en moet
de cursor in dit veld staan wachten. Handel de fouten
ter plaatse af!
JAVA -- H15
30
5. De exceptie opnieuw gooien
Gooi de exceptie opnieuw, als de catch deze niet kan
afhandelen of deze wil doorgeven aan een andere catcher:
throw exceptionReference;
Een dergelijk statement gooit de exceptie naar de volgende
try-blok en deze wordt afgehandeld door een exception
handler na dit blok.
JAVA -- H15
31
6. Het finally-blok
•Resource leak
–Noodzakelijk wanneer resources niet vrijgegeven worden
door een programma. Bijvoorbeeld het sluiten van files
geopend in de try-blok.
•De finally blok
–Staat altijd achter alle catch blokken.
–Wordt ALTIJD uitgevoerd.
–Wordt gebruikt om resources terug vrij te geven.
JAVA -- H15
32
6. Het finally-blok (2)
• definieert de verplichte uitvoering van een stukje code
• meestal gebruikt om bv. bestanden e. d. af te sluiten
indien er zich een foutsituatie heeft voorgedaan
• mogelijke situaties:
> als er in een try-blok GEEN fout optreedt, wordt
nadien het finally-blok uitgevoerd, zelfs als er in het tryblok een return of break staat
> als er een fout optreedt in het try-blok, die niet kan
opgevangen worden, dan wordt eerst het finally-blok
uitgevoerd en vervolgens wordt de fout gepropageerd
JAVA -- H15
33
6. Het finally-blok (3)
> de fout die zich voordoet in het try-blok, wordt opgevangen in het
catch-blok en vervolgens wordt het finally-blok uitgevoerd:
String regel;
try { while ((regel = mijnBestand.readLine()) != null)
{
// verwerk regel
}
}
catch (IOException e)
{
errorField.setText("Fout in invoerbestand");}
finally
{ mijnBestand.close();}
JAVA -- H15
34
Voorbeeld
Gebruik van een finally-blok
JAVA -- H15
35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Fig. 15.3: UsingExceptions.java
// Demonstratie van try-catch-finally
// exception handling mechanisme.
public class UsingExceptions
{
// uitvoeren application
public static void main( String args[] )
{
// methode throwException aanroepen
try {
throwException();
}
13. Het finally blok
•Resource leak
–Caused when resources are not released by a program
// catch Exceptions gegooid door de methode throwException
catch ( Exception exception )
{
System.err.println( "Exception handled in main" );
}
•The finally block
–Appears after catch blocks
–Always executes
–Use to release resources
doesNotThrowException();
}
// demonstratie van try/catch/finally
public static void throwException() throws Exception
{
// gooi een exceptie en catch het onmiddellijk
try {
System.out.println( "Method throwException" );
throw new Exception(); // generate exception
}
JAVA -- H15
36
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// catch exception gegooid in try block
catch ( Exception exception )
{
System.err.println(
"Exception handled in method throwException" );
throw exception; // gooi opnieuw voor verdere uitvoering
// elke code die hier staat wordt nooit bereikt!
}
13. Het finally blok
// dit blok wordt uitgevoerd, ongeacht wat in try/catch staat
finally {
System.err.println( "Finally executed in throwException" );
}
// elke code die hier staat wordt nooit bereikt!
•Resource leak
–Caused when resources are not released by a program
•The finally block
}
–Appears after catch blocks
// finaal, demonstratie wat er gebeurt als er geen exceptie optreedt
public static void doesNotThrowException()
{
// try block gooit geen exceptie
try {
System.out.println( "Method doesNotThrowException" );
}
–Always executes
–Use to release resources
// catch wordt niet uitgevoerd, want er wordt geen exceptie gegooid
catch( Exception exception )
{
System.err.println( exception.toString() );
}
JAVA -- H15
37
66
// dit blok wordt uitgevoerd ongeacht wat er gebeurt in de try/catch
67
finally {
68
System.err.println("Finally executed in doesNotThrowException" );
69
}
70
71
System.out.println( "End of method doesNotThrowException" );
72
}
73
74 } // einde class UsingExceptions
13. Het finally blok
Method throwException
Exception handled in method throwException
Finally executed in throwException
Exception handled in main
Method doesNotThrowException
Finally executed in doesNotThrowException
End of method doesNotThrowException !
JAVA -- H15
Output v/h programma
38
7. Stack Unwinding
• wanneer een exception wordt gegooid, maar niet onmiddellijk wordt
afgehandeld in een bepaalde methode, dan wordt deze methode
beëindigd (alle lokale vaiabelen worden vernietigd) en er wordt
teruggekeerd naar de caller van de methode = “unwinding van de
methode-call stack”
• staat de caller binnen een try-blok, dan wordt de fout afgehandeld
• staat de caller niet in een try-blok, dan krijgen we terug een stack
unwinding; uiteindelijk, als er geen gepaste catcher is, wordt het
programma beëindigd
JAVA -- H15
39
Voorbeeld 1
Demonstratie van “stack-unwinding”
JAVA -- H15
40
1
2
// Fig. 15.4: UsingExceptions.java
// Demonstratie van de “stack-unwinding”.
3
4
5
6
7
8
public class UsingExceptions
{
// uitvoeren application
public static void main( String args[] )
{
// roep de methode throwException om de “stack-unwinding” te demonstreren
9
10
11
12
13
14
15
16
17
13. Het finally blok
try {
throwException();
}
// catch exception gegooid in throwException
catch ( Exception exception )
{ System.err.println( "Exception handled in main" );
}
}
JAVA -- H15
41
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41 }
// throwException gooit een exceptie die niet wordt opgevangen in
// de body van deze methode
public static void throwException() throws Exception
{
// gooit een exceptie, die in main wordt opgevangen
try {
System.out.println( "Method throwException" );
throw new Exception();
// genereert een exception
}
13. Het finally blok
// de catcher is van een incorrect type, dus de Exceptie wordt niet opgevangen
catch( RuntimeException runtimeException )
{
System.err.println( "Exception handled in method throwException" );
}
// finally block wordt altijd uitgevoerd
finally
{
System.err.println( "Finally is always executed" );
}
}
// einde class UsingExceptions
Method throwException
Finally is always executed
Exception handled in main
Output v/h programma
JAVA -- H15
42
Voorbeeld 2
Demonstratie van “stack-unwinding”
JAVA -- H15
43
4 Indien nergens iets voorzien
wordt, komen we bij de main
en stopt het programma met
een foutmelding
main
3
De exception
volgt de weg
terug.
2
methodeY throws
de exception
methodeA
methodeX
methodeY
1 In methodeY doet zich een
exception voor
JAVA -- H15
44
Voorbeeld (1)
class Propagation_Demo
{ public static void main(String[] args)
{ Exception_Scope demo = new Exception_Scope();
System.out.println("Begin van het programma");
demo.level1();
System.out.println("Einde van het programma");
}
}
JAVA -- H15
45
Voorbeeld (2)
class Exception_Scope
{
public void level3(int adjustment)
{ int huidig = 1;
System.out.println(" start level3 ");
huidig = huidig / adjustment;
System.out.println(" einde level3 ");
}
JAVA -- H15
46
Voorbeeld (3)
public void level2()
{
System.out.println(" start level2 ");
level3(0);
System.out.println(" einde level2 ");
}
JAVA -- H15
47
Voorbeeld (4)
public void level1()
{ System.out.println(" start level1 ");
try
{ level2(); }
catch (ArithmeticException probleem)
{System.out.println(probleem.getMessage());
probleem.printStackTrace();
}
System.out.println(" einde level1 ");
} }
JAVA -- H15
48
Uitvoer voorbeeld
JAVA -- H15
49
8. printStackTrace, getStackTrace en
getMessage
•Methode printStackTrace
- Geeft op de standaard outputstream een foutboodschap met
* de klassenaam van de exceptie
* de beschrijvende string, die bewaard wordt in het exceptie-object
* een lijst van methodes die niet volledig uitgevoerd werden, wanneer
de exceptie gegooid werd ( = de methode call stapel) met telkens het
lijnnummer die het throw-punt aangeeft
•Methode getStackTrace
- Deze methode kunnen we gebruiken om de stack-trace informatie naar
een andere stream dan de standaard outputstream te sturen. De informatie wordt opgeslaan in een array van de klasse StackTraceElement.
JAVA -- H15
50
8. printStackTrace, getStackTrace en
getMessage (vervolg)
•Methode getMessage
Methode getMessage geeft een informatieString terug, die
via de constructor van de klasse Throwable meegegeven kan worden.
•Methode toString van de klasse Throwable
Geeft een string terug, die de naam van de klasse bevat ( = soort
exception) en een beschrijvende boodschap, die het probleem weergeeft.
JAVA -- H15
51
Voorbeeld
Demonstratie van de methoden
getMessage, getStackTrace en
printStackTrace
JAVA -- H15
52
1
2
3
// Fig. 15.5: UsingExceptions.java
// Demonstratie van de methoden getMessage en printStackTrace
// methoden die geërfd worden in alle exceptie klassen.
4 public class UsingExceptions
5 {
6
// uitvoeren application
7
public static void main( String args[] )
8
{
9
// call methode1
10
try {
11
method1();
12
}
13
14
// catch excepties gegooid door methode1
15
catch ( Exception exception )
16
{ System.err.println( exception.getMessage() + "\n" );
17
exception.printStackTrace();
18
19
// verkrijg de stacktrace informatie
20
StacktraceElement[] traceElements = exception.getStackTrace();
21
System.out.println(“\nStack Trace from getStackTrace: “);
22
System.out.println(“Class\t\tFile\t\tLine\tMethod”);
14. Gebruikmaken van printStackTrace en
getMessage
•Method printStackTrace
–Prints the method call stack
•Throwable class
–Method getMessage retrieves informationString
23
24
25
26
27
28
29
30
31
for (int i = 0; i < traceElements.length;i++)
{
StackTraceElement currentElement = traceElements[i];
System.out.print(currentElement.getClassName() + “\t”);
System.out.print(currentElement.getFileName() + “\t”);
System.out.print(currentElement.getLineNumber() + “\t”);
System.out.print(currentElement.getMethodName() + “\n”);
}
} // einde catch
} // einde main
JAVA -- H15
53
// call
32
33
34
35
36
37
38
39
40
41
methode2; gooi de excepties terug naar main
public static void method1() throws Exception
{
method2();
}
42
43
44
45
46
47
48 }
// call methode3; gooi de excepties terug naar methode1
public static void method2() throws Exception
{
method3();
}
// gooi de Exceptie terug naar methode2
public static void method3() throws Exception
{
throw new Exception( "Exception thrown in method3" );
}
// einde class Using Exceptions
JAVA -- H15
54
Merk op :
- elk element van de StackTraceElement-array bevat een methode-call
- de stack-trace-informatie is gelijk bij printStackTrace en getStackTrace
JAVA -- H15
55
9. Geketende (“chained”) exceptions
• Normaal vangt een catcher één soort fout op en handelt
deze af. De catcher kan vervolgens een ander soort fout
gooien, om aan te geven dat een programma-specifieke
exceptie voorgekomen is.
• Vroeger was het niet mogelijk om de informatie van de
eerste exceptie te koppelen aan de boodschap van de
nieuwe exceptie. Men kon geen complete stack-trace tonen,
om aan te geven waar de fout uiteindelijk vandaan kwam.
• Vanaf versie 1.4 is dit wel mogelijk, via “chained”
exceptions.
JAVA -- H15
56
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Fig. 15.6: UsingChainedExceptions.java
// Demonstratie van chained exceptions
public class UsingChainedExceptions
{
public static void main( String args[] )
{
try {
method1(); // call method1
}
// catch excepties gegooid door methode1
catch ( Exception exception )
–Prints the method call stack
{ exception.printStackTrace();
}
}
–Method
getMessage
// call
methode2; gooi
de excepties terugretrieves
naar main informationString
public static void method1() throws Exception
{
try
{ method2();
}
catch (Exception exception)
{ throw new Exception(“Exception gegooid in methode1”,exception);
14. Gebruikmaken van printStackTrace en
getMessage
•Method printStackTrace
•Throwable class
}
}
JAVA -- H15
57
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41 }
// call methode3; gooi de excepties terug naar methode1
public static void method2() throws Exception
{
try
{ method3();
}
catch (Exception exception)
{ throw new Exception(“Exception gegooid in methode2”,exception);
}
}
// gooi de Exceptie terug naar methode2
public static void method3() throws Exception
{
throw new Exception( "Exception gegooid in method3" );
}
// einde class UsingChainedExceptions
Vanaf J2SE 1.4 heeft de klasse Exception een
constructor met twee parameters! Het tweede
argument is de exceptie, die het originele probleem
vertegenwoordigt.
JAVA -- H15
58
De meest recente exceptie, die gegooid werd.
JAVA -- H15
59
10. Nieuwe exceptie-types declareren
• Wanneer we een eigen exceptieklasse ontwerpen, dan
moet deze afgeleid zijn van een Java API exceptieklasse
(eventueel Exception)!
• Een typische exceptieklasse bevat enkel twee
constructoren, één constructor zonder argument welke een
default exceptieboodschap specifieert en een constructor
met één argument, die een foutboodschap ontvangt als een
String.
JAVA -- H15
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// DivideByZeroException.java
// Definitie van de class DivideByZeroException.
// Wordt
om een exceptie
gooien wanneer
een
8.gebruikt
Voorbeeld
: deteexceptie
“delen
door
// deling door nul voorkomt.
afhandelen (2)
public class DivideByZeroException extends ArithmeticException
{
// constructor zonder argument, specifieert de default error message
public DivideByZeroException()
{
super( "Attempted to divide by zero" );
}
0”
// constructor met een parameter
public DivideByZeroException( String message )
{
super( message );
}
} // end class DivideByZeroException
JAVA -- H15
61
11. Constructoren en exception handling
Wanneer er een fout in de constructor gedetecteerd
wordt, is het aan te raden om deze via een throw te gooien
naar de code die het object wenst te creëren.
Het throw-statement zal het soort fout identificeren.
Bijgevolg kan de exceptie op een correcte manier worden
afgehandeld.
JAVA -- H15
62
Oefening 2
Herneem oefening 1.
Een niet-numerieke invoer handelen we nog altijd ter
plaatse af. Alle numerieke invoer wordt in eerste
instantie aanvaard, maar in de set-methode() van de
klasse Thermometer moet op de waarde
gecontroleerd worden. Blijkt de waarde buiten het
interval te vallen, dan moet de set-methode() een
exceptie teruggooien. Deze wordt dan zoals in oef1
afgehandeld.
JAVA -- H15
63