OBJECT ORIENTED PROGRAMMING II LECTURE 22 GEORGE KOUTSOGIANNAKIS CS 201 OBJECT ORIENTED PROGRAMMING II LECTURE 22 GEORGE KOUTSOGIANNAKIS Copyright: 2016 Illinois Institute of Technology/ George Koutsogiannakis

Last Week’s Topics The java.io Package Reading Text Files Reading Structured Text Files Using StringTokenizer Reading using Streams Writing to Structured Text Files

New Topics Writing objects into a File. Reading objects from a File. Simple Recursion Recursion with a Return Value

Serialization Writing objects into a file involves a protocol of Java called: Serialization Objects are converted (serialized) into a byte stream and stored in the file. Reading objects from a file involves a protocol called deserialization. Objects are converted back to the particular data type that they belong to.

Serialization A State of an object is the particular value sof its attributes (fields) at a particular time. Saving a particular state via serialization is called “persistence”.

Writing Objects to a File To write an object to a file, its class must implement the Serializable interface, which indicates that: the object can be converted to a byte stream to be written to a file that byte stream can be converted back into a copy of the object when read from the file The Serializable interface has no methods to implement. All we need to do is: import the java.io.Serializable interface add implements Serializable to the class header i.e public class MyClass implements Serializable

The ObjectOutputStream Class The ObjectOutputStream class, coupled with the FileOutputStream class, provides the functionality to write objects to a file. The ObjectOutputStream class provides a convenient way to write objects to a file. Its writeObject method takes one argument: the object to be written.

Constructors for Writing Objects Class Constructor FileOutputStream FileOutputStream( String filename, boolean mode ) creates a FileOutputStream object from a String representing the name of a file. If the file does not exist, it is created. If mode is false, the current contents of the file, if any, will be replaced. If mode is true, writing will append data to the end of the file. Throws a FileNotFoundException. ObjectOutputStream ObjectOutputStream( OutputStream out ) creates an ObjectOutputStream that writes to the OutputStream out. Throws an IOException.

The writeObject Method See Examples 11.16 FlightRecord2.java and Example 11.17 WritingObjects.java Return value Method name and argument list void writeObject( Object o ) writes the object argument to a file. That object must be an instance of a class that implements the Serializable interface. Otherwise, a run-time exception will be generated. Throws an IOException.

Omitting Data from the File The writeObject method does not write any object fields declared to be static or transient. You can declare a field as transient if you can easily reproduce its value or if its value is 0. Syntax to declare a field as transient: accessModifier transient dataType fieldName Example: private transient double totalRevenue;

Reading Objects from a File The ObjectInputStream class, coupled with FileInputStream, provides the functionality to read objects from a file. The readObject method of the ObjectInputStream class is designed to read objects from a file. Because the readObject method returns a generic Object, we must type cast the returned object to the appropriate class. When the end of the file is reached, the readObject method throws an EOFException, so we detect the end of the file when we catch that exception.

Constructors for Reading Objects Class Constructor FileInputStream FileInputStream( String filename ) constructs a FileInputStream object from a String representing the name of a file. Throws a FileNotFoundException. ObjectInputStream ObjectInputStream( InputStream in ) creates an ObjectInputStream from the InputStream in. Throws an IOException.

The readObject Method See Example 11.18 ReadingObjects.java Note: Return value Method name and argument list Object readObject( ) reads the next object and returns it. The object must be an instance of a class that implements the Serializable interface. When the end of the file is reached, an EOFException is thrown. Also throws an IOException and ClassNotFoundException See Example 11.18 ReadingObjects.java Note: we detect reaching the end of the file in the EOFException catch block we use a finally block to close the file

Example Of Writing Objects We could serialize the VehicleA class by making a minor change to the class: public class VehicleA implements Serializable We can exclude certain fields of the class from being serialized (and thus have their values written) by using the keyword transient in front of the declaration of the field. i.e. private transient double init_v; private transient double init_d;

Example Of Writing Objects Now in a VehicleClient class we can save the state of a particular VehicleA object by writing it into a file. The file name usually has the extension .ser i.e. MyFile.ser Thus:

Example Of Writing Objects VehicleA va=new VehicleA(“My Vehicle”, 2, 3, 2.1, 3.5); try{ FileOutputStream fos=new FileOutputStream(“MyFile.ser”); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(va); oos.close(); } catch(IOException ioe) { System.out.println(“Error writing into file”); ioe.printStackTrace();

Example of Reading the Object From the File try{ FileInputStream fis = new FileInputStream(“MyFile.ser”); ObjectInputStream ois = new ObjectInputStream(fis); VehicleA vh = (VehicleA)ois.readObject(); ois.close(); } Catch(IOException ioe) { System.out.println(“Error writing into file”); ioe.printStackTrace(); We can output the object’s attributes and observe that the values are the same as the ones we wrote in the file.

Simple Recursion Sometimes large problems can be solved by transforming the large problem into smaller and smaller problems until you reach an easily solved problem. This methodology of successive reduction of problems is called Recursion. That easy-to-solve problem is called the base case. The formula that reduces the size of a problem is called the general case.

Recursive Methods A recursive method calls itself, i.e. in the body of the method, there is a call to the method itself. The arguments passed to the recursive call are smaller in value than the original arguments.

Simple Recursion When designing a recursive solution for a problem, we need to do the following: define the base case define the rule for the general case

Printing “Hello World” n Times Using Recursion In order to print “Hello World” n times (n is greater than 0), we can do the following: Print “Hello World” Print “Hello World” (n – 1) times This is the general case. We have reduced the size of the problem from size n to size (n – 1).

Printing “Hello World” n Times Using Recursion Printing “Hello World” (n – 1) times will be done by: Printing “Hello World” Printing “Hello World” (n – 2) times … and so on Eventually, we will arrive at printing “Hello World” 0 times: that is easy to solve; we do nothing. That is the base case.

Pseudocode for Printing “Hello World” n Times Using Recursion printHelloWorldNTimes( int n ) { if ( n is greater than 0 ) print “Hello World” printHelloWorldNTimes( n – 1 ) } // else do nothing

Coding the Recursive Method public static void printHelloWorldNTimes( int n ) { if ( n > 0 ) System.out.println( “Hello World” ); printHelloWorldNTimes( n – 1 ); } // if n is 0 or less, do nothing See Example 13.1 RecursiveHelloWorld.java

Recursion with a Return Value In a value-returning method, the return statement can include a call to another value-returning method. For example, public int multiplyAbsoluteValueBy3( int n ) { return ( 3 * Math.abs( n ) ); }

Recursion with a Return Value In a recursive value-returning method, the return statement can include a call to the method itself. The return value of a recursive value-returning method often consists of an expression that includes a call to the method itself: return ( expression including a recursive call to the method );

Calculating a Factorial The factorial of a positive number is defined as factorial( n ) = n! = n * ( n – 1 ) * ( n – 2 ) * … 3 * 2 * 1 By convention, factorial( 0 ) = 0! = 1 (The factorial of a negative number is not defined.) Can we find a relationship between the problem at hand and a smaller, similar problem?

Calculating a Factorial factorial( n ) = n * factorial( n – 1 ) At each step, the size of the problem is reduced by 1: we progress from a problem of size n to a problem of size (n – 1) A call to factorial( n ) will generate a call to factorial( n – 1 ), which in turn will generate a call to factorial( n – 2 ), …. Eventually, a call to factorial( 0 ) will be generated; this is our easy-to-solve problem. We know that factorial( 0 ) = 1. That is the base case.

Code for a Recursive Factorial Method public static int factorial( int n ) { if ( n <= 0 ) // base case return 1; else // general case return ( n * factorial( n – 1 ) ); } See Example 13.2 RecursiveFactorial.java

Common Error Trap In coding a recursive method, failure to code the base case will result in a run-time error. If the base case is not coded, when the method is called, the recursive calls keep being made because the base case is never reached. This eventually generates a StackOverflowError.

Study Guide Chapter 11 Chapter 13 Section 11.7, 11.8