1. 1 / 89 COP 3503 FALL 2012 SHAYAN JAVED LECTURE 11 Programming Fundamentals using Java 1

2. 2 / 89 Exception Handling

3. 3 / 89 Errors  Syntax Errors  Logic Errors  Runtime Errors

4. 4 / 89 Syntax Errors  Arise because language rules weren’t followed.

5. 5 / 89 Syntax Errors  Arise because language rules weren’t followed.  Detected by the compiler  javac for Java  g++ for C++

6. 6 / 89 Logic Errors  Program compiles and runs, but results are wrong.

7. 7 / 89 Logic Errors  Program compiles and runs, but results are wrong.  Detected and fixed through testing.

8. 8 / 89 Logic Errors  Program compiles and runs, but results are wrong.  Detected and fixed through testing.  Arise because logic coded by the programmer was incorrect.

9. 9 / 89 Logic Errors  Program compiles and runs, but results are wrong.  Detected and fixed through testing.  Arise because logic coded by the programmer was incorrect.  Example: wrote c = a - b instead of c = a + b

10. 10 / 89 Runtime Errors  Occur when program is running – environment detects it and can’t carry it out

11. 11 / 89 Runtime Errors  Occur when program is running – environment detects it and can’t carry it out  Examples of Code Errors:  Divide by zero

12. 12 / 89 Runtime Errors  Occur when program is running – environment detects it and can’t carry it out  Examples of Code Errors:  Divide by zero  Array out of bounds

13. 13 / 89 Runtime Errors  Occur when program is running – environment detects it and can’t carry it out  Examples of Code Errors:  Divide by zero  Array out of bounds  Accessing a null pointer (reference)

14. 14 / 89 Runtime Errors  Occur when program is running – environment detects it and can’t carry it out  Examples of Code Errors:  Divide by zero  Array out of bounds  Accessing a null pointer (reference)  Integer overflow

15. 15 / 89 Runtime Errors  Occur when program is running – environment detects it and can’t carry it out  Examples of Code Errors:  Divide by zero  Array out of bounds  Accessing a null pointer (reference)  Integer overflow  Programs crash when such exceptions are not handled

16. 16 / 89 Errors int[] numbers = { 1.5, 5, 7 }; System.out.prntln(numbers[numbers.length]); Try to point out all the errors in this code

17. 17 / 89 Errors int[] numbers = { 1.5, 5, 7 }; System.out.prntln(numbers[numbers.length]); Syntax Error(s)

18. 18 / 89 Errors int[] numbers = { 1.5, 5, 7 }; System.out.prntln(numbers[numbers.length]); Syntax Error(s)

19. 19 / 89 Errors int[] numbers = { 1.5, 5, 7 }; System.out.prntln(numbers[numbers.length]); Syntax Error(s) Runtime Error(s)

20. 20 / 89 Exception An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program’s instructions.

21. 21 / 89 Exception Handling in Java  Mechanism for handling exceptions by detecting and responding to them in a systematic, uniform and reliable manner.

22. 22 / 89 Exception Handling in Java  Mechanism for handling exceptions by detecting and responding to them in a systematic, uniform and reliable manner.  Any exceptions not handled within the Java program are “caught” by the Java Runtime Environment (JRE)

23. 23 / 89 Exception  A method in Java throws Exceptions  “Something went wrong”

24. 24 / 89 Exception  A method in Java throws Exceptions  “Something went wrong”  Exceptions are Objects  Every Exception is a subclass of the Exception class

25. 25 / 89 Unchecked Exceptions/Errors

26. 26 / 89 System Errors

27. 27 / 89 System Errors  Thrown by the Java Virtual Machine (JVM)

28. 28 / 89 System Errors  Thrown by the Java Virtual Machine (JVM)  Represented by the Error class

29. 29 / 89 System Errors  Thrown by the Java Virtual Machine (JVM)  Represented by the Error class  Describes internal system errors

30. 30 / 89 System Errors  Thrown by the Java Virtual Machine (JVM)  Represented by the Error class  Describes internal system errors  Rarely occur – if they do you can’t do much other than terminating

31. 31 / 89 Runtime Exceptions (Unchecked)

32. 32 / 89 Checked Exceptions

33. 33 / 89 Checked Exceptions Need to explicitly deal with Checked Exceptions: try and catch them, or throw them

34. 34 / 89 Exception Handling  Keywords:  try some code, catch any Exceptions

35. 35 / 89 Exception Handling  Keywords:  try some code, catch any Exceptions  or throw an Exception

36. 36 / 89 Exception Handling  Keywords:  try some code, catch any Exceptions  or throw an Exception  finally execute some code

37. 37 / 89 Exception Handling  Java forces you to deal with checked Exceptions

38. 38 / 89 Exception Handling  Java forces you to deal with checked Exceptions  Two ways to deal with them: void p1 () { try { riskyMethod(); } catch (Exception ex) {.... } (a)

39. 39 / 89 Exception Handling  Java forces you to deal with checked Exceptions  Two ways to deal with them: void p1 () { try { riskyMethod(); } catch (Exception ex) {.... } (a) void p1 () throws Exception { riskyMethod(); } (b)

40. 40 / 89 Exception Handling  Remember the clone() method?

41. 41 / 89 Exception Handling  Remember the clone() method?  Can be written in two ways: Object clone() { try { return super.clone(); } catch (CloneNotSupportedException ex) {.... } (a)

42. 42 / 89 Exception Handling  Remember the clone() method?  Can be written in two ways: Object clone() { try { return super.clone(); } catch (CloneNotSupportedException ex) {.... } (a) Object clone() throws CloneNotSupportedException { return super.clone(); } (b)

43. 43 / 89 Exception Handling  In the first case, we are catching and handling the Exception

44. 44 / 89 Exception Handling  In the first case, we are catching and handling the Exception  In the second case we are throwing it – needs to be caught and handled by the calling method

45. 45 / 89 Catching Exceptions  A try-catch statement: try { // Statement(s) which throw Exceptions } catch (Exception1 exception1) { // Handles Exceptions of type Exception1 } catch (Exception2 exception2) { // Handles Exceptions of type Exception2 } catch (Exception exception) { // Handles Exceptions of type Exception // ALL Exceptions } // Any code after the try-catch block

46. 46 / 89 Catching Exceptions  A try-catch statement: try { // Statement(s) which throw Exceptions } catch (CloneNotSupportedException exception1) { // Handles Exceptions of type CloneNotSupportedException } catch (NullPointerException exception2) { // Handles Exceptions of type NullPointerException } catch (Exception exception) { // Handles Exceptions of type Exception // ALL Exceptions } // Any code after the try-catch block

47. 47 / 89 Catching Exceptions  A try-catch statement: try { Circle clone = circle1.clone(); } catch (CloneNotSupportedException exception1) { // Handles Exceptions of type CloneNotSupportedException } catch (NullPointerException exception2) { // Handles Exceptions of type NullPointerException } catch (Exception exception) { // Handles Exceptions of type Exception // ALL Exceptions } // Any code after the try-catch block

48. 48 / 89 Catching Exceptions  Thrown Exceptions have to be eventually caught somewhere in your code

49. 49 / 89 Exception Information  So an Exception has been caught – what can we do with it? try { // Statements which throw Exceptions } catch (Exception exception) { // ALL Exceptions }

50. 50 / 89 Exception Information  Some useful methods in the Throwable class:

51. 51 / 89 Exception Information  Some useful methods in the Throwable class:  String toString():  Returns a short description of the Exception

52. 52 / 89 Exception Information  Some useful methods in the Throwable class:  String toString():  Returns a short description of the Exception  String getMessage():  Returns a detailed description of the Exception

53. 53 / 89 Exception Information  Some useful methods in the Throwable class:  String toString():  Returns a short description of the Exception  String getMessage():  Returns a detailed description of the Exception  void printStackTrace():  Prints the stacktrace information on the console

54. 54 / 89 Exception Information  Some useful methods in the Throwable class:  void printStackTrace():  Prints the stacktrace information on the console Sample output: java.lang.NullPointerException at MyClass.method2(MyClass.java:9) at MyClass.method1(MyClass.java:6) at MyClass.main(MyClass.java:3)

55. 55 / 89 Exception Information  Example: java.io.PrintWriter output = null; try { output = new java.io.PrintWriter(“text.txt”); output.println(“Welcome to Java”); output.close(); } catch (java.io.IOException ex){ System.out.println(ex.toString()); ex.printStackTrace() ; }

56. 56 / 89 Problems  Example: java.io.PrintWriter output = null; try { output = new java.io.PrintWriter(“text.txt”); output.println(“Welcome to Java”); output.close(); } catch (java.io.IOException ex){ System.out.println(ex.toString()); ex.printStackTrace() ; } Must execute output.close() even if Exception occurs

57. 57 / 89 Solution  Use the finally clause – for code that must be executed “no matter what”

58. 58 / 89 Solution  Use the finally clause – for code that must be executed “no matter what” try { // Statement(s) which throw Exceptions } catch (Exception1 exception1) { // Handles Exceptions of type Exception1 } catch (Exception exception) { // Handles Exceptions of type Exception } finally { // code executed whether there is an Exception or not }

59. 59 / 89 Solution  Example: java.io.PrintWriter output = null; try { output = new java.io.PrintWriter(“text.txt”); output.println(“Welcome to Java”); } catch (java.io.IOException ex){ ex.printStackTrace() ; } finally { if (output != null) output.close(); }

60. 60 / 89 The finally block  Executed when try block is exited in these ways:

61. 61 / 89 The finally block  Executed when try block is exited in these ways:  After last statement of try block

62. 62 / 89 The finally block  Executed when try block is exited in these ways:  After last statement of try block  After last statement of the catch block (if an Exception was caught)

63. 63 / 89 The finally block  Executed when try block is exited in these ways:  After last statement of try block  After last statement of the catch block (if an Exception was caught)  When an Exception is thrown in try but NOT caught

64. 64 / 89 The finally block  Executed when try block is exited in these ways:  After last statement of try block  After last statement of the catch block (if an Exception was caught)  When an Exception is thrown in try but NOT caught Executed even if there is a return statement prior to reaching the finally block

65. 65 / 89 Throwing Exceptions  If written code could encounter a runtime error:

66. 66 / 89 Throwing Exceptions  If written code could encounter a runtime error:  It creates an Exception object and throws it

67. 67 / 89 Throwing Exceptions  If written code could encounter a runtime error:  It creates an Exception object and throws it  and must also declare it in the method description

68. 68 / 89 Throwing Exceptions  If written code could encounter a runtime error:  It creates an Exception object and throws it  and must also declare it in the method description  Only if the Exception is a checked Exception  Optional for unchecked

69. 69 / 89 Throwing Exceptions  Example: public void setRadius(double newRadius) { if (newRadius >= 0) radius = newRadius; else throw new IllegalArgumentException( "Radius cannot be negative"); }

70. 70 / 89 Throwing Exceptions  Example: OPTIONAL public void setRadius(double newRadius) throws IllegalArgumentException { if (newRadius >= 0) radius = newRadius; else throw new IllegalArgumentException( "Radius cannot be negative"); }

71. 71 / 89 Throwing Exceptions try { Circle c1 = new Circle(5); c1.setRadius(-5); } catch (IllegalArgumentException ex) { System.out.println(ex); }

72. 72 / 89 Throwing Exceptions try { Circle c1 = new Circle(5); c1.setRadius(-5); } catch (IllegalArgumentException ex) { System.out.println(ex); } Output: Radius cannot be negative

73. 73 / 89 Creating Custom Exceptions  Create custom Exception classes if predefined classes not sufficient

74. 74 / 89 Creating Custom Exceptions  Create custom Exception classes if predefined classes not sufficient  To create a custom class:  class should extend Exception

75. 75 / 89 Creating Custom Exceptions  Create custom Exception classes if predefined classes not sufficient  To create a custom class:  class should extend Exception  Good practice to add: A default (empty) constructor A constructor with one String parameter

76. 76 / 89 Creating Custom Exceptions public class InvalidRadiusException extends Exception { private double radius; public InvalidRadiusException() { super(“Invalid radius!”); } public InvalidRadiusException(double radius) { super("Invalid radius!”); this.radius = radius; } public double getRadius() { return radius; }

77. 77 / 89 Creating Custom Exceptions  Example: public void setRadius(double newRadius) throws IllegalArgumentException { if (newRadius >= 0) radius = newRadius; else throw new IllegalArgumentException( "Radius cannot be negative"); }

78. 78 / 89 Creating Custom Exceptions  Example: public void setRadius(double newRadius) throws InvalidRadiusException { if (newRadius >= 0) radius = newRadius; else throw new InvalidRadiusException(radius); }

79. 79 / 89 Creating Custom Exceptions try { Circle c1 = new Circle(5); c1.setRadius(-5); } catch (IllegalArgumentException ex) { System.out.println(ex); }

80. 80 / 89 Creating Custom Exceptions try { Circle c1 = new Circle(5); c1.setRadius(-5); } catch (InvalidRadiusException ex) { System.out.println(“Invalid Radius: “ + ex.getRadius()); }

81. 81 / 89 Creating Custom Exceptions try { Circle c1 = new Circle(5); c1.setRadius(-5); } catch (InvalidRadiusException ex) { System.out.println(“Invalid Radius: “ + ex.getRadius()); } Output: Invalid Radius: -5.0

82. 82 / 89 When to create Custom Exceptions  Use the exception classes in the API whenever possible.

83. 83 / 89 When to create Custom Exceptions  Use the exception classes in the API whenever possible.  Write your own custom exception class if you answer yes to one of the following:

84. 84 / 89 When to create Custom Exceptions  Use the exception classes in the API whenever possible.  Write your own custom exception class if you answer yes to one of the following:  Do you need an exception type that isn’t represented by Java?

85. 85 / 89 When to create Custom Exceptions  Use the exception classes in the API whenever possible.  Write your own custom exception class if you answer yes to one of the following:  Do you need an exception type that isn’t represented by Java?  Would it help users if they can differentiate your exceptions from those thrown by classes from other vendors?

86. 86 / 89 When to create Custom Exceptions  Use the exception classes in the API whenever possible.  Write your own custom exception class if you answer yes to one of the following:  Do you need an exception type that isn’t represented by Java?  Would it help users if they can differentiate your exceptions from those thrown by classes from other vendors?  Do you want to pass more than just a string to the exception handler?

87. 87 / 89 When to use Exceptions  Use if the event is exception and truly an error

88. 88 / 89 When to use Exceptions  Use if the event is exception and truly an error  Do not use it to deal with simple, expected situations  Example: try { System.out.println(refVar.toString()); } catch (NullPointerException ex) { System.out.println("refVar is null"); }

89. 89 / 89 When to use Exceptions  Use if the event is exception and truly an error  Do not use it to deal with simple, expected situations  Example:  Replace with: try { System.out.println(refVar.toString()); } catch (NullPointerException ex) { System.out.println("refVar is null"); } if (refVar != null) System.out.println(refVar.toString()); else System.out.println("refVar is null");