Exceptions and Working with Files

Transcription

1 Exceptions and Working with Files Creating your own Exceptions. You have a Party class that creates parties. It contains two fields, the name of the host and the number of guests. But you don t want to create a party, when the number of guests is less than 10. We also want to mention the name of the host, whose party couldn t be created. So we define the following classes public class PartyException extends Exception public PartyException(String name) super(name); // It will pass the name of the host to the // error message in the Exception } //End of constructor }// End of PartyException class Now we define the Party class that will create the Party public class Party String host = new String(); int guests; public Party(String hst, int gst) throws PartyException host = hst; guest = gst; if(gst < 10) throw new PartyException(hst); } // End of constructor } // End of Party class Finally we write the class that creates the parties.

2 public class ThrowParty public static void main(string[] args) try Party first = new Party( Jones, 15); Party second = new Party( Bob, 7); Party third = new Party( Sara, 20); } //end of try catch (PartyException e) System.out.print( Party Error: The party of ); System.out.println(e.getMessage() + couldn t be created ); } // end of catch }// end of main }// end of ThrowParty Assertions. They are used for consistency check, during development, and they are normally removed in the final version. Java has an assert statement. The assert keyword is followed by a Boolean expression. The purpose is to assert that something must be true at this point in your program. This serves two purposes, the idea what we assume to be true made it explicitly through the statement, and therefore a good documentation featureand the actual check that it is really true. Note that if an assert statement is true, nothing happens, but if it is false then an AssertionError exception would be thrown. The Assert statement has two forms, assert boolean-expression

3 assert boolean-expression: expression usually a String Note that by default the assertions are not enabled in the JVM (Java Virtual Machine). If you want to use the assertions in your code you should use the java command with the switch ea (shortcut for enableassertions). Consider the BankAccount class, with one Assertion, checking if we have entered the correct number of parameters, in the main method of the class (See exercise 7 for the rest of the class) 139 public static void main(string[] args) throws ArrayIndexOutOfBoundsException assert (args.length == 2) : "You must enter the interest and the deposit" ; 142 // first argument is the interest rate. Checking if it was entered 143 try 144 int size = args[0].length(); 145 } 146 catch (ArrayIndexOutOfBoundsException e) 147 System.err.println("I need you to enter the interest!"); 148 System.exit(0); 149 } // second argument is the amount deposited by month. Checking if it was entered try 155 int size = args[1].length(); 156 } 157 catch (ArrayIndexOutOfBoundsException e) 158 System.err.println("I need a deposit!"); 159 System.exit(0); 160 } 161 // if everything is correct, we read the values double dinterest = (double) Integer.parseInt(args[0]); 164 double dpermonth = (double) Integer.parseInt(args[1]); // Create my bank account BankAccount mybankaccount = new BankAccount(dInterest); // Make a deposit each month and show the growing of the

4 balance each year 173 System.out.println("Watch the balance of the account grow yearly"); 175 System.out.println(); for (int whichyear = 0; whichyear < 10; whichyear++) System.out.println("After year " + (whichyear+1)); 184 for (int nmonth = 0; nmonth < 12; nmonth++) //make monthly deposit mybankaccount.newdeposit(dpermonth); // perform the monthly changes mybankaccount.monthlychanges(); 193 } 194 System.out.println("$ " +mybankaccount.getbalance() ); } } If you compile the whole BankAccount class, with this new main method, and use the regular java BankAccount (without entering any value for the interest and the deposit) to run the program, the assertion will be ignored, and the ArrayIndexOutOfBoundsException will be thrown, telling you that You must enter the interest and the deposit. On the other hand, if you use java ea BankAccount 7 (you entered the interest, but not the deposit) the AssertionError will take precedence because it is located before the other Exceptions- and it will send the message "You must enter the interest and the deposit". As a matter of fact you get the message: (Copying from the screen) Note that the message is a little more confusing than in the regular exceptions that we can create, because as we said before it is intended for the programmer, in the development stages, not to be seen by the user. Another consequence of the way the assertions are handled is that we shouldn t mix assertions with actual code that we want always to be performed.

5 File-based Input/Output. A portion of the class hierarchy of the java.io package is shown below. Note that Readers and writers deal with textual data (Based around the char type) Streams deal with binary data. (Based around the byte type) Java.lang.Object File FileDescriptor Input Stream ByteArrayInputStream FileInputStream FiSrelterInputStream BufferedInputStream DataInputStream PushbackInputStream ObjectInputStream PipedInputStream SequenceInputStream OutputStream ByteArray OutputStream FileOutputStream FilterOutputStream BufferedOutputStream DataOutputStream PrintStream ObjectOutputStream PipedOutputStream RandomAccessFile Reader BufferedReader LineNumberReader CharArrayReader FilterReader PushbackReader InputStreamReader FileReader PipedReader StringReader Writer BufferedWriter CharArrayWriter

6 FilterWriter OutputStreamWriter FileWriter PipedWriter PrintWriter StringWriter The following picture tries to catch some of the hierarchy on a more visible tree structure. Note that both InputStream and OutputStream are abstract classes. They provide the capability to read from and write to a disk file. The FilterOutputStream descends from the OutputStream, and it is a parent of the PrintStream, used to send output to the standard output device (mostly the monitor). System.out is an object of the type PrintStream. We are going to deal mostly with text input and output, but we should know about the possibility of working with binary data. The Reader and Writer we will have a similar tree structure, based on the hierarchy incorporated in the indentation. These two classes are also abstract classes.

7 Text Output with the FileWriter. To write text to a file, you should have to follow the following three procedures: 1) Open the file 2) Write to the file 3) Close the file Anyone of them can fail, so you should anticipate the possibility of failure, throwing exceptions to protect your program. 1) You open the file by creating a FileWriter, to which you pass either a String the filename-, or a File object the file. 2) Then you write to the file using the write method that the FileWriter inherits from its supeclasses. 3) Finally we close the file to ensure that the output buffer has been flushed, and everything has been written to the disk file. Very Simple example, without catching the exceptions: import java.io.*; public class WriteChar // Exceptions could be generated when creating the file, or // writing to the file, or closing the file. We throw them public static void main(string[] args) throws IOException // Opening or creating the file FileWriter letters = new FileWriter("Thealphabet.txt"); for(int i =65; i< 91; i++) letters.write((char)i ); // writing to the file letters.write("\n" );

8 } // end of for letters.close(); // closing the file }// end of main } // end of WriteChar Note that the write method is polymorphic. You could use write(int) - It writes the character whose ASCII code is the value of the integer. write(char[], int, int) Writes from the specified character array with the indicated starting point and the number of characters written. write(string, int, int) Writes characters from the specified String using the indicated starting point and the number of characters written. Text Input with the FileReader. In this case, we have the same three steps that we found in the case of the output to a file, with the only difference that instead of using a write() method, we will use the read() method in one of its variants, or the readline() method, if we use the BufferedReader object, that defines that method. In other words, the FileReader can t read a line, unless it is wrapped into a BufferedReader Following the same example as before: import java.io.*; public class ReadChar // Exceptions could be generated when creating the file, or // reading from the file, or closing the file. We throw them public static void main(string[] args) throws IOException // Opening the file FileReader myletters = new FileReader("Thealphabet.txt"); // Reading from the file int mybyte; //Variable to hold the character read do mybyte = myletters.read();

9 // If not the end of file, then I print the good character if (mybyte!= -1) System.out.print((char) mybyte); } while (mybyte!= -1); // keep reading until the EOF //So we know we are done System.out.println("********************"); myletters.close(); // closing the fil }// end of main } // end of RadChar Note that the read method is polymorphic. You could use read(int) - It returns the ASCII code value of the next character in the file read(char[], int, int) Reads characters into the specified character array with the indicated starting point in the array and the number of characters to be read. As noted before, if we wanted to read a line from the text file, we will change the code given by: FileReader myletters = new FileReader("Thealphabet.txt"); into the following one: FileReader oldletters = new FileReader("Thealphabet.txt"); BufferedReader myletters = new BufferedReader(oldLetters); The BufferedReader gets the characters from the FileReader, and places them into a buffer with default size, because we didn t specify any size in the constructor of the BufferedReader. The File class When a File object is created in the program, no disk file is created. It keeps information about the file associated with it, in the fields of the object. We can check the methods of it, to see if the disk file exists -exists( )- and it can be read canread()- that could help us to avoid reading failures, for instance, later in the program. The Scanner class We have used the Scanner to read and parse information from the keyboard. But the Scanner object can be used to read and parse information from a file. See the next example:

10 1 2 /* A class to read information from a file to input data for a projection 3 * The file name: Projection.txt. Located in the directory of this program 4 * The file is assumed to contain simply some data in the following format: 5 * Every line contains the following fields, separated by commas: 6 * Kind of homogeneous point: String 7 * The four coordinates of the homogeneous points: Double 8 * The last line contains the distance: String and one Double: its value 9 10 Example: 11 View Reference Point, 3.0, 2.1, 3.2, Normal Vector, 3.0, -2.1, 3.1, 0 13 View Up vector, 4.1, 2.2, -3.5, 0 14 Distance, * Note that you could change the information in the file to import any kind of data 17 * into your program 18 */ 19 import java.io.*; 20 import java.util.*; public class Datafile // Showing exeception handling... Exceptions found by running program and 26 // blowing it up 27 private double [][] coordinates; 28 File en; 29 private String[] kind; // read and write can throw IO exceptions. So pass them along public Datafile1(String filename) kind = new String[4]; 36 coordinates = new double[4][4]; try read(filename); 41 } 42 catch ( IOException e) System.out.println(" Input File does not exist!"); 45 System.exit(0); 46 } 47 } // End of constructor public void read(string in) throws IOException // read and write can throw IO exceptions. So pass them along File en = new File(in); 54 if (!en.exists()) 55 throw new IOException();

11 56 if(!en.canread()) 57 throw new IOException(); 58 Scanner projfile = new Scanner(en); 59 int i = 0; 60 while ( projfile.hasnextline()) String thispoint = projfile.nextline(); 63 Scanner s = new Scanner(thispoint).useDelimiter("\\s*,\\s*"); 64 String thiskind = s.next(); 65 kind[i] = thiskind; 66 coordinates[i][0] = s.nextdouble(); 67 if (thiskind.equals("distance")) coordinates[3][1] = 0.0; 70 coordinates[3][2] = 0.0; 71 coordinates[3][3] = 0.0; 72 break; 73 } //end of if 74 coordinates[i][1] = s.nextdouble(); 75 coordinates[i][2] = s.nextdouble(); 76 coordinates[i][3] = s.nextdouble(); 77 i++; 78 } // end of while projfile.close(); // To show that the data had been read. 84 // Just one value as a token double muestra = coordinates [2][0]; 87 String mypoint = kind[2]; System.out.println(mypoint + " " + muestra ); 90 } // end of read public static void main(string[] args) Datafile1 mydata =new Datafile1("Projection.txt"); } // End of main } // End of Datafile1 Object serialization So far we have been reading from a file and writing to a file, characters, or String, or numbers. We want now to show how to read from a file and write to it, entire objects (a database, for instance), without recurring to save to a file on a field-by-field basis. Object serialization is the solution that let us write objects to the I/O streams, and then read them without defining any additional methods. In order to let the instance of a class to be serializable, we must tell the class that implements Serializable.

12 It would look like in the following example: import java.io /* * A class defined to be used in serialization operations */ public class ObjectToSave implements Serializable static final long serialversionuid = L; private int i; private String s; private transient double d; // transient means that this field will not be serialized. public ObjectToSave (int i, String s, double d) this.i = i; this.s = s; this.d = d; }..