Exception

Advanced Programming

SUT • Spring 2019

Error handling mechanisms
Exception handling framework
Benefits of exception handling framework
Exception handling in Java

Exception Handling

Example

public class Main {
    public static Integer getYear(String day) {
        String yearString = day.substring(0, 4);
        int year = Integer.parseInt(yearString);
        return year;
    }


    public static void main(String[] args) {
        String day = "2010/11/29";
        Integer year = getYear(day);
        System.out.println(year);
    }
}

Exceptions

What is wrong with it?
What if day parameter is not a day representation?
- day = “salam!”
What if day parameter is malformed?
- Day = “29 Nov 2010”
What if day parameter is empty?
- String s = "";
What if day parameter is null?
- These occasions are called Exception

Handling Exceptions

What to do with exceptions?
Exit the program
Printing the error on console
Returning a special value
- e.g. -1

Important Note

Sometimes the method can’t handle the exception effectively
What should a method do when an exception occurs?
Exit the program?
- Suppose you are in a desktop application
  - Excel, Word, a game, …
Print on console?
- edu site
- A game

Returning a Special Value

We can return a special value to report an exception
E.g.
- return null;
- return -1;
- return 0;
- return “”;
Why not?

Why not?

There is no special value
There are many exceptions
Ambiguity
- Need for documentation
Combination of program code and exception code

There is no special value

public class Main {
    public static int minimum(int[] nums) {
        int m = Integer.MAX_VALUE;
        for (int i : nums) {
            m = Math.min(m, i);
        }
        return m;
    }
}

int[] array = {1,2,-1};
int minimumFound = minimum(array);

Exception Handling

Exception Handling is a framework for handling exceptions
- ;-)
It simplifies code
- Separates business code and exception code

What is an Exception?

Exceptional event
Error that occurs during runtime
Cause normal program flow to be disrupted
Examples
- Divide by zero errors
- Accessing the elements of an array beyond its range
- Invalid input
- Hard disk crash
- Opening a non-existent file
- Heap memory exhausted

Default Exception Handling

Provided by Java runtime
Prints out exception description
Prints the stack trace
- Hierarchy of methods where the exception occurred
Causes the program to terminate

Example

class DivByZero {
    public static void main(String a[]) {
	System.out.println(3/0);
    }
}

Exception in thread "main" java.lang.ArithmeticException: 
/ by zero
at exception.Test2.main(Test2.java:19)

Note: Exception is a runtime concept
This code has no syntax error (No compile-time error)

What Happens When an Exception Occurs?

When an exception occurs within a method
The method creates an exception object
And hands it off to the runtime system
- This job is called “throwing an exception”
Exception object contains
- information about the error
- its type
- the state of the program when the error occurred
  - Exception line of code

What Happens When an Exception Occurs (2)?

The run time system searches the call stack for a method that contains an exception handler
When an appropriate handler is found
- The runtime system passes the exception to the handler
- The exception handler catches the exception
What if the runtime system can not find an exception handler?
- Uses the default exception handler

Example

Exception Handling in Java

import java.util.Scanner;

public class Year {
    public static Integer getYear(String day) {
        String yearString = day.substring(0, 4);
        return Integer.parseInt(yearString);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a well-formed date: ");
        String date = scanner.next();
        Integer year = getYear(date);
        System.out.println(year);
    }
}

Example

public class Year {
    public static Integer getYearWithException(String day) throws Exception {
        if (day == null)
            throw new Exception("null value");
        if (day.length() == 0)
            throw new Exception("empty value");
        if (!matchesDateFormat(day))
            throw new Exception("malformed value");
        String yearString = day.substring(0, 4);
        int year = Integer.parseInt(yearString);
        return year;
    }

    private static boolean matchesDateFormat(String input) {
        return input.matches("\\d\\d\\d\\d/\\d\\d/\\d\\d");
    }
}

main

public class Year {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean ok = false;
        while (ok == false) {
            System.out.print("Enter a well-formed date: ");
            String date = scanner.next();
            try {
                Integer year = getYear(date);
                System.out.println(year);
                ok = true;
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

Exception Handling Keywords

throw
- throws a new exception
throws
- Declares exception throw
- If a method may throw an exception, it should declare it
try
- Start a block with exception handling
catch
- Catch the exception

Benefits of Exception Handling Framework

Separating Error-Handling code from “regular” business logic code
Propagating errors up the call stack
Grouping and differentiating error types

Example

public class Test {
    public static void main(String[] args){
        try {
            Scanner scanner = new Scanner(System.in);
            int first = scanner.nextInt();
            int second = scanner.nextInt();
            int div = division(first, second);
            System.out.println(div);            
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    

    private static int division(int first, int second) throws Exception{
        if(second == 0)
            throw new Exception("OOPS! Makhraj Sefre!");
        return first/second;
    }
}

Separating Error-Handling Code

Consider pseudocode method
It reads an entire file into memory

readFile {
    open the file;
    determine its size;
    allocate that much memory;
    read the file into memory;
    close the file;
}

errorCodeType readFile {
    initialize errorCode = 0;
    
    open the file;
    if(theFileIsOpen) {
        determine the length of the file;
        if(gotTheFileLength) {
            allocate that much memory;
            if(gotEnoughMemory) {
                read file int memory;    
                if(readFailed) {
                    errorCode = -1;
                }
            } else {
                errorCode = -2;
            }
        } else {
            errorCode = -3;
        }
        close the file;
        if (theFileDidntClose && errorCode == 0) {
            errorCode = -4;
        } else {
            errorCode = errorCode and -4;
        }
    } else {
        errorCode = -5;
    }
    return errorCode;
}

With Exception
Handling Framework

readFile {
    try {
        open the file;
        determine its size;
        allocate that much memory;
        read the file into memory;
        close the file;
    } catch (fileOpenFailed) {
        doSomething;
    } catch (sizeDeterminationFailed) {
        doSomething;
    } catch (MemoryAllacationFailed) {
        doSomething;
    } catch (readFailed) {
        doSomething;
    } catch (fileCloseFailed) {
        doSomething;
    }
}

Note

You should still write code for detecting, reporting and handling exceptions
Exception handling framework is not responsible for these jobs!
It only helps you organize the work more effectively

Propagating Errors Up the Call Stack

Traditional approach
- Each method should explicitly forward the exception
- Use a special return code
- Using return type for reporting exceptions
  - Smells bad!
New approach
- Automatic
- Beautiful!

Grouping and Differentiating Error Types

All exceptions thrown within a program are objects
The grouping or categorizing of exceptions is a natural outcome of the class hierarchy

public class Test {
    public static void main(String[] args){
        try {
            Scanner scanner = new Scanner(System.in);
            int first = scanner.nextInt();
            int second = scanner.nextInt();
            int div = division(first, second);
            System.out.println(div);            
        } catch (IOException e) {
            System.out.println(e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
    
    private static int readInt() throws IOException {
        String str = scanner.next();
        if(str.matches("[\\d]+")){
            return Integer.parseInt(str);
        }
        throw new IOException("Bad input");
    }


    private static int division(int first, int second) throws ArithmeticException{
        if(second == 0)
            throw new ArithmeticException("OOPS! Makhraj Sefre!");
        return first/second;
    }
}

Example

public class MultipleCatch {
    public static void main(String args[]) {
        try {
            int den = Integer.parseInt(args[0]);
            System.out.println(3 / den);
        } catch (ArithmeticException exc) {
            System.out.println("Divisor was 0.");
        } catch (ArrayIndexOutOfBoundsException exc2) {
            System.out.println("Missing argument.");
        }
        System.out.println("After exception.");
    }
}

Nested Tries

public class NestedTryDemo {
    public static void main(String args[]) {
        try {
            int a = Integer.parseInt(args[0]);
            try {
                int b = Integer.parseInt(args[1]);
                System.out.println(a / b);
            } catch (ArithmeticException e) {
                System.out.println("Div by zero error !");
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Need 2parameters !");
        }
    }
}

Bad Use of Exceptions

Don’t Use Exception instead of If-else
Use exceptions for exceptions!

Writing Your Own Exceptions

Your class should extend Exception class
Exception subclasses could be thrown and caught
Steps to follow
- Create a class that extends Exception class
- Customize the class
  - Members and constructors may be added to the class
Exception classes are usually simple classes
- With no (or few) methods and properties

Example

public class HateStringExp extends Exception {
        /* some code */

    public static void main(String[] args) {
        String input = "invalid input";
        try {
            if (input.equals("invalid input")) {
                throw new HateStringExp();
            }
            System.out.println("Accept string.");
        } catch (HateStringExp e) {
            System.out.println("Hate string!");
        }
    }
}

getYear(), revisited

public class Year {
    public static Integer getYear(String day)
            throws Exception {
        if (day == null)
            throw new NullPointerException();
        if (day.length() == 0)
            throw new EmptyValueException();
        if (!matchesDateFormat(day))
            throw new MalformedValueException();
        String yearString = day.substring(0, 4);
        int year = Integer.parseInt(yearString);
        return year;
    }

    private static boolean matchesDateFormat(String input) {
        return input.matches("\\d\\d\\d\\d/\\d\\d/\\d\\d");
    }
}

Finally

try {
    //..
} catch (ExceptionType e) {
   //…
} ...
} finally {
	<code to be executed before the try block ends>
}

Contains the code for cleaning up after a try or a catch

Finally (2)

Block of code is always executed
Despite of different scenarios:
- Normal completion
- Forced exit occurs using a return, a continue or a break statement
- Caught exception thrown
- Exception was thrown and caught in the method
- Uncaught exception thrown
- Exception thrown was not specified in any catch block in the method

What is the output of:

public class Main {
    static void myMethod(int n) throws Exception {
        try {
            switch(n) {
                case 1:
                    System.out.println("1 case");
                    return;
                case 3: 
                    System.out.println("3 case");
                    throw new RuntimeException("3!");
                case 4: 
                    System.out.println("4 case");
                    throw new Exception("4!");
                case 2:
                    System.out.println("2nd case");
                // continued ...
            }
        } catch (RuntimeException e) {
            System.out.println("RuntimeException: ");
            System.out.println(e.getMessage());
        } finally {
            System.out.println("try-block entered.");
        }
    }
}

What is the output of:

class MyException extends Exception {}

public class Main {
    public static int myMethod(int n) {
       try {  
          switch (n) {
          case 1:
             System.out.println("One");
             return 1;
          case 2:
             System.out.println("Two");
             throw new MyException();
          case 3:
             System.out.println("Three");
       }
       return 4;
    } catch (Exception e) {
       System.out.println("catch");
       return 5;
    } finally {
       System.out.println("finally");
       return 6;
    }
}

int a = myMethod(1);
System.out.println("myMethod(1)=" + a);
a = myMethod(2);
System.out.println("myMethod(2)=" + a);
a = myMethod(3);
System.out.println("myMethod(3)=" + a);

Unchecked Exceptions

private static void function(String[] args) {
    int den = Integer.parseInt(args[0]);
    System.out.println(3 / den);
}

public static void main(String[] args) {
    function(args);
}

The method function() may throw exceptions
But it has not declared it with throws keyword
Why?
- Because some exceptions are unchecked
- such as ArithmeticException and ArrayIndexOutOfBoundsException

Checked and Unchecked Exceptions

Checked exception
- Java compiler checks
- the program should catch or list the occurring exception
- If not, compiler error will occur
Unchecked exceptions
- Not subject to compile-time checking for exception handling

Checked and Unchecked Exceptions

Built-in unchecked exception classes
- Error
- RuntimeException
- Their subclasses
Unchecked exceptions only relax compiler
- The runtime behavior is the same

Exception Class Hierarchy

Exception Classes and Hierarchy

Multiple catches should be ordered from subclass to superclass
Or else, Compile error: Unreachable catch block…

class MultipleCatchError {
    public static void main(String args[]){
	try {
	    int a = Integer.parseInt(args [0]);
	    int b = Integer.parseInt(args [1]);
	    System.out.println(a/b);
	} catch (ArrayIndexOutOfBoundsException e) {
	    //..
	} catch (Exception ex) {
	    //..
	}
    }
}

Exceptions & Inheritance

Suppose method f() overrides parent’s method
f() in child class can not throw more exceptions than those of f() in Parent class
- Less or equal exceptions in throws declaration
These mistakes bring compiler error
Why?
- Polymorphic method invocations may cause failure in catching some exceptions

Example (1)

class Parent{
    void f() {}
}

class Child extends Parent{
    void f() throws Exception {}
}

Result?
- Compiler Error

Example (2)

class Parent{
    void f() throws ArithmeticException {}
}

class Child extends Parent{
    void f() throws ArithmeticException, IOException {}
}

Result?
- Compiler Error

Example (3)

class Parent{
    void f() throws ArithmeticException {}
}

class Child extends Parent{
    void f() throws Exception {}
}

Result?
- Compiler Error

Example (4)

class Parent{
    void f() throws Exception{}
}

class Child extends Parent{
    void f() throws ArithmeticException{}
}

Result?
- No Error

Conclusion

f() in child class can not throw more exceptions
Less or equal exceptions in throws declaration
f() in child class can not throw more general exceptions
f() in child class can throw more specific exceptions
Reason:
- Prevent uncaught exceptions in polymorphic invocations

class MyException extends Exception {
    public MyException(String string) {
        super(string);
    }
}

class YourException extends RuntimeException {
    public YourException(String string) {
        super(string);
    }
}

public class Sample {
    public static void main(String[] args) {
        try {
            f();
            System.out.println("After f()");
            throw new YourException("Your Exception");
        } catch (MyException e) {
            System.out.println("My Exception");
        } catch (Exception e) {
            System.out.println("Exception");
        } finally {
            System.out.println("Finally");
        }
    }

    private static void f() throws Exception {
        System.out.println("f() method");
        throw new MyException("Exception");
    }
}

Example

interface A {
    void a(Object o);
}

interface B {
    void b(String s);
}

class C implements A {
    public void a(Object o) {
        System.out.println("a() in C");
    }

    public void b(String s) {
        System.out.println("b() in C");
    }
}


class D extends C implements A, B {
    public void a(Object o) {
        System.out.println("a() in D");
        super.a(o);
    }

    public void b(String s) {
        System.out.println("b() in D");
        try {
            int parseInt = Integer.parseInt(s);
        } catch (Exception e) {
            //NumberFormatException
            throw new BadFormatException();
        }
    }
}

class BadFormatException extends 
RuntimeException {
}

public class Test {
    public static void main(String[] args) {
        A a1 = new C();
        B b1 = new D();
        C c1 = new C();
        C c2 = new D();
        Object o = new String("Twenty Two");
        try {
            f(c2);
            a1.a(o);
            c1.a((String) o);
            b1.b((String) o);
            c2.a(o);
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException");
        } catch (BadFormatException e) {
            System.out.println("BadFormatException");
        } catch (Exception e) {
            System.out.println("Exception");
        } finally {
            System.out.println("Good Bye!");
        }
    }

    public static void f(A a) {
        a.a(a);
    }
}

Accessing the Stack Trace

e.printStackTrace();
e.getStackTrace();

for(StackTraceElement methodCall : e.getStackTrace())
	System.out.println(methodCall);

Multiple Catch Blocks

When providing multiple catch handlers:
handle specific exceptions before handling general exceptions.
Multi-Catch Blocks (Java7):

catch(IOException | IllegalStateException multie) {…}

Try-with-Resources (Java7)

try(Scanner sc = new Scanner(System.in)) {
    System.out.println("You Typed the integer value: " + sc.nextInt());
} catch (Exception e){
    // catch all other exceptions here ...
    System.out.println("Error: Encountered an exception and could not read
    an integer from the console ...");
    System.out.println("Exciting the program - 
    restart and try the program again!");
}

java.lang.AutoCloseable interface

Assertions

The assert statement
used to check your assumptions about the programs
E.g.
- assert (i >= 0) : "impossible: i is negative!";
AssertionError
java -ea MyClassName

Assert or Exception?

The key to understanding assertions
they are useful for debugging and testing
Assertions are meant to be disabled when the application is deployed to end users

Exception

Contents

Exception Handling

Example

Exceptions

Handling Exceptions

Important Note

Returning a Special Value

Why not?

There is no special value

Exception Handling

What is an Exception?

Default Exception Handling

Example

What Happens When an Exception Occurs?

What Happens When an Exception Occurs (2)?

Example

Example

Exception Handling in Java

Example

main

Exception Handling Keywords

Benefits of Exception Handling Framework

Example

Separating Error-Handling Code

With Exception Handling Framework

Note

Propagating Errors Up the Call Stack

Grouping and Differentiating Error Types

Example

Nested Tries

Bad Use of Exceptions

Writing Your Own Exceptions

Example

getYear(), revisited

Finally

Finally (2)

What is the output of:

What is the output of:

Unchecked Exceptions

Checked and Unchecked Exceptions

Checked and Unchecked Exceptions

Exception Class Hierarchy

Exception Classes and Hierarchy

Exceptions & Inheritance

Example (1)

Example (2)

Example (3)

Example (4)

Conclusion

Example

Accessing the Stack Trace

Multiple Catch Blocks

Try-with-Resources (Java7)

Assertions

Assert or Exception?

Title Text

With Exception
Handling Framework