Hoofdstuk 15: Exception Handling JAVA -- H15.

Presentatie over: "Hoofdstuk 15: Exception Handling JAVA -- H15."— Transcript van de presentatie:

1 Hoofdstuk 15: Exception Handling JAVA -- H15

2 kan onderschept en afgehandeld worden.
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

3 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

4 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

5 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

6 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

7 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! 2. Tussen de catchers en het try-blok kan geen andere code staan!

8 catch(ArrayIndexOutOfBoundsException fout)
Voorbeeld 1 try { int a[]= new int[2]; a[5] = 1; } catch(ArrayIndexOutOfBoundsException fout) { System.out.println(“Fout:” + fout );} JAVA -- H15

9 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

10 { public static int getInteger(String prompt)
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

11 { getal = Integer.parseInt(stdin.readLine());
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

12 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

13 public class ExceptionDemo extends JApplet implements ActionListener {
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

14 { Container c = getContentPane(); c.setLayout(new FlowLayout());
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

15 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

16 Het throw statement (expliciet of impliciet)
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

17 Een catch-blok handelt een bepaalde soort exceptie af.
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

18 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

19 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

20 De throws-clausule 2. Exception handling – overzicht (vervolg)
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

21 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

22 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 floating-point 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

23 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2)
1 // Fig. 15.1: DivideByZeroTest.java 2 // Controle op een divide-by-zero-error. 3 4 import java.awt.*; 5 import java.awt.event.*; 6 import javax.swing.*; 7 8 public class DivideByZeroTest extends JFrame implements ActionListener 9 { private JTextField inputField1, inputField2, outputField; private int number1, number2, result; 12 // set up GUI public DivideByZeroTest() { super( "Demonstrating Exceptions" ); 17 // get content pane and set its layout Container container = getContentPane(); container.setLayout( new GridLayout( 3, 2 ) ); 21 // set up label and inputField1 container.add( new JLabel( "Enter numerator ", SwingConstants.RIGHT ) ); inputField1 = new JTextField( 10 ); container.add( inputField1 ); 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2) JAVA -- H15

24 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2)
// 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 ); 33 // set up label and outputField container.add( new JLabel( "RESULT ", SwingConstants.RIGHT ) ); outputField = new JTextField(); container.add( outputField ); 38 setSize( 425, 100 ); setVisible( true ); 41 } // einde constructor 43 44 // process GUI events public void actionPerformed( ActionEvent event ) { outputField.setText( "" ); // clear outputField 49 // read two numbers and calculate quotient try { number1 = Integer.parseInt( inputField1.getText() ); number2 = Integer.parseInt( inputField2.getText() ); 54 result = quotient( number1, number2 ); outputField.setText( String.valueOf( result ) ); } 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2) JAVA -- H15

25 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2)
// 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 ); } 65 // de catcher die uitgevoerd wordt, wanneer er door nul wordt gedeeld catch ( ArithmeticException arithmeticException ) { JOptionPane.showMessageDialog( this, arithmeticException.toString(), "Arithmetic Exception", JOptionPane.ERROR_MESSAGE ); } } 72 // methode quotient gooit een exceptie wanneer een divide-by-zero error optreedt public int quotient( int numerator, int denominator ) throws ArithmeticException { return numerator / denominator; } 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2) JAVA -- H15

26 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2)
// execute application public static void main( String args[] ) { DivideByZeroTest application = new DivideByZeroTest(); 85 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); } 88 89 } // end class DivideByZeroTest 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2) JAVA -- H15

27 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

28 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

29 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

30 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

31 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

32 Resource leak De finally blok 6. Het finally-blok
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

33 definieert de verplichte uitvoering van een stukje code
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 try-blok 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

34 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

35 Gebruik van een finally-blok
Voorbeeld Gebruik van een finally-blok JAVA -- H15

36 Resource leak The finally block 13. Het finally blok
1 // Fig. 15.3: UsingExceptions.java 2 // Demonstratie van try-catch-finally 3 // exception handling mechanisme. 4 public class UsingExceptions 5 { // uitvoeren application public static void main( String args[] ) { // methode throwException aanroepen try { throwException(); } 13 // catch Exceptions gegooid door de methode throwException catch ( Exception exception ) { System.err.println( "Exception handled in main" ); } 19 doesNotThrowException(); } 22 // 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 } 13. Het finally blok Resource leak Caused when resources are not released by a program The finally block Appears after catch blocks Always executes Use to release resources JAVA -- H15

37 Resource leak The finally block 13. Het finally blok
// 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! } 40 // 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! } 47 // 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" ); } 55 // catch wordt niet uitgevoerd, want er wordt geen exceptie gegooid catch( Exception exception ) { System.err.println( exception.toString() ); } 61 13. Het finally blok Resource leak Caused when resources are not released by a program The finally block Appears after catch blocks Always executes Use to release resources JAVA -- H15

38 13. Het finally blok Output v/h programma
// dit blok wordt uitgevoerd ongeacht wat er gebeurt in de try/catch finally { System.err.println("Finally executed in doesNotThrowException" ); } 70 System.out.println( "End of method doesNotThrowException" ); } 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 ! Output v/h programma JAVA -- H15

39 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

40 Demonstratie van “stack-unwinding”
Voorbeeld 1 Demonstratie van “stack-unwinding” JAVA -- H15

41 13. Het finally blok 1 // Fig. 15.4: UsingExceptions.java
2 // Demonstratie van de “stack-unwinding”. 3 public class UsingExceptions 4 { // uitvoeren application public static void main( String args[] ) { // roep de methode throwException om de “stack-unwinding” te demonstreren try { throwException(); } 12 // catch exception gegooid in throwException catch ( Exception exception ) { System.err.println( "Exception handled in main" ); } } 13. Het finally blok JAVA -- H15

42 13. Het finally blok Output v/h programma
// 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 } 28 // de catcher is van een incorrect type, dus de Exceptie wordt niet opgevangen catch( RuntimeException runtimeException ) { System.err.println( "Exception handled in method throwException" ); } 34 // finally block wordt altijd uitgevoerd finally { System.err.println( "Finally is always executed" ); } } 40 41 } // einde class UsingExceptions 13. Het finally blok Method throwException Finally is always executed Exception handled in main Output v/h programma JAVA -- H15

43 Demonstratie van “stack-unwinding”
Voorbeeld 2 Demonstratie van “stack-unwinding” JAVA -- H15

44 De exception volgt de weg terug.
4 Indien nergens iets voorzien wordt, komen we bij de main en stopt het programma met een foutmelding main 3 methodeA De exception volgt de weg terug. methodeX 2 methodeY throws de exception 1 In methodeY doet zich een exception voor methodeY JAVA -- H15

45 class Propagation_Demo { public static void main(String[] args)
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

46 class Exception_Scope { public void level3(int adjustment)
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

47 System.out.println(" start level2 "); level3(0);
Voorbeeld (3) public void level2() { System.out.println(" start level2 "); level3(0); System.out.println(" einde level2 "); } JAVA -- H15

48 { System.out.println(" start level1 "); try { level2(); }
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

49 Uitvoer voorbeeld JAVA -- H15

50 Methode printStackTrace
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 infor- matie wordt opgeslaan in een array van de klasse StackTraceElement. JAVA -- H15

51 Methode toString van de klasse Throwable
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

52 Voorbeeld Demonstratie van de methoden getMessage, getStackTrace en printStackTrace JAVA -- H15

53 Method printStackTrace Throwable class
1 // Fig. 15.5: UsingExceptions.java 2 // Demonstratie van de methoden getMessage en printStackTrace 3 // methoden die geërfd worden in alle exceptie klassen. 4 public class UsingExceptions 5 { // uitvoeren application public static void main( String args[] ) { // call methode1 try { method1(); } 13 // catch excepties gegooid door methode1 catch ( Exception exception ) { System.err.println( exception.getMessage() + "\n" ); exception.printStackTrace(); 18 // verkrijg de stacktrace informatie StacktraceElement[] traceElements = exception.getStackTrace(); System.out.println(“\nStack Trace from getStackTrace: “); System.out.println(“Class\t\tFile\t\tLine\tMethod”); 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 14. Gebruikmaken van printStackTrace en getMessage Method printStackTrace Prints the method call stack Throwable class Method getMessage retrieves informationString JAVA -- H15

54 42 // gooi de Exceptie terug naar methode2
// call methode2; gooi de excepties terug naar main public static void method1() throws Exception { method2(); } 36 // 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" ); } 47 48 } // einde class Using Exceptions JAVA -- H15

55 Merk op : elk element van de StackTraceElement-array bevat een methode-call de stack-trace-informatie is gelijk bij printStackTrace en getStackTrace JAVA -- H15

56 Vanaf versie 1.4 is dit wel mogelijk, via “chained” exceptions.
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

57 Method printStackTrace Throwable class
1 // Fig. 15.6: UsingChainedExceptions.java 2 // Demonstratie van chained exceptions 3 public class UsingChainedExceptions 4 { public static void main( String args[] ) { try { method1(); // call method1 } // catch excepties gegooid door methode1 catch ( Exception exception ) { exception.printStackTrace(); } } // call methode2; gooi de excepties terug naar main 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 Prints the method call stack Throwable class Method getMessage retrieves informationString JAVA -- H15

58 Vanaf J2SE 1.4 heeft de klasse Exception een
// 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" ); } 40 41 } // 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

59 De meest recente exceptie, die gegooid werd.
JAVA -- H15

60 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

61 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2)
1 // DivideByZeroException.java 2 // Definitie van de class DivideByZeroException. 3 // Wordt gebruikt om een exceptie te gooien wanneer een 4 // deling door nul voorkomt. 5 public class DivideByZeroException extends ArithmeticException 6 { // constructor zonder argument, specifieert de default error message public DivideByZeroException() { super( "Attempted to divide by zero" ); } 12 // constructor met een parameter public DivideByZeroException( String message ) { super( message ); } 18 19 } // end class DivideByZeroException 8. Voorbeeld : de exceptie “delen door 0” afhandelen (2) JAVA -- H15

62 Wanneer er een fout in de constructor gedetecteerd
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

63 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