Java Exception Yangjun Chen Dept. Business Computing University of Winnipeg

1. Java Exception Yangjun Chen Dept. Business Computing University of Winnipeg

2. Outline: Exceptions • Exceptions • Managing Exceptions • try and catch blocks • finally clause • Exception propagation • Throwing Exceptions • Creating your own Exceptions

3. Outline: Exceptions Creating exception: Catching exception: Reporting exception: public boolean myM(int x) throws AnException { … throw new AnException(); } public class A extends Exception { … } try { … } catch { … } finally { … } exception propagation

4. Exceptions • Exceptions are unusual things that happen within your Java • program that are different from the desired behavior of the • program. • They could be fatal errors or could be in the event of • exceptional circumstances. • Exception handling is the management of these exceptions or errors. • When an exception is encountered, Java will report this • problem by throwing an exception.

5. Exceptions • At this point, the system will halt normal operation and look for a solution to the problem. It looks in your code, to see if there is anything that will catch the exception. • After the exception is caught, normal operation is resumed • after the offending block of code. • In traditional error handling, some code is usually written • to head off the error before it occurs. • Exception handling in Java allows the error or unusual • situation to occur and then takes steps to deal with it. • Exceptions don’t occur in Java. They are thrown. • Exceptions can be thrown by either the system or by the • programmer.

6. Exception Error Exceptions • Exceptions in Java are actual objects of classes that inherit • from the Throwable class. ArithmeticException RuntimeException ArrayStoreException … ... ClassNotFoundException NoSuchFieldException NoSuchMethodException … ... Throwable OutOfMemoryError StackOverflowError … ... VirtualMachineError LinkageError ClassFormatError ThreadDeath NoClassDefFoundError … ...

7. Throwable Class • The Throwable class has two subclasses: Error and • Exception . • Instances of the Error class represent internal errors that are • usually fatal. You can neither catch them nor throw them • yourself. • The Exception subclass will contain most of the exception • classes that are used, but there are other packages that • define their own exception classes. • - For example, the java. io package has its own exception class • called IOException . • So how do we handle exceptions?

8. Managing Exceptions • The Java compiler will enforce exception management • when you try to use methods that declare exceptions. Your • program will not compile unless there is code that will • handle the exception. • Handling or catching an exception requires two things: • - protecting the code that contains the method that throws an • exception by putting it inside a try block • - Testing and dealing with the exception in a catch block • What these two keywords mean is to “try this code that • might cause an exception. If all works well, then continue • on. If it doesn’t, then catch the problem and deal with it.” • For example, let’s look at the following code.

9. Try and Catch • All try blocks must have a catch block associated with it. • You can also have more than one catch clause associated • with each try block. • try { • offset = x / n; • // anything from here down will be ignored if n is 0. • } • catch (ArithmeticException e){ • offset = 10; • } • // Execution will continue from here after the exception is • // handled

10. Multiple Catch Clauses • catch clauses are examined from top to bottom, stopping at • the first clause that has an argument that is compatible with • the thrown exception and then skipping the remaining • clauses. • try { • … • } • catch (Exception e) { // Compatible with every exception • … • } • catch (ArithmeticException e) { // will never be called • … • }

11. finally Clause • Suppose that there is some code that must be executed • whether an exception was thrown or not. • This is done in what is called the finally clause. • SomeFileClass f = new SomeFileClass(); • if (f. open(“/ a/ file/ name/ path”)) { • try { • someReallyExceptionalMethod(); • } catch (IOException e) { • // deal with them!! • } finally { • f. close(); • }//finally • }//if

12. finally Clause • Instead of using the finally clause, you could put the code • in all the catch clauses as well as just outside them, but this • would be duplicating code. • A try block can have at most one finally clause and it must • appear immediately after the last catch clause. • If a try block has a finally clause, it does not have to have • any catch clauses. • As with catch, a finally clause must be associated with a try • block.

13. Exception Propagation • Exceptions are propagated if there isn’t a catch clause • associated with the try block that has a compatible • exception type. • The system will then look for an enclosing try.. catch pair • that has an appropriate catch clause. • try { • … • try { // exception thrown here } • catch (SomeException e) { // exception not caught here • } • } • catch (SomeOtherException e) { // look here • }

14. Exception Propagation • If an appropriate catch clause is not found, the search • continues until it reaches the block which encloses the • entire method body. • If there is still no compatible catch clause, the search is • widened to include the block containing the method call. • This search continues on outward, until eventually the • exception is handled. If there doesn’t exist any handling • for the exception, the Java environment will handle it for • you. Java will terminate you program! • This isn’t always a bad idea. There are situations that • terminating the program will be better or is the only • alternative.

15. The throws Clause • To indicate that some code in the body of your method may • throw an exception, use the throws keyword after the • signature of the method. • - public boolean myMethod( int x) throws AnException { … } • For multiple exception types, put them all in the throws • clause separated by commas. • You can also throw a superclass of a group of exceptions to • indicate that your method may throw any subclass of that • exception. • - public void myMethod2( int x) throws IOException { … } • Exceptions of either class Error or RuntimeException do • not have to be included in the throws clause. Java gives • them special treatment. They are implicit exceptions.

16. The throws Clause • Declaring that your method throws an exception doesn’t • actually make your method throw the exception if occurred. • This has to be done within the body of the method itself. • To throw an exception, an instance of some exception class • is needed. Once an instance is created or obtained, use the • throw statement to throw it.

17. The throws Clause • The simplest way is to create the instance and throw the • exception in the same statement. • - throw new ServiceNotAvailableException(); • You can only throw objects that are instances of subclasses • of Throwable unlike in C++ where an object of any type • may be thrown. • Depending on the exception class that you are using, the • exception’s constructor may require some arguments. The • most common argument is a string that describes the • exception in more detail. • - throw new ServiceNotAvailableException(“ Exception: • service not available, database is offline.”);

18. The throws Clause • Once an exception is thrown, the method exits after • executing the finally clause (if one exists) without returning • a value. • The exception is then passed on to the surrounding • try.. catch block and propagated further until it is handled.

19. Creating Exceptions • Although Java provides a wealth of exception classes, there • may be times where we would like to create our own • exceptions that are not covered by the predefined exception • classes. • To create a exception, you must inherit from one of the • other exception classes. Try to find an exception that’s • close to the one you are creating. • If none of the exceptions match closely, then inherit from • Exception itself which is the top of the hierarchy for • explicit exceptions or RuntimeException. • Exception classes typically have two constructors, one with • no arguments and one with a string argument.

20. Creating Exceptions • The MissingData exception is thrown in a utility method. • class MissingData extends Exception { • // thrown by the processSubmitButton() when one or more of the • // data fields are empty • public MissingData() { • super(); • } • public MissingData( String s) { • super(s); • } • }

21. Creating Exceptions private void processSubmitButton() throws MissingData { if (( custName. getText(). equals( EMPTY)) || (custStreet. getText(). equals( EMPTY) || //( six more clauses omitted here) (order. getText(). equals( EMPTY))) { throw new MissingData(“ Complete all fields!”); } else { // Data is all there order. appendText( CRLF+” ORDER PLACED”); repaint(); }//else }// processSubmitButton

22. Creating Exceptions • Note that we have to use a throws clause, since MissingData is a checked exception. • Now the exception is caught in the applets action() handler. • … • else if (e. target == Submit) { • try { • processSubmitButton(); • } • catch (MissingData ex) { • order.appendText(“* ”+ ex.getMessage()+ CRLF); • repaint(); • } • return true; • }

23. An Example for Exception Propagation import java.lang.*; //Here we define some exception types of our own. //Exception classes generally have constructors but no data or //other methods. All these do is call their superclass constructors. class MyException extends Exception { public MyException() {super();} public MyException(String s) { super(s); } } class MyOtherException extends Exception { public MyOtherException { super();} public MyOtherException(String s) { super(s); } }

24. An Example for Exception Propagation class MySubException extends MyException { public MySubException() { super(); } public MySubException(String s) { super(s); } } public class Throwtest { //This is the main() method. Note that it uses two //catch clauses to handle two standard Java exceptions. public static void main(String argv[]) { int i = 2;

25. An Example for Exception Propagation //First, covert our argument to an integer. //Make sure we have an argument and that it is convertible. try { i = Integer.parseInt(argv[0]; } catch (ArrayIndexOutOfBoundsException e) {//argv is empty System.out.println("Must specify an argument"); return; } catch (NumberFormatException e) {//argv[0] is not an integer System.out.println("Must specify an integer argument"); }

26. An Example for Exception Propagation //Now, oass that integer to method a(). a(i); } //This method invokes b(), which is declared to throw //one type of exception. We handle that one exception. public static void a(int i) { try { b(i); }

27. An Example for Exception Propagation catch (MyException e) { //Point 1 //Here we handle MyException and its subclass MySubException if (e instanceof MySubException) System.out.print("MySubException: "); else System.out.print("MyException: "); System.out.println(e.getMessage()); System.out.println("Handle at point 1"); } }

28. An Example for Exception Propagation public static void b(int i) throws MyException { int result; try { System.out.print("i = " + i); result = c(i); System.out.print(" c(i) = " + result); } catch (MyOtherException e) { //Point 2 //Handle MyOtherException: System.out.println("MyOtherException: " + e.getMessage()); System.out.println("Handle at point 2"); }

29. An Example for Exception Propagation finally { //Terminate the output we printed above with a newline. System.out.print("\n"); }} public static int c(int i) throws MyException, MyOtherException { switch (i) { case 0: //processing resumes at point 1 above throw new MyException("input too low"); case 1: //processing resumes at point 1 above throw new MyException("input still too low"); case 99: //processing resumes at point 2 above throw new MyOtherException("input too high"); default: return i*i;}}}