CS-202 Introduction to Object Oriented Programming

Transcription

1 CS-202 Introduction to Object Oriented Programming California State University, Los Angeles Computer Science Department Lecture IV Exception Handling and Text I/O

2 Introduction

3 Introduction exception handling: allows a program to deal with "exceptional" situations and continue its normal execution. in other words if there is a runtime error your program can handle the error without actually crashing. runtime errors: errors which occur while a program is running if the JVM finds an operation that is impossible for it to carry out. ArrayIndexOutOfBoundsException: triggered when an array index is out of bounds.

4 Introduction Java "throws" runtime errors as exceptions exceptions: an object that represents an error or condition that prevents execution from proceeding normally. unhandled exceptions = program crashes.

5 Exception-Handling Overview

6 Exception-Handling Overview exceptions are thrown from a method, the caller of the method can catch and handle the exception. Example: Quotient.java

7 Exception-Handling Overview Error Checking Method 1: Using an If Statement. Example: QuotientWithIf.java

8 Exception-Handling Overview Error Checking Method 2: Using a Method Example: QuotientWithMethod.java

9 Exception-Handling Overview Error Checking Method 3: Using Exception-Handling Example: QuotientWithException.java

10 Throwing an Exception Line 6: throw new ArithmeticException("Divisor cannot be zero") notice the throw keyword, indicates that an exception of the type ArithmeticException should be "thrown" triggered when number2 (the denominator) is 0 ArithmeticException, is a Class type in Java which is used to indicate a runtime error due to an invalid math operation. this is called "throwing an exception"

11 Throwing an Exception thrown exceptions interrupt normal flow of execution "throwing an exception" passes the exception from one place in the program to another. most "thrown" exceptions have to be dealt with somewhere and it is an error not to deal with them. so if you "throw an exception", then at some point you need to "catch" that exception.

12 Catching an Exception Lines 19 27: try { int result = quotient(number1, number2); System.out.println(number1 + " / " + number2 + " is " + result); } catch (ArithmeticException ex) { System.out.println("Exception: an integer " + "cannot be divided by zero "); }

13 Catching an Exception Whenever you invoke a method which has the potential to throw an checked exception, then you MUST surround the invocation of the method in a try/catch structure. try contains the code that is executed under normal conditions catch is only executed if the code from the try block triggers (throws) an exception this is where the exception is handled Whether or not an exception is thrown, the code after the catch clause is executed as the program continues.

14 Catching an Exception The catch clause must identify the type of exception it is catching: catch (ArithmeticException ex) NOTE: the value of the thrown exception can be accessed through the parameter of the catch (ex) try-catch block template:

15 Catching an Exception exceptions can be thrown directly in a try block, or by invoking a method that may throw an exception. most of the time a called method does not know how to handle an error, and it is up to the caller, to deal with the error. Example: InputMismatchExceptionDemo.java

16

17 Exception Types

18 Exception Types

19 Exception Types Throwable is root of all exceptions all exceptions inherit from Throwable custom exceptions can be created by extending Exception or one of its subclasses. Exception classes are classified in three major types: System Errors Exceptions Runtime Exceptions

20 System Errors thrown by the JVM represented by Error Class describes internal system errors these errors rarely occur if a system error occurs, and you know about it, then all you can do is notify the user and try to terminate the program gracefully. these would be errors that Oracle would have to fix with a Java update.

21 System Errors

22 Exception Errors represented by the Exception class errors caused by the program, or external circumstances can be caught and handled easily by your program

23 Runtime Exceptions represented by the RuntimeException class describes programming errors (bad casting, out of bounds index, numeric errors, etc) generally thrown by the JVM.

24 Checked and Unchecked Exceptions RuntimeException and Error (and any subclasses of these) are known as unchecked exceptions the compiler does not force you to check and deal with them in a try-catch block reflect programming logic errors that are unrecoverable and should be corrected in your program. Example: NullPointerException, IndexOutOfBoundsException can occur anywhere in a program and are unchecked to avoid overuse of try-catch blocks. All other exceptions are checked exceptions the compiler forces you to deal with these

25 More on Exception Handling

26 Finding a Handler for an Exception when an exception is thrown, a handler for that exception is found by tracing backward through the chain of method calls leading up to the exception. exception-handling is based on three operations: declaring an exception throwing an exception catching an exception

27 Declaring Exceptions declaring exceptions: every method must declare the types of checked exceptions that it might throw Remember: Error and RuntimeException types do not have to be declared because they are unchecked to declare an exception use the throws keyword in the method header public void mymethod() throws ExceptionType

28 Declaring Exceptions if a method throws more than one exception list them all separated by commas: public void mymethod() throws Exception1, Exception2,, ExceptionN NOTE: if a superclass method does not declare an exception, you cannot override to to declare one in the subclass.

29 Throwing Exceptions errors can be created as an instance of the appropriate exception type and thrown Example: program detects a method argument violates the valid types of arguments to a method i.e. an argument cannot be negative: IllegalArgumentException ex = new IllegalArgumentException("Wrong Argument"); throw ex; Or you can throw an anonymous exception: throw new IllegalArgumentException("Wrong Argument");

30 Throwing Exceptions NOTE: Most exceptions in the Java API have two constructors: a no-arg constructor a constructor which takes a String argument that describes the nature of the error. this is called the exception message and can be accessed using getmessage() TIP: to declare an exception use throws to throw an exception use throw

31 Catching Exceptions Thrown exceptions can be caught and handled in try-catch blocks:

32 Catching Exceptions if no exceptions trigger in the try block, all catch blocks are skipped if any statement from try throws an exception: Java skips all remaining statements in the try block Java tries to find the code to handle the exception method calls are "propogated backward" until an exception handler is found each catch block is tried from first to last if the exception type matches, then that catch block is executed if no handler is found java keeps passing the exception up the chain of method calls until one is found or the program terminates if nothing is found.

33 Catching Exceptions

34 Catching Exceptions

35 Catching Exceptions Note: Exceptions classes can be derived from a common superclass. If a catch block catches an exception of a superclass type, it can catch all the exception objects derived from that superclass.

36 Catching Exceptions The order of the exceptions in a catch block is important compile errors occur if a catch block for a superclass type appears before a catch block for a subclass type.

37 Catching Exceptions Note: you MUST deal with checked exceptions which means you have to invoke a method which throws a checked exception in a try-catch block or declare to throw the exception somewhere else

38 Catching Exceptions JDK 7 introduced a feature called the multi-catch to simplify coding for exceptions with the same handling code. Each exceptions is seperated by the pipe character (think half of an OR operator)

39 Getting Information from Exceptions The following methods from Throwable, allow you to get information about the thrown exception

40 Putting It All Together See Code: TestException.java CircleWithException.java TestCircleWithException.java

41 The finally Clause

42 The finally Clause An optional clause added to try/catch

43 The finally Clause The code in finally is executed under all circumstances, regardless of an exception occurring if no exception in try, finalstatements executed and next statement after try is executed. if exception is thrown and caught by the same catch as the try block, rest of the statements in try are skipped, catch block is executed, and finally is executed, then statements after try are executed. if an exception is thrown and caught somewhere else, statements in try are skipped, finally is executed, exception is passed to the caller of the method. finally is executed even if there is a return statement prior to reaching the finally block

44 When to Use Exceptions

45 When to Use Exceptions exception handling separates error-handling code from normal programming tasks makes the program easier to read and modify caveat: exception handling requires more time and resources have to instantiate a new exception object have to roll back the call stack have to propagate the exception through the chain of methods and search for a handler

46 When to Use Exception Exceptions always occur in methods General Rule of Thumb: if you want an exception to be processed by its caller, create an exception object and throw it. (common exceptions that may occur in multiple classes) if you can handle the exception in the method where it occurs, no need to throw or use exceptions (simple errors)

47 When to Use Exceptions

48 Rethrowing Exceptions

49 Rethrowing Exceptions an exception handler can "rethrow" an exception if the handler cannot process the exception or just wants to let the caller be notified of the exception

50 Chained Exceptions

51 Chained Exceptions chained exception: throwing a new exception along with another exception usually you would throw a new exception with additional information along with the original

52 ChainedExceptionDemo.java

53 Defining Custom Exception Classes

54 Defining Custom Exception Classes Java gives many exception classes, use them whenever possible. however, if you can't apply an existing exception to an error in your program you can write your own. all exception should be derived from Exception or one of its subclasses. Custom exceptions are always classes by themselves

55 Defining Custom Exception Classes

56 Defining Custom Exceptions

57 The File Class

58 Intro to File I/O File I/O (input / output) is very common in programming. Files allow you to store data permanently all data stored in variables is lost once the program exits. files can be backed up and transferred from computer to computer easily.

59 Absolute File Paths absolute file name: contains a file name with its complete path and driver letter example: windows: UNIX/LINUX: /home/user/documents/games.txt these names are machine dependent c:\user\documents\games.txt different machines may have different file systems, and folder structures absolute file names are generally not a good object for dynamic programs.

60 Relative File Path relative file name: name is relative to the current working directory the complete directory path is usually omitted example: games.txt NOTE: in order to use the relative file name in Eclipse, you must place your i/o files in the project directory (same directory as the src and bin folders of your project)

61 The File Class Java provides a File class to easily work with files stored on a computer. This class is machine independent. Contains basic operations for files: obtaining a file or directory and its properties creating or deleting a file or directory renaming files or directories etc...

62 The File Class

63 The File Class

64 Caution with Backslash The directory separator in Windows is a backslash (\) If you want to write a back slash in a string you need to escape it by writing a double backslash \\ If you use a file name such as: c:\\book\\welcome.java it will only work on a Windows machine and not on any others. you should always just use a forward slash because this will work on any machine

65 TestFileClass.java

66 File Input and Output

67 File Input and Output To perform I/O you must create an instance of the appropriate classes. Scanner for file input. PrintWriter for file output. These classes are generally used for text i/o i/o involving human readable text binary i/o will be covered in CS-203

68 Writing Data with PrintWriter

69 WriteData.java

70 Closing Resources Automatically often, programmers forget to close their files, which can lead to memory leaks in your program JDK 7 provides a new "try-with-resources" syntax to automatically close files

71 WriteDataWithAutoClose.java

72 Closing Resources Automatically the resource is declared and created using the keyword try. note that the resources are enclosed in parentheses in order for this to work, resources must be a subtype of AutoCloseable and have a.close() method PrintWriter is a subtype of this type

73 Reading Data Using Scanner

74 ReadData.java

75 Auto Close We can also rewrite the previous example using the auto close feature See Code: ReadDataWithAutoClose.java

76 How Does Scanner Work? token-reading methods: nextbyte(), nextshort(), nextint(), nextlong(), nextfloat(), nextdouble(), next() methods which read tokens separated by delimiters by default, the delimiters are whitespace characters (newline character, tabs, spaces, etc) you can use the usedelimiter(string regex) method to set a new pattern for delimiters each method skips any delimiters and then reads the next "token" converting it to the correct datatype (except for next() which requires no conversion).

77 next() and nextline() Both of these methods read strings next() reads up to the next whitespace character nextline() reads up to the next line separator character. Note about line-separators: the line-separator string is defined by the system Windows is \r\n Unix base systems it is \n to get the line separator for a particular system use: String lineseparator = System.getProperty("line.separator"); when you enter input from the keyboard, the line ends with the enter key press which is the \n character.