1. Tirgul 13
Exceptions 1

2. Exception Handling in Java
Topics:
Introduction
Errors and Error handling
Exceptions
Types of Exceptions
Coding Exceptions
Summary

3. Introduction Users have high expectations for the code we produce.
Users will use our programs in unexpected ways.
Due to design errors or coding errors, our programs may fail in unexpected ways during execution

4. Introduction
It is our responsibility to produce quality code that does not fail unexpectedly.
Consequently, we must design error handling into our programs.

5. Errors and Error Handling
An Error is any unexpected result obtained from a program during execution.
Unhandled errors may manifest themselves as incorrect results or behavior, or as abnormal program termination.
Errors should be handled by the programmer, to prevent them from reaching the user.

6. Errors and Error Handling
Some typical causes of errors:
Memory errors (i.e. memory incorrectly allocated, memory leaks, “null pointer”)
File system errors (i.e. disk is full, disk has been removed)
Network errors (i.e. network is down, URL does not exist)
Calculation errors (i.e. divide by 0)

7. Errors and Error Handling
More typical causes of errors:
Array errors (i.e. accessing element –1)
Conversion errors (i.e. convert ‘q’ to a number)
Can you think of some others?

8. Exceptions What are they?
An exception is a representation of an error condition or a situation that is not the expected result of a method.
Exceptions are built into the Java language and are available to all program code.
Exceptions isolate the code that deals with the error condition from regular program logic.

9. Exceptions Exceptions fall into two categories:
Checked Exceptions
Unchecked Exceptions
Checked exceptions are inherited from the core Java class Exception. They represent exceptions that are frequently considered “non fatal” to program execution
Checked exceptions must be handled in your code (catch it), or passed to calling code for handling (declare that your method might throw it using the throws keyword at the method signature).

10. Exceptions
Unchecked exceptions represent error conditions that are considered “fatal” to program execution.
They all inherit from the RuntimeException class.
You are not forced to catch, or declare that you throw, an unchecked exception (but you’re allowed to, if you want).
If an exception is not caught, it will eventually crash the program and a stack-trace will be printed.

11. Exceptions
Examples:
Checked exceptions include errors such as “file not found” and “number format conversion”.
Unchecked exceptions include errors such as “null pointer”.

12. Exceptions How do you handle exceptions?
Exception handling is accomplished through the “try – catch” mechanism, or by a “throws” clause in the method declaration.
For any code that throws a checked exception, you can decide to handle the exception yourself, or pass the exception “up the chain” (to the “parent” code that called your function).

13. Exceptions How do you handle exceptions?
To handle the exception, you write a “try-catch” block. To pass the exception “up the chain”, you declare a throws clause in your method or class declaration.
If the method contains code that may cause a checked exception, you MUST handle the exception OR pass the exception to the calling code context.

14. Coding Exceptions Try-Catch Mechanism
Wherever your code may trigger an exception, the normal code logic is placed inside a block of code starting with the “try” keyword:
After the try block, the code to handle the exception should it arise is placed in a block of code starting with the “catch” keyword.

15. Exception Handling in Java
Coding Exceptions
Try-Catch Mechanism
You may also write an optional “finally” block. This block contains code that is ALWAYS executed, either after the “try” block code, or after the “catch” block code.
Finally blocks can be used for operations that must happen no matter what (i.e. cleanup operations such as closing a file)
June 14, 2001
Exception Handling in Java

16. Exception Handling in Java
Coding Exceptions
Example
try { … normal program code } catch(Exception e) { … exception handling code }
June 14, 2001
Exception Handling in Java

17. Exception Handling in Java
Coding Exceptions
Passing the exception
In any method that might throw an exception, you may declare that the method “throws” that exception, and thus avoid handling the exception yourself
Example
public void myMethod throws IOException { … normal code with some I/O }
June 14, 2001
Exception Handling in Java

18. Coding Exceptions Types of Exceptions
All checked exceptions have class “Exception” as the parent class.
You can use the actual exception class or the parent class when referring to an exception
Where do you find the exception classes?
Reference books such as “Java in a Nutshell” (O’Reilly, 2001), or the Java Documentation.
Various online resources…

19. JAVA Exception hierarchy
Blue: checked exceptions
Red: Unchecked exceptions

20. Example: catch general exception
try{ int[] myArray=null; System.out.println(myArray[3]); } catch(Exception e){ System.out.println(e.getMessage()); e.printStackTrace();
NullPointerException !

21. Example: several catch statements
try{…} catch(NullPointerException npe){ System.out.println(“npe"); } catch(Exception e){ System.out.println("got Exception");
The order in which exceptions are caught is the order in which the code is written.
If we caught Exception, and only then NullPointerException, the code would fail to compile!

22. Checked exceptions must be checked or propagated!
class Example2{
public static void test (){
try{
int message=System.out.read();
System.out.pribtln("successful read"); }
Catch (IOEXception exception){
System.out.println("unsuccessful read");
class Example2{
public static void test () throws IOException{
int message=System.out.read();
System.out.pribtln("successful read"); }

23. Writing a new exception
public class MyException extends Exception} public MyException (String error){ super(error); } { public static void foo(int n) throws MyException{ if (n<5) throw new MyException(“n could not be <5 in foo”); System.out.println(“Thank you and have a good day”);

24. Using the execption int n = (int)(Math.random()*10); try{ foo(n); }
catch (MyException e){
e.printStackTrace();

25. Summary Exceptions are a powerful error handling mechanism.
Exceptions in Java are built into the language.
Exceptions can be handled by the current code (try-catch), or handled by the caller (throws).