Download presentation
Presentation is loading. Please wait.
1
Chapter 11 I/O and Exception Handling 1 Chapter 11 I/O and Exception Handling
2
Chapter 11 I/O and Exception Handling 2 Chapter Goals To learn how to read and write text files To learn how to throw exceptions To be able to design your own exception classes To understand the difference between checked and unchecked exceptions To learn how to catch exceptions To know when and where to catch an exception
3
Chapter 11 I/O and Exception Handling 3 Reading Text Files Simplest way to read text: use Scanner class To read from a disk file, construct a FileReader Then, use FileReader to construct Scanner object Use the Scanner methods to read data from file next, nextLine, nextInt and nextDouble FileReader reader = new FileReader("input.txt"); Scanner in = new Scanner(reader);
4
Chapter 11 I/O and Exception Handling 4 Writing Text Files To write to a file, use a PrintWriter object If file already exists, it is emptied before the new data are written into it If file doesn't exist, an empty file is created PrintWriter out = new PrintWriter("output.txt");
5
Chapter 11 I/O and Exception Handling 5 Writing Text Files Use print and println to write to a PrintWriter You must close a file when you are done processing it Otherwise, not all of the output may be written to the disk file out.println(29.95); out.println(new Rectangle(5, 10, 15, 25)); out.println("Hello, World!"); out.close();
6
Chapter 11 I/O and Exception Handling 6 A Sample Program Reads all lines of a file and sends them to the output file, preceded by line numbers Sample input file Mary had a little lamb Whose fleece was white as snow. And everywhere that Mary went, The lamb was sure to go!
7
Chapter 11 I/O and Exception Handling 7 A Sample Program The program produces the output file This program can be used to number the lines of Java source files /* 1 */ Mary had a little lamb /* 2 */ Whose fleece was white as snow. /* 3 */ And everywhere that Mary went, /* 4 */ The lamb was sure to go!
8
Chapter 11 I/O and Exception Handling 8 File LineNumberer.java 01: import java.io.FileReader; 02: import java.io.IOException; 03: import java.io.PrintWriter; 04: import java.util.Scanner; 05: 06: public class LineNumberer 07: { 08: public static void main(String[] args) 09: { 10: Scanner console = new Scanner(System.in); 11: System.out.print("Input file: "); 12: String inputFileName = console.next(); 13: System.out.print("Output file: "); 14: String outputFileName = console.next(); 15: 16: try 17: { Continued…
9
Chapter 11 I/O and Exception Handling 9 File LineNumberer.java 18: FileReader reader = new FileReader(inputFileName); 19: Scanner in = new Scanner(reader); 20: PrintWriter out = new PrintWriter(outputFileName); 21: int lineNumber = 1; 22: 23: while (in.hasNextLine()) 24: { 25: String line = in.nextLine(); 26: out.println("/* " + lineNumber + " */ " + line); 27: lineNumber++; 28: } 29: 30: out.close(); 31: } 32: catch (IOException exception) 33: { Continued…
10
Chapter 11 I/O and Exception Handling 10 File LineNumberer.java 34: System.out.println("Error processing file:" + exception); 35: } 36: } 37: }
11
Chapter 11 I/O and Exception Handling 11 Self Check 1. What happens when you supply the same name for the input and output files to the LineNumberer program? 2. What happens when you supply the name of a nonexistent input file to the LineNumberer program?
12
Chapter 11 I/O and Exception Handling 12 Answers 1. When the PrintWriter object is created, the output file is emptied, which is the same file as the input file. The input file is now empty and the while loop exits immediately. 2. The program catches a FileNotFoundException, prints an error message, and terminates.
13
Chapter 11 I/O and Exception Handling 13 Command Line Arguments Three different ways to run a program Select “run” in compile environment Click an icon Type program name in terminal window Last method is called invoking the program from a command line When program is invoked from command line, you can provide more info to the program
14
Chapter 11 I/O and Exception Handling 14 Command Line Arguments Programs accept command line arguments For example, program could be written to allow user to specify input and output files on command line: Command line arguments are are placed in args parameter of main In this example args[0] is “input.txt” args[1] is “output.txt” java LineNumberer input.txt output.txt
15
Chapter 11 I/O and Exception Handling 15 Command Line Arguments It is up to the programmer to decide what to do with command line arguments It is customary to interpret arguments as follows If it starts with a hyphen, it is an option If it does not start with a hyphen, it is a file name For example, could use -c if comment delimiters are desired (e.g., if file is a program) java LineNumberer -c HelloWorld.java HelloWorld.txt
16
Chapter 11 I/O and Exception Handling 16 Command Line Arguments Example for(String a : args) { if(a.startsWith(“-”)) // It’s an option { if (a.equals(“-c”) useCommentDelimiters = true; } else if (inputFileName == null) inputFileName = a; else if (outputFileName == null) outputFileName = a; }
17
Chapter 11 I/O and Exception Handling 17 Command Line Arguments Are command line arguments a good idea? It depends… For casual or infrequent use, graphical user interface (GUI) is much better But for frequent use, GUI has some drawbacks For example, hard to automate, so it is hard to write a script to automate tasks
18
Chapter 11 I/O and Exception Handling 18 Therac-25 Incident Computerized device used for radiation treatment Between 1985 and 1987 at least 6 people got severe overdoses, some died Cause was a bug in the program that controlled the machine See the text
19
Chapter 11 I/O and Exception Handling 19 Error Handling Traditional approach: Method returns error code Problem: Might forget to check for error Failure notification may go undetected Problem: Calling method may not be able to do anything about failure Program must fail --- let its caller worry about it Many method calls would need to be checked
20
Chapter 11 I/O and Exception Handling 20 Error Handling Instead of programming for success… …you would always program for failure But this might make code hard to read x.doSomething() if (!x.doSomething()) return false;
21
Chapter 11 I/O and Exception Handling 21 Throwing Exceptions In Java: Exceptions Cannot be overlooked Sent directly to an exception handler, not just caller of failed method “Throw” an exception object to signal an exceptional condition Example: IllegalArgumentException // illegal parameter value IllegalArgumentException exception = new IllegalArgumentException("Amount exceeds balance"); throw exception;
22
Chapter 11 I/O and Exception Handling 22 Throwing Exceptions No need to store exception object in variable When an exception is thrown, method terminates immediately Execution continues with an exception handler throw new IllegalArgumentException("Amount exceeds balance");
23
Chapter 11 I/O and Exception Handling 23 Example public class BankAccount { public void withdraw(double amount) { if (amount > balance) { IllegalArgumentException exception = new IllegalArgumentException("Amount exceeds balance"); throw exception; } balance = balance - amount; }... }
24
Chapter 11 I/O and Exception Handling 24 Hierarchy of Exception Classes Figure 1: The Hierarchy of Exception Classes
25
Chapter 11 I/O and Exception Handling 25 Syntax 15.1: Throwing an Exception throw exceptionObject; Example: throw new IllegalArgumentException(); Purpose: To throw an exception and transfer control to a handler for this exception type
26
Chapter 11 I/O and Exception Handling 26 Self Check 1. How should you modify the deposit method to ensure that the balance is never negative? 2. Suppose you modify withdraw to throw exception if balance is negative. Then you construct a new bank account object with a zero balance and call withdraw(10). What is the value of balance afterwards?
27
Chapter 11 I/O and Exception Handling 27 Answers 1. Throw an exception if the amount being deposited is less than zero. 2. The balance is still zero because the last statement of the withdraw method was never executed.
28
Chapter 11 I/O and Exception Handling 28 Checked and Unchecked Exceptions Two types of exceptions: checked and unchecked Checked exceptions The compiler checks that you don't ignore them Caused by external circumstances that the programmer cannot prevent Majority occur when dealing with I/O For example, IOException
29
Chapter 11 I/O and Exception Handling 29 Checked and Unchecked Exceptions Two types of exceptions: checked, unchecked Unchecked exceptions Extend the class RuntimeException or Error They are the programmer's “fault” Examples of runtime exceptions Example of error: OutOfMemoryError NumberFormatException IllegalArgumentException NullPointerException
30
Chapter 11 I/O and Exception Handling 30 Checked and Unchecked Exceptions Categories are not perfect Scanner.nextInt throws unchecked InputMismatchException Programmer cannot prevent users from entering incorrect input This choice makes the class easy to use for beginning programmers Checked exceptions arise mostly when programming with files and streams
31
Chapter 11 I/O and Exception Handling 31 Checked and Unchecked Exceptions For example, use a Scanner to read a file But, FileReader constructor can throw a FileNotFoundException String filename =...; FileReader reader = new FileReader(filename); Scanner in = new Scanner(reader);
32
Chapter 11 I/O and Exception Handling 32 Checked and Unchecked Exceptions Two choices… Handle the exception or Tell compiler that you want method to be terminated when the exception occurs Use throws specifier; method throws a checked exception public void read(String filename) throws FileNotFoundException { FileReader reader = new FileReader(filename); Scanner in = new Scanner(reader);... }
33
Chapter 11 I/O and Exception Handling 33 Checked and Unchecked Exceptions For multiple exceptions, use commas Exception inheritance hierarchy: for example, if method can throw an IOException and FileNotFoundException, only use IOException Better to just throw exception than to handle it incompetently public void read(String filename) throws IOException, ClassNotFoundException
34
Chapter 11 I/O and Exception Handling 34 Syntax 15.2: Exception Specification accessSpecifier returnType methodName(parameterType parameterName,...) throws ExceptionClass, ExceptionClass,... Example: public void read(BufferedReader in) throws IOException Purpose: To indicate the checked exceptions that this method can throw
35
Chapter 11 I/O and Exception Handling 35 Self Check 3. Suppose a method calls the FileReader constructor and the read method of the FileReader class, which can throw an IOException. Which throws specification should you use? 4. Why is a NullPointerException not a checked exception?
36
Chapter 11 I/O and Exception Handling 36 Answer 3. The specification throws IOException is sufficient since FileNotFoundException is a subclass of IOException 4. Because programmers should simply check for null pointers instead of trying to handle a NullPointerException
37
Chapter 11 I/O and Exception Handling 37 Catching Exceptions Install an exception handler with try/catch statement try block contains statements that may cause an exception catch clause contains handler for an exception type
38
Chapter 11 I/O and Exception Handling 38 Catching Exceptions Consider this example Three possible exceptions FileReader can throw FileNotFoundException Scanner.Next can throw NoSuchElementException Integer.parseInt throws NumberFormatException String filename =...; FileReader reader = new FileReader(filename); Scanner in = new Scanner(reader); String input = in.next(); int value = Integer.parseInt(input);...
39
Chapter 11 I/O and Exception Handling 39 Catching Exceptions Example of try, catch try { String filename =...; FileReader reader = new FileReader(filename); Scanner in = new Scanner(reader); String input = in.next(); int value = Integer.parseInt(input);... } catch (IOException exception) { exception.printStackTrace(); } catch (NumberFormatException exception) { System.out.println("Input was not a number"); }
40
Chapter 11 I/O and Exception Handling 40 Catching Exceptions Statements in try block are executed If no exceptions occur, catch clauses are skipped If exception of matching type occurs, execution jumps to catch clause If exception of another type occurs, it is thrown, to be caught by another try block
41
Chapter 11 I/O and Exception Handling 41 Catching Exceptions catch (IOException exception) exception contains reference to the exception object that was thrown catch clause can analyze object to find out more details exception.printStackTrace() printout of chain of method calls that lead to exception
42
Chapter 11 I/O and Exception Handling 42 Syntax 15.3: General Try Block try { statement... } catch (ExceptionClass exceptionObject) { statement... } catch (ExceptionClass exceptionObject) { statement... }... Continued…
43
Chapter 11 I/O and Exception Handling 43 Syntax 15.3: General Try Block Example: try { System.out.println("How old are you?"); int age = in.nextInt(); System.out.println("Next year, you'll be " + (age + 1)); } catch (InputMismatchException exception) { exception.printStackTrace(); } Purpose: To execute one or more statements that may generate exceptions. If an exception occurs and it matches one of the catch clauses, execute the first one that matches. If no exception occurs, or an exception is thrown that doesn't match any catch clause, then skip the catch clauses.
44
Chapter 11 I/O and Exception Handling 44 Self Check 5. Suppose the file with the given file name exists and has no contents. Trace the flow of execution in the try block in this section. 6. Is there a difference between catching checked and unchecked exceptions?
45
Chapter 11 I/O and Exception Handling 45 Answers 5. The FileReader constructor succeeds, and it is constructed. Then the call in.next() throws a NoSuchElementException, and the try block is terminated. None of the catch clauses match, so none are executed. If none of the enclosing method calls catch the exception, the program terminates.
46
Chapter 11 I/O and Exception Handling 46 Answers 6. No, you catch both exception types in the same way, as you can see from the previous example, since IOException is a checked exception and NumberFormatException is an unchecked exception.
47
Chapter 11 I/O and Exception Handling 47 The finally clause Exception terminates current method Danger: Program can skip over essential code Example reader = new FileReader(filename); Scanner in = new Scanner(reader); readData(in); reader.close();// May never get here
48
Chapter 11 I/O and Exception Handling 48 The finally clause Must execute reader.close() even if exception occurs Use finally clause for code that must be executed "no matter what"
49
Chapter 11 I/O and Exception Handling 49 The finally clause FileReader reader = new FileReader(filename); try { Scanner in = new Scanner(reader); readData(in); } finally { reader.close(); } If an exception occurs, finally clause is also executed before exception is passed to its handler, so file is always closed
50
Chapter 11 I/O and Exception Handling 50 The finally clause Executed when try block is exited in any of 3 ways: After last statement of try block After last statement of catch clause, if this try block caught an exception When an exception was thrown in try block and not caught Recommendation: do not mix catch and finally clauses in same try block See example in textbook
51
Chapter 11 I/O and Exception Handling 51 Syntax 15.4: The finally clause try { statement... } finally { statement... } Continued…
52
Chapter 11 I/O and Exception Handling 52 Syntax 15.4: The finally clause Example: FileReader reader = new FileReader(filename); try { readData(reader); } finally { reader.close(); } Purpose: To ensure that the statements in the finally clause are executed whether or not the statements in the try block throw an exception.
53
Chapter 11 I/O and Exception Handling 53 Self Check 7. Why was the reader variable declared outside the try block? 8. Suppose the file with the given name does not exist. Trace the flow of execution of the code segment in this section.
54
Chapter 11 I/O and Exception Handling 54 Answers 7. If it had been declared inside the try block, its scope would only have extended to the end of the try block, and the catch clause could not have closed it. 8. The FileReader constructor throws an exception. The finally clause is executed. Since reader is null, the call to close is not executed. Next, a catch clause that matches the FileNotFoundException is located. If none exists, the program terminates.
55
Chapter 11 I/O and Exception Handling 55 You can design your own exception types, subclasses of Exception or RuntimeException Make it checked or unchecked exception? Designing Your Own Execution Types if (amount > balance) { throw new InsufficientFundsException( "withdrawal of " + amount + " exceeds balance of “ + balance); }
56
Chapter 11 I/O and Exception Handling 56 Make it unchecked exception Programmer could have called getBalance first Extend RuntimeException or one of its subclasses Supply two constructors 1.Default (do nothing) constructor 2.A constructor that accepts a message string describing reason for exception Designing Your Own Execution Types
57
Chapter 11 I/O and Exception Handling 57 Designing Your Own Execution Types public class InsufficientFundsException extends RuntimeException { public InsufficientFundsException() {} public InsufficientFundsException(String message) { super(message); } }
58
Chapter 11 I/O and Exception Handling 58 Self Check 9. What is the purpose of the call super(message) in the second InsufficientFundsException constructor? 10. Suppose you read bank account data from a file. Contrary to your expectation, the next input value is not of type double. You decide to implement a BadDataException. Which exception class should you extend?
59
Chapter 11 I/O and Exception Handling 59 Answers 9. To pass the exception message string to the RuntimeException superclass. 10. Exception or IOException are both good choices. Because file corruption is beyond the control of the programmer, this should be a checked exception, so it would be wrong to extend RuntimeException.
60
Chapter 11 I/O and Exception Handling 60 A Complete Program Program does the following… Asks user for name of file File expected to contain data values First line of file contains total number of values Remaining lines contain the data Typical input file: 3 1.45 -2.1 0.05
61
Chapter 11 I/O and Exception Handling 61 A Complete Program What can go wrong? File might not exist File might have data in wrong format Who can detect the faults? FileReader constructor will throw an exception when file does not exist Methods that process input need to throw exception if they find error in data format
62
Chapter 11 I/O and Exception Handling 62 A Complete Program What exceptions can be thrown? FileNotFoundException can be thrown by FileReader constructor IOException can be thrown by close method of FileReader BadDataException, a custom checked exception class
63
Chapter 11 I/O and Exception Handling 63 A Complete Program Who can remedy the faults that the exceptions report? Only the main method of DataSetTester program interacts with user In this example, main method should Catch exceptions Print appropriate error messages Give user another chance to enter a correct file
64
Chapter 11 I/O and Exception Handling 64 File DataSetTester.java 01: import java.io.FileNotFoundException; 02: import java.io.IOException; 03: import java.util.Scanner; 04: 05: public class DataSetTester 06: { 07: public static void main(String[] args) 08: { 09: Scanner in = new Scanner(System.in); 10: DataSetReader reader = new DataSetReader(); 11: 12: boolean done = false; 13: while (!done) 14: { 15: try 16: { Continued…
65
Chapter 11 I/O and Exception Handling 65 File DataSetTester.java 17: System.out.println("Please enter the file name: "); 18: String filename = in.next(); 19: 20: double[] data = reader.readFile(filename); 21: double sum = 0; 22: for (double d : data) sum = sum + d; 23: System.out.println("The sum is " + sum); 24: done = true; 25: } 26: catch (FileNotFoundException exception) 27: { 28: System.out.println("File not found."); 29: } 30: catch (BadDataException exception) 31: { 32: System.out.println ("Bad data: " + exception.getMessage()); Continued…
66
Chapter 11 I/O and Exception Handling 66 File DataSetTester.java 33: } 34: catch (IOException exception) 35: { 36: exception.printStackTrace(); 37: } 38: } 39: } 40: }
67
Chapter 11 I/O and Exception Handling 67 The readFile method of the DataSetReader class Constructs Scanner object Calls readData method Completely unconcerned with any exceptions Exceptions may occur, but this is not a good place to catch them
68
Chapter 11 I/O and Exception Handling 68 The readFile method of the DataSetReader class If there is a problem with input file, it simply passes the exception to caller public double[] readFile(String filename) throws IOException, BadDataException // FileNotFoundException is an IOException { FileReader reader = new FileReader(filename); try { Scanner in = new Scanner(reader); readData(in); } Continued…
69
Chapter 11 I/O and Exception Handling 69 The readFile method of the DataSetReader class finally { reader.close(); } return data; }
70
Chapter 11 I/O and Exception Handling 70 The readData method of the DataSetReader class Reads the number of values private void readData(Scanner in) throws BadDataException { if (!in.hasNextInt()) throw new BadDataException("Length expected"); int numberOfValues = in.nextInt(); data = new double[numberOfValues]; for (int i = 0; i < numberOfValues; i++) readValue(in, i); if (in.hasNext()) throw new BadDataException("End of file expected"); } Constructs an array Calls readValue for each data value
71
Chapter 11 I/O and Exception Handling 71 The readData method of the DataSetReader class Checks for two potential errors 1.File might not start with an integer 2.File might have additional data after reading all values Makes no attempt to catch any exceptions
72
Chapter 11 I/O and Exception Handling 72 The readValue method of the DataSetReader class private void readValue(Scanner in, int i) throws BadDataException { if (!in.hasNextDouble()) throw new BadDataException("Data value expected"); data[i] = in.nextDouble(); }
73
Chapter 11 I/O and Exception Handling 73 Scenario 1. DataSetTester.main calls DataSetReader.readFile 2. readFile calls readData 3. readData calls readValue 4. readValue doesn't find expected value and throws BadDataException 5. readValue has no handler for exception and terminates
74
Chapter 11 I/O and Exception Handling 74 Scenario 6. readData has no handler for exception and terminates 7. readFile has no handler for exception and terminates after executing finally clause 8. DataSetTester.main has handler for BadDataException ; handler prints a message, and user is given another chance to enter file name
75
Chapter 11 I/O and Exception Handling 75 File DataSetReader.java 01: import java.io.FileReader; 02: import java.io.IOException; 03: import java.util.Scanner; 04: 05: /** 06: Reads a data set from a file. The file must have // the format 07: numberOfValues 08: value1 09: value2 10:... 11: */ 12: public class DataSetReader 13: { Continued…
76
Chapter 11 I/O and Exception Handling 76 File DataSetReader.java 14: /** 15: Reads a data set. 16: @param filename the name of file holding the data 17: @return the data in the file 18: */ 19: public double[] readFile(String filename) 20: throws IOException, BadDataException 21: { 22: FileReader reader = new FileReader(filename); 23: try 24: { 25: Scanner in = new Scanner(reader); 26: readData(in); 27: } 28: finally 29: { 30: reader.close(); 31: } Continued…
77
Chapter 11 I/O and Exception Handling 77 File DataSetReader.java 32: return data; 33: } 34: 35: /** 36: Reads all data. 37: @param in the scanner that scans the data 38: */ 39: private void readData(Scanner in) throws BadDataException 40: { 41: if (!in.hasNextInt()) 42: throw new BadDataException("Length expected"); 43: int numberOfValues = in.nextInt(); 44: data = new double[numberOfValues]; 45: 46: for (int i = 0; i < numberOfValues; i++) 47: readValue(in, i); Continued…
78
Chapter 11 I/O and Exception Handling 78 File DataSetReader.java 48: 49: if (in.hasNext()) 50: throw new BadDataException("End of file expected"); 51: } 52: 53: /** 54: Reads one data value. 55: @param in the scanner that scans the data 56: @param i the position of the value to read 57: */ 58: private void readValue(Scanner in, int i) throws BadDataException 59: { Continued…
79
Chapter 11 I/O and Exception Handling 79 File DataSetReader.java 60: if (!in.hasNextDouble()) 61: throw new BadDataException("Data value expected"); 62: data[i] = in.nextDouble(); 63: } 64: 65: private double[] data; 66: }
80
Chapter 11 I/O and Exception Handling 80 Self Check 11. Why doesn't the DataSetReader.readFile method catch any exceptions? 12. Suppose the user specifies a file that exists and is empty. Trace the flow of execution.
81
Chapter 11 I/O and Exception Handling 81 Answers 11. It would not be able to do much with them. The DataSetReader class is a reusable class that may be used for systems with different languages and different user interfaces. Thus, it cannot engage in a dialog with the program user.
82
Chapter 11 I/O and Exception Handling 82 Answers 12. DataSetTester.main calls DataSetReader.readFile, which calls readData. The call in.hasNextInt() returns false, and readData throws a BadDataException. The readFile method doesn't catch it, so it propagates back to main, where it is caught.
Similar presentations
© 2024 SlidePlayer.com Inc.
All rights reserved.