Input, Output and Exceptions. COMS W1007 Introduction to Computer Science. Christopher Conway 24 June 2003

Transcription

1 Input, Output and Exceptions COMS W1007 Introduction to Computer Science Christopher Conway 24 June 2003

2 Input vs. Output We define input and output from the perspective of the programmer. Input is data that comes into the program, e.g., from a file or from the keyboard into a program variable. Ouput is data that goes out of the program, e.g., into a file or to the screen.

3 Byte vs. Character Streams Java has two kinds of I/O streams: byte streams and character streams Byte streams operate on arbitrary binary data. The parent classes of byte streams are InputStream and OutputStream. Character streams operate on textual data. The parent classes of character streams are Reader and Writer.

4 public abstract class InputStream { /* returns a value 0-255, * or -1 for end of input */ public abstract int read() ; /* read count bytes into buf at offset */ public int read(byte[] buf, int offset, int count) {... /* fill buf */ public int read(byte[] buf) {... public long skip(long count) {... /* how many bytes are available? */ public int available() {... public void close() {...

5 public abstract class Reader { /* returns a value , * or -1 for end of input */ public abstract int read() ; /* read count bytes into buf at offset */ public int read(char[] buf, int offset, int count) {... /* fill buf */ public int read(char[] buf) {... public long skip(long count) {... /* is there input ready? */ public boolean ready() {... public void close() {...

6 public abstract class OutputStream { /* writes b as a byte */ public abstract void write(int b) ; /* write count bytes from buf at offset */ public void write(byte[] buf, int offset, int count) {... /* write the entire buf */ public void write(byte[] buf) {... /* write any buffered values */ public void flush() {... public void close() {...

7 public abstract class Writer { /* writes ch as a char */ public abstract void write(int ch) ; /* write count bytes from buf at offset */ public void write(char[] buf, int offset, int count) {... /* write the entire buf */ public void write(char[] buf) {... public void write(string str, int offset, int count) {... public void write(string str) {... { /* write any buffered values */ public void flush() {... public void close() {...

8 Conversion Streams Classes are provided that convert between byte and character I/O. InputStreamReader takes a byte input stream as its source and produces the equivalent character input. OutputStreamWriter take a byte output stream as its target and converts character output into the equivalent byte form.

9 File Streams The file streams (FileInputStream, FileOutputStream, FileReader and FileWriter) enable byte and character I/O with files. Each has a constructor that takes a file name String and returns the corresponding stream. If you give a file output stream the name of a file that doesn t exist, it will create the file, if possible.

10 Filter Streams Some streams are defined by where they get their data (or put it); others are defined by what they do to the data. Ordinary streams read and write data from a particular source, e.g., a file, or a byte array. Filter streams process data that comes in from or goes out to another data stream, e.g., buffering streams, compressing/decompressing streams.

11 Filter Streams: Examples InputStream infile = new FileInputStream("foo.gz") ; int data = infile.read() ; /* data contains 1 byte of gzip compressed data. */ InputStream infile2 = new GZipInputStream( infile ) ; data = infile2.read() ; /* data contains 1 byte of decompressed data. */ OutputStream outfile = new GZipOutputStream( new FileOutputStream("bar.gz") ) ; outfile.write(12) ; /* bar.gz contains 1 compressed byte of data. */

12 Buffered Streams Not every filter stream has to transform the data. The buffered streams (BufferedInputStream, BufferedOutputStream, BufferedReader and BufferedWriter) make I/O more efficient by reading and writing in large blocks. Instead of one access to disk for every call to read or write, a buffered stream puts a chunk of data into a buffer in memory; calls to read or write act on the buffer until it runs out. Note: it is often necessary to call flush() to force output on a buffered output stream.

13 LineNumberReader The LineNumberReader input stream wraps a character input stream and keeps track of lines read. The method getlinenumber() returns the number of lines seens so far. LineNumberReader in = new LineNumberReader( new FileReader( "input.txt" ) ) ; String line ; while( (line = in.readline())!= null ) { System.out.println("Line "+in.getlinenumber() +": "+line) ;

14 Print Streams The print output streams (PrintStream and PrintWriter) are filter streams that provide print and println methods that take any of the basic types as parameters. The print streams output character data, i.e., println(123) is output as "123" (a 6-byte character string). System.out and System.err are static PrintStream objects. System.in is an InputStream.

15 Data Streams The data streams (DataInputStream and DataOutputStream) provide convenience methods for reading and writing all of the basic types as binary data. I.e., writeint(123) is output as 123 (a 32-bit binary-encoded integer). The data stream methods are of the form readint/writeint, readboolean/writeboolean, readfloat/writefloat, etc.

16 Network Streams Java allows you to access a file on the Internet as easily as you d access a file on your own computer. The class java.net.url represents a network resource. URL url = new URL(" ; InputStream in = url.openstream() ; int ch ; while( (ch = in.read())!= -1 ) {...

17 Exceptions I/O provides many opportunities for unexpected errors. What if the user deletes a file while we are trying to read it? What if the network connection goes dead while we try to connect to a URL? We call unexpected events in the life of a program exceptions. Java provides a mechanism for handling exceptions gracefully.

18 Exceptions: 2 If a method generates (throws) an exception, it must declare that exception in a throws clause. E.g., all of the InputStream methods throw IOException: public abstract int read() throws IOException ; If a method calls another method that may throw an exception, it must: throw the exception itself (declare it in a throws clause), or handle (catch) the exception

19 The Execution Stack When an exception is thrown, execution stops immediately and control is transferred to the calling method. If the exception is not caught, control is immediately transferred to the method that called that method. And so on. This chain of method calls is called the execution stack. This is what you see when an exception spills through to the terminal (e.g., a NullPointerException): a list of method names and line numbers detailing at what point the exception was thrown and how execution reached that point.

20 Catching Exceptions Exceptions are handled using a try-catch block. Code that may throw an exception is put inside a try block, followed by catch clauses that match a particular exception. try { InputStream infile = new FileInputStream("a.txt") ; int ch = infile.read() ; catch( FileNotFoundException e ) { System.err.println("No file a.txt.") ; catch( IOException e ) { System.err.println("Error reading a.txt") ;

21 Exception Types Exception is a subclass of Throwable. Particular exceptions subclass Exception to provide more descriptive error information. Exception has a method getmessage() that returns a description of the error encountered. try { InputStream infile = new FileInputStream("a.txt") ; catch( FileNotFoundException e ) { System.err.println( e.getmessage() ) ; /* "a.txt (No such file or directory)" */

22 Exception Types: 2 When an exception is thrown, the first assignment-compatible catch clause will match. That means that supertype clauses will handle subtype exceptions. try { InputStream infile = new FileInputStream("a.txt") ; int ch = infile.read() ; catch( Exception e ) { /* This clause catches everything. */ System.err.println("General error.") ; catch( FileNotFoundException e ) { /* This clause will never execute. */ System.err.println("Specific error.") ;

23 The finally Clause A try-catch block can have a finally clause containing code to be executed whether or not an exception is thrown. A finally clause is typically used to close any open streams and clean up any internal state. try { int ch = instream.read() ; catch( IOException e ) { System.err.println( e.getmessage() ) ; finally { instream.close() ; /* The stream gets closed whether or not * the read succeeds. */

24 Exceptions Inside Handlers If an exception is thrown inside a catch or finally clause, it will not be handled inside the same try block; execution will halt and control will be sent to the next method up the stack. InputStream infile = null ; try { infile = new FileInputStream("a.txt") ; catch( FileNotFoundException e ) { infile = new FileInputStream("a.txt") ; /* Calling method must handle * FileNotFoundException */

25 Unchecked Exceptions You may be wondering why you ve never been asked to catch a NullPointerException. NullPointerException is a subclass of RuntimeException, the parent class of all unchecked exceptions. Methods that throw unchecked exceptions are not required to be enclosed in a try-catch block. Other unchecked exceptions are: ArrayIndexOutOfBoundsException ClassCastException ArithmeticException

26 Errors Error is subclass of Throwable that encompasses runtime errors that are too serious to be caught. Some subclasses of Error that you ve probably spent some time with: NoClassDefFoundError NoSuchMethodError

27 Defining Exceptions To create your own exception, extend Exception. An exception should provide a constructor that takes information about the nature of the error and passes it to Exception as a message. public class ReallyBadException extends Exception { public ReallyBadException(int badness) { super("a really bad exception occured: " +badness+" out of 10") ;

28 Object Serialization We ve talked about how to read and write character data and binary data of a primitive type. What if we want to do I/O on an object? The process of reading or writing an object to an I/O stream is called object serialization. The streams that read and write object data are ObjectInputStream and ObjectOutputStream. Objects are serialized and deserialized using the methods writeobject and readobject.

29 Object Serialization: 2 Invoking writeobject causes all of the non-static fields of the object to be written to the stream. If a field is of an object type, the field itself will be serialized. The serialization process does not just operate on a single object: it operates on an entire set of objects that can be reached through the references starting with that object (a reference graph). Invoking readobject reconstitutes the reference graph and returns a reference to the root (i.e., the original object).

30 Serializable A class indicates it can be serialized by implementing the Serializable interface. The interface has no methods it is a marker interface. Any object fields of the class should also be Serializable. If the class is a subclass, its parent must have a no-arg constructor or itself be Serializable.

31 import java.io.* ; public class Foo implements Serializable { private int x, y ; public Foo(int x, int y) { this.x = x ; this.y = y ; public static void main(string[] args) { try { Foo a = new Foo(3,7) ; ObjectOutputStream out = new ObjectOutputStream ( new FileOutputStream( "a.tmp" ) ) ; out.writeobject(a) ;

32 ObjectInputStream in = new ObjectInputStream ( new FileInputStream( "a.tmp" ) ) ; Foo b = (Foo) in.readobject() ; catch( IOException e ) { System.err.println( e.getmessage() ) ;

33 Object Versions The serialization process assigns a version ID to every class. If we change anything about the class, the version ID will change. In order to deserialize a class, the version ID of the serialized version must exactly match that of the.class file. An attempt to deserialize a non-matching class will cause an InvalidClassException. To make superficially dissimilar versions of a class compatible with respect to serialization, we can define the constant: public static final long serialversionuid

34 Transient Fields Fields marked with the modifier transient are not serialized. As the name indicates, they are usually values that aren t part of the objects permanent state. public class Circle implements Serializable { private double r ; private transient double area ; public Circle(double r) { this.r = r ; area = Math.PI * r * r ;...

35 Customizing Serialization If dumping all of the object s fields isn t what we want to do, we can define the methods writeobject and readobject. private void writeobject( ObjectOutputStream out) throws IOException ; private void readobject( ObjectInputStream in) throws IOException ; A class that defines these methods takes responsibility for serializing its own fields.