1 / 29

Java Exception Yangjun Chen Dept. Business Computing University of Winnipeg

Java Exception Yangjun Chen Dept. Business Computing University of Winnipeg. Outline: Exceptions. Exceptions Managing Exceptions try and catch blocks finally clause Exception propagation Throwing Exceptions Creating your own Exceptions. Outline: Exceptions. Creating exception:.

josephineg
Télécharger la présentation

Java Exception Yangjun Chen Dept. Business Computing University of Winnipeg

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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;}}}

More Related