13: Error Handling with Exceptions. The basic philosophy of Java is that "badly formed code will not be run."

Size: px

Start display at page:

Download "13: Error Handling with Exceptions. The basic philosophy of Java is that "badly formed code will not be run.""

Hope Hardy
6 years ago
Views:

1 13: Error Handling with Exceptions The basic philosophy of Java is that "badly formed code will not be run." 1

Error Handling in Java C++/Java: Badly-formed code will not compile. Java: Badly-formed code, if compiled, will not run. Not all errors can be caught at compile time.

2 Error Handling in Java C++/Java: Badly-formed code will not compile. Java: Badly-formed code, if compiled, will not run. Not all errors can be caught at compile time. Run-time error handling is integrated into the core of the language and enforced by the compiler. The standard libraries require the handling of exceptional conditions. 2

3 Sources of Problems Program logic. Errors like exceeding array bounds and division by zero can be prevented by the programmer. Environmental conditions. Loss of a network connection or a full disk can be anticipated but not prevented. 3

4 Exceptions An exception is an object that signals an error condition and provides information about the error. When an exception is generated, control is passed up the call stack until a specific handler is found. Multiple handlers for different exceptions may be provided at multiple levels. In Java, many exceptions cannot be ignored. This is enforced by the compiler. 4

5 Basic Exceptions An exceptional condition is a problem that prevents the continuation of the current method or scope. To indicate such a condition, one throws an exception object: if (t == null) throw new NullPointerException(); or If (t == null) throw new NullPointerException("t = null"); 5

6 The Exception Class Hierarchy Throwable Error Exception Runtime Exception Checked Exceptions Unchecked Exceptions 6

7 Throwable Methods public class Throwable implements Serializable { public Throwable(); public Throwable(String message); public Throwable(Throwable cause); public Throwable(String message, Throwable cause); public Throwable getcause(); public String getlocalizedmessage(); public String getmessage(); public StackTraceElement[] getstacktrace(); public void setstacktrace(stacktraceelement[] stacktrace); public Throwable fillinstacktrace(); public Throwable initcause(throwable cause); public void printstacktrace(); public void printstacktrace(java.io.printstream s); public void printstacktrace(java.io.printwriter s); public String tostring(); 7

Exception & RuntimeException Methods public class Exception extends Throwable { public Exception(); public Exception(Throwable cause); public Exception(String message); public Exception(String

8 Exception & RuntimeException Methods public class Exception extends Throwable { public Exception(); public Exception(Throwable cause); public Exception(String message); public Exception(String message, Throwable cause); public class RuntimeException extends Exception { public RuntimeException(); public RuntimeException(Throwable cause); public RuntimeException(String message); public RuntimeException(String message, Throwable cause); 8

9 Catching Exceptions A thrown exception will cause immediate transfer from a try block to an appropriate catch clause. /* Code that might generate exceptions */ catch (Type1 e1) { /* Handle exceptions of Type1 */ catch (Type2 e2) { /* Handle exceptions of Type2 */ catch (Type3 e3) { /* Handle exceptions of Type3 */ finally { /* Execute code that will always run */ 9

10 The Exception Specification Any exception thrown by a method (except for runtime exceptions) must be declared in a throws clause. This is enforced by the compiler. All checked exceptions will be caught somewhere. 10

Creating an Exception Throwing MyException from f() MyException at FullConstructors.f(FullConstructors.java:10) at FullConstructors.main(FullConstructors.

11 Creating an Exception Throwing MyException from f() MyException at FullConstructors.f(FullConstructors.java:10) at FullConstructors.main(FullConstructors.java:16) Throwing MyException from g() MyException: Originated in g() at FullConstructors.g(FullConstructors.java:13) at FullConstructors.main(FullConstructors.java:20) 11

12 Getting More Creative class MyException2 extends Exception { private int x; public MyException2() { public MyException2(String msg) { super(msg); public MyException2(String msg, int x) { super(msg); this.x = x; public int val() { return x; public String getmessage() { return "Detail Message: " + x + " " + super.getmessage(); 12

13 Testing the Class public class ExtraFeatures { public static void f() throws MyException2 { print("throwing MyException2 from f()"); throw new MyException2(); public static void g() throws MyException2 { print("throwing MyException2 from g()"); throw new MyException2("Originated in g()"); public static void h() throws MyException2 { print("throwing MyException2 from h()"); throw new MyException2("Originated in h()", 47); public static void main(string[] args) { f(); catch (MyException2 e) { e.printstacktrace(system.out); g(); catch (MyException2 e) { e.printstacktrace(system.out); Throwing MyException2 from f() MyException2: Detail Message: 0 null at ExtraFeatures.f(ExtraFeatures.java:22) at ExtraFeatures.main(ExtraFeatures.java:34) Throwing MyException2 from g() MyException2: Detail Message: 0 Originated in g() at ExtraFeatures.g(ExtraFeatures.java:26) at ExtraFeatures.main(ExtraFeatures.java:39) Throwing MyException2 from h() h(); MyException2: Detail Message: 47 Originated in h() catch (MyException2 e) { at ExtraFeatures.h(ExtraFeatures.java:30) e.printstacktrace(system.out); at ExtraFeatures.main(ExtraFeatures.java:44) System.out.println("e.val() e.val() = " + = e.val()); 47 13

14 Rethrowing A caught exception may be partially handled and thrown again: catch(exception e) System.err.println("An exception was thrown."); throw e; The rethrown exception goes to the next higher context. All of its contained information is preserved. 14

15 Installing a New Stack Trace public class Rethrowing { public static void f() throws Exception { System.out.println("originating the exception in f()"); throw new Exception("thrown from f()"); public static void g() throws Exception { f(); catch (Exception e) { originating the exception in f() System.out.println("Inside g(),e.printstacktrace()"); Inside g(),e.printstacktrace() e.printstacktrace(system.out); java.lang.exception: thrown from f() throw e; public static void h() throws Exception { f(); catch (Exception e) { System.out.println("Inside h(),e.printstacktrace()"); e.printstacktrace(system.out); throw (Exception)e.fillInStackTrace(); public static void main(string[] args) { g(); catch (Exception e) { System.out.println("main: printstacktrace()"); e.printstacktrace(system.out); h(); catch (Exception e) { System.out.println("main: printstacktrace()"); e.printstacktrace(system.out); at Rethrowing.f(Rethrowing.java:7) at Rethrowing.g(Rethrowing.java:11) at Rethrowing.main(Rethrowing.java:29) main: printstacktrace() java.lang.exception: thrown from f() 15 at Rethrowing.f(Rethrowing.java:7) at Rethrowing.g(Rethrowing.java:11) at Rethrowing.main(Rethrowing.java:29) originating the exception in f() Inside h(),e.printstacktrace() java.lang.exception: thrown from f() at Rethrowing.f(Rethrowing.java:7) at Rethrowing.h(Rethrowing.java:20) at Rethrowing.main(Rethrowing.java:35) main: printstacktrace() java.lang.exception: thrown from f() at Rethrowing.h(Rethrowing.java:24) at Rethrowing.main(Rethrowing.java:35)

Rethrowing a New Exception class OneException extends Exception { public OneException(String s) { super(s); class TwoException extends Exception { public TwoException(String s) { super(s); public

16 Rethrowing a New Exception class OneException extends Exception { public OneException(String s) { super(s); class TwoException extends Exception { public TwoException(String s) { super(s); public class RethrowNew { public static void f() throws OneException { System.out.println("originating the exception in f()"); throw new OneException("thrown from f()"); public static void main(string[] args) { f(); catch (OneException e) { System.out.println( "Caught in inner try, e.printstacktrace()"); e.printstacktrace(system.out); throw new TwoException("from inner try"); catch (TwoException e) { System.out.println( "Caught in outer try, e.printstacktrace()"); e.printstacktrace(system.out); originating the exception in f() Caught in inner try, e.printstacktrace() OneException: thrown from f() at RethrowNew.f(RethrowNew.java:15) at RethrowNew.main(RethrowNew.java:20) Caught in outer try, e.printstacktrace() TwoException: from inner try at RethrowNew.main(RethrowNew.java:25) 16

17 Cleanup With Finally The finally clause provides a mechanism to take care of non-memory resources. Anything that must always be done should be included in the finally clause. The finally clause should not be used for operations that may not always be needed or appropriate. 17

Doesn t Always Work public class Switch { private boolean state = false; public boolean read() { return state; public void on() { state = true; print(this); public void off() { state = false;

18 Doesn t Always Work public class Switch { private boolean state = false; public boolean read() { return state; public void on() { state = true; print(this); public void off() { state = false; print(this); public String tostring() { return state? "on" : "off"; public class OnOffSwitch { private static Switch sw = new Switch(); public static void f() throws OnOffException1, OnOffException2 { public static void main(string[] args) { sw.on(); // Code that can throw exceptions... f(); sw.off(); catch (OnOffException1 e) { System.out.println("OnOffException1"); sw.off(); catch (OnOffException2 e) { System.out.println("OnOffException2"); sw.off(); 18

19 Always Works public class WithFinally { static Switch sw = new Switch(); public static void main(string[] args) { sw.on(); // Code that can throw exceptions... OnOffSwitch.f(); catch (OnOffException1 e) { System.out.println("OnOffException1"); catch (OnOffException2 e) { System.out.println("OnOffException2"); finally { sw.off(); 19

20 Inheritance Implications Overridden methods may only throw exceptions specified in the base-class version. Derived-class exceptions do not violate the rule. The restriction does not apply to constructors. Derived-class constructors must declare baseclass exeptions in their exception specification. 20

21 Constructors If a constructor throws an exception proper cleanup may not occur. Any sort of cleanup done in a finally clause should be executed conditionally and controlled by a flag. Only perform this cleanup in finally if you re forced to. 21

22 Cleanup Example public class InputFile { private BufferedReader in; public InputFile(String fname) throws Exception { in = new BufferedReader(new FileReader(fname)); /* Other code that might throw exceptions */ catch (FileNotFoundException e) { System.out.println("Could not open " + fname); // Wasn't open, so don't close it throw e; catch (Exception e) { // all other exceptions must close it in.close(); catch (IOException e2) { System.out.println("in.close() unsuccessful"); throw e; /* Rethrow */ finally { /* Don't close it here */ 22

23 The Rest of the Class public String getline() { String s; s = in.readline(); catch (IOException e) { throw new RuntimeException("readLine() failed"); return s; public void dispose() { in.close(); System.out.println("dispose() successful"); catch (IOException e2) { throw new RuntimeException("in.close() failed"); 23

24 Client Code public class Cleanup { public static void main(string[] args) { InputFile in = new InputFile("Cleanup.java"); String s; int i = 1; while ((s = in.getline())!= null) ; /* Perform line-by-line processing here... */ catch (Exception e) { System.out.println("Caught Exception in main"); e.printstacktrace(system.out); finally { in.dispose(); catch (Exception e) { System.out.println("InputFile construction failed"); 24

25 Exception Matching... Handlers are searched through in the order in which they were written. Derived-class exceptions match base-class handlers. The compiler will detect unreachable code. 25

26 ...Exception Matching class Annoyance extends Exception { class Sneeze extends Annoyance { public class Human { public static void main(string[] args) { // Catch the exact type: throw new Sneeze(); catch (Sneeze s) { System.out.println("Caught Sneeze"); catch (Annoyance a) { System.out.println("Caught Annoyance"); // Catch the base type: throw new Sneeze(); catch (Annoyance a) { System.out.println("Caught Annoyance"); 26

27 Avoiding the Issue Exceptions are harmful if swallowed: /*...to do something useful */ catch(exception e) { // Gulp! Or you can do nothing and get a stack trace: public class MainException { public static void main(string[] args) throws Exception { // Use the file... // Close the file: file.close(); 27

28 Converting an Exception You can turn a checked exception into a runtime exception: somethinguseful(); catch(idontknowwhattodowiththischeckedexception e) { throw new RunTimeException(e); 28

29 Overhead Exceptions are free as long as they don t get thrown. Thrown exceptions are expensive. Don t use exceptions for normal flow of control. Exceptions should only be used to handle abnormal conditions. 29

Guidelines Handle an exception only if there is enough information in the current context to correct the error. If not, allow it to propigate upward.

30 Guidelines Handle an exception only if there is enough information in the current context to correct the error. If not, allow it to propigate upward. Separated error handling from normal flow makes code more readable and maintainable. Handle complete tasks, not single statements in a try block. Resumption causes excessive coupling and is not available in C++/Java. Use loops to retry. 30

31 Guidelines Use exceptions in constructors if something could go wrong: people assume construction succeeds. If you catch an exception, do something with it; don t stub it out. Clean up using finally. 31

32 Summary Exception handling in Java is enforced by the compiler: they must be caught, exception specification must be provided. Error handling is clean and straightforward: error handling is left to the client programmer, how the client handles the error is decoupled from the implementation, the implementer knows that errors will be handled. If it seems like more work it s because you ve been ignoring errors. 32

엄현상 (Eom, Hyeonsang) School of Computer Science and Engineering Seoul National University COPYRIGHTS 2017 EOM, HYEONSANG ALL RIGHTS RESERVED

엄현상 (Eom, Hyeonsang) School of Computer Science and Engineering Seoul National University COPYRIGHTS 2017 EOM, HYEONSANG ALL RIGHTS RESERVED Outline - Interfaces - An Instrument interface - Multiple Inheritance