CS 2430 Day 22

Announcements Prog4 test document and Rational Junit tests are due this Friday at 2 PM Quiz 3 this Friday Quiz 4 next Friday Exam 2: 4/3/13 –Review for exam 2 in lab on 4/2/13

Agenda Exceptions

Motivation public static void main(String args[]) { Stack theStack = new Stack(); Object obj = theStack.pop(); // Uh oh, pop from empty Stack!?! } What to do here? Just let the program crash? ($5) The pop() method could return null ? ($10) Use Exception s! (>$50)

The Exception class In Java, Exception s are Object s Can be “thrown” ( throw, throws ) Must be “caught” ( try, catch, finally )

The Exception hierarchy Exception RuntimeExceptionIOException... ArrayOutOfBoundsException... Throwable Object

Handling Exception s

Does this look familiar? try { new Prog4().run(); } catch (IOException ex) { System.out.println("Something bad happened: " + ex); ex.printStackTrace(); } Let’s take a closer look!

The try block try { new Prog4().run(); } catch (IOException ex) { System.out.println("Something bad happened: " + ex); ex.printStackTrace(); } Contains code that may throw an Exception, e.g. run()

The “suspect” code try { new Prog4().run(); } catch (IOException ex) { System.out.println("Something bad happened: " + ex); ex.printStackTrace(); } Remember the signature for run() ? public void run() throws IOException

A catch block try { new Prog4().run(); } catch (IOException ex) { System.out.println("Something bad happened: " + ex); ex.printStackTrace(); } If an IOException is thrown, it is caught by this (matching) catch block.

Handle the IOException try { new Prog4().run(); } catch (IOException ex) { System.out.println("Something bad happened: " + ex); ex.printStackTrace(); } If IOException is thrown by run(), this code is executed

The finally block try { new Prog4().run(); } catch (IOException ex) { System.out.println("Something bad happened: " + ex); ex.printStackTrace(); } finally { System.out.println("Always executed"); } The (optional) finally block is always executed last

Exception handling rules A try block can have one or more catch blocks If an Exception is thrown, only the first matching catch block is executed If there is a finally block, it must be last –And it is always executed! Do NOT try - catch RuntimeExceptions ( NullPointerException, etc.)

Be careful! try {... } catch (Exception ex) { System.out.println("Exception"); } catch (IOException ioex) { System.out.println("IOException"); }

Be careful! try {... } catch (Exception ex) { System.out.println("Exception"); } catch (IOException ioex) { System.out.println("IOException"); } Syntax error! Why?

Children first, parents last try {... } catch (IOException ioex) { System.out.println("IOException"); } catch (Exception ex) { System.out.println("Exception"); } “Children must be caught before parents”

Defining your own Exception s

Just make a new class public class StackEmptyException {... // could have data public StackEmptyException(String msg) {... } } Not quite an Exception yet

Our very own Exception ! public class StackEmptyException extends Exception {... public StackEmptyException(String msg) { super(msg);... } } Most of the time, this is all we need for our own Exception s

When to throw a StackEmptyException ?

Before public class Stack { private Object[] items; private int top;... public Object pop() { return items[--top]; } }

After public class Stack { private Object[] items; private int top;... public Object pop() throws StackEmptyException { if (top == 0) throw new StackEmptyException("Empty stack, ya'll!"); return items[--top]; }

Exception may be thrown public class Stack { private Object[] items; private int top;... public Object pop() throws StackEmptyException { if (top == 0) throw new StackEmptyException("Empty stack, ya'll!"); return items[--top]; } The throws keyword specifies that a StackEmptyException may be thrown (back to the calling method)

throw an Exception public class Stack { private Object[] items; private int top;... public Object pop() throws StackEmptyException { if (top == 0) throw new StackEmptyException("Empty stack, ya'll!"); return items[--top]; } This statement throw s a new StackEmptyException back to where the method was initially called

Client code public void doSomething(Stack inStack) {... Object obj = inStack.pop(); System.out.println("Here is the object: " + obj);... } This is (now) a syntax error!

Must try - catch public void doSomething(Stack inStack) {... try { Object obj = inStack.pop(); System.out.println("Here is the object: " + obj); } catch (StackEmptyException ex) { System.out.println("Here is the exception: " + ex); }... }

Could also do this public void doSomething(Stack inStack) throws StackEmptyException {... Object obj = inStack.pop(); System.out.println("Here is the object: " + obj);... } In general: If the calling method does not try - catch the Exception, it must advertise that it throws the Exception to the calling method.

Bad practice public static void main(String args[]) throws Exception {... } You probably shouldn’t do this. Why?

Do NOT throw or throws RuntimeException s ( NullPointerException, etc.)