Exception Handling

• Checked exceptions are subclasses of the Exception class, excluding the class RuntimeException and its subclasses.
  • These exceptions correspond to situation which are unexpected but which are not bugs in the program.

    (the network is temporarily down, the hard disk is full, etc.)

  • These exception can happen at specific places in your program (when opening a network connection, when saving a file, etc.)
  • The compiler forces the programmer to handle these exceptions in some way (see later). Usually the program can recover from the problem (instead of dying) and keep running.

The Java code that you think may produce an exception is placed within a try block.

• No exception occurs inside the try block → the finally block is executed, then the rest of the method.
• An exception occurs inside the try block → an exception object is created by Java and thrown, killing all the code after that inside the try block, until a matching catch block is found and executed to handle the exception object → the finally block is executed → the rest of the method is executed.

• An exception object created and thrown during execution of the try block can be caught and handled in a catch block.
• On exit from a catch block, normal execution continues and the finally block is executed, followed by the execution of the rest of the method.

// try-catch example:
import java.util.Scanner;
public class Test2 {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    while(true) {
        System.out.print("Input an integer: ");
        String s = scanner.nextLine();
        try {
          int i = Integer.parseInt(s);
          System.out.println("i is: " + i);
        }catch(NumberFormatException e) {
          System.out.println("Wrong!");
        }
    }
  }
}
Copy

• A finally block is always executed.
• Generally a finally block is used for freeing resources, cleaning up, closing files or network connections etc. Otherwise you do not need it.
• If the finally block executes a control transfer statement such as a return or a break statement, then this control statement determines how the execution will proceed regardless of any return or control statement present in the try or catch.

try {
    <code that might throw an exception>
} catch (<exception type1> <parameter1>) {
    <statements handling parameter1>
} catch (<exception type2> <parameter2>) {
    <statements handling parameter2>
}finally { // finally block
    <statements always executed>
}
Copy

//finally example:
public class Test3 {
    public static void division(int i, int j) {
        int result = -1;
        try {
            result = i / j;
        } catch(ArithmeticException e) {
            System.out.println("Wrong: " + e.getMessage());
        } finally {
            System.out.println(i + " / " + j + " = " + result);
        }
    }
    public static void main(String[] args) {
        division(100, 4);
        division(100, 0); // ArithmeticException: / by zero
        System.out.println("End of main()");
    }
}
Copy

A method can explicitly create an object from the Exception class (or one of its subclasses) using new and then throw the object using the throw statement. Then the method must either:

• Catch the exception object itself using a try-catch statement. 使用try-catch捕获并处理异常
  • This is not very useful: in general there is little reason for a method to throw an exception just to immediately catch it in the same method...
• use the throws clause to specify as part of the type of the method that the method might throw an exception. 在方法名旁边throws特定的异常
  • The exception object will then have to be caught somewhere else, in one of the callers of the method. 可以用if-else, 挑出异常，用throw抛出异常

1. Define a subclass of Exception.
2. Create an exception object from the subclass using new.
3. Throw the exception object using throw.
4. Use a try-catch statement to handle the exception object inside the method itself, or use a throws clause and catch the exception object somewhere else.

public class NotPositiveException extends Exception {
    public NotPositiveException(String msg) {
    // msg is the message given to the exception 
    when
    // it is created, which will later be the 
    resultP
    // of calling the getMessage() method.
    super(msg);
    }
}

import java.util.Scanner;
public class Test8 {
    public static void readPosInt() throws NotPositiveException {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Input a positive integer: ");
        String s = scanner.nextLine();
        int i = Integer.parseInt(s);
        if (i <= 0) {
            throw new NotPositiveException(i + " <= 0 !");
        }
        System.out.println("i is: " + i);
    }
    public static void main(String[] args) {
        while (true) {
            try {
                readPosInt();
            } catch (NotPositiveException e) { // If i <= 0.
                System.out.println("NotPositive: " + e.getMessage());
            } catch (NumberFormatException e) { // If parseInt() fails.
                System.out.println("NumberFormat: " + e.getMessage());
            }
        }
    }
}
Copy

Input a positive integer: -2
NotPositive: -2 <= 0 !
Input a positive integer: -2.5
NumberFormat: For input string: "-2.5"

• An overriding method in subclass can throw any unchecked exception, regardless of whether the overridden method in superclass throws exceptions or not.
• If an overriding method in subclass throws checked exception, then it must be the same exception or child exceptions of the exception(s) declared in the overridden method.

class A {
    void meth() throws FileNotFoundException {
    }
}

class B extends A {
    @Override
    void meth() {
    } // compiles fine
}

class C extends A {
    @Override
    void meth() throws IOException {
    } // compile error
    /*
     * Exception IOException is not compatible with throws clause
     * in A.meth()
     */
}

class D extends A {
    @Override
    void meth() throws RuntimeException {
    }// compiles fine
}

interface A {
    void meth() throws IOException;
}

class B implements A {
    @Override
    public void meth() throws FileNotFoundException {
    }
    // compiles fine
}

class C implements A {
    @Override
    public void meth() {
    } // compiles fine
}

class D implements A {
    @Override
    public void meth() throws Exception {
    } // compile error
}
Copy