Question

Complete the following tasks, assuming that each applies to the same program: a) Write a statement that opens file "oldmast.txt" for input-use Scanner variable in01 dMaster. b) Write a statement that opens file "trans.txt" for input-use Scanner variable inTransaction. c) Write a statement that opens file "newmast.txt" for output (and creation) -use formatter variable outNewMaster. d) Write the statements needed to read a record from the file "oldmast.txt". Use the data to create an object of class Account-use Scanner variable in01 dMaster. Assume that class Account is the same as the Account class in Fig. 15.9 e) Write the statements needed to read a record from the file "trans.txt". The record is an object of class TransactionRecord-use Scanner variable inTransaction. Assume that class TransactionRecord contains method setAccount (which takes an int) to set the account number and method setAmount (which takes a double) to set the amount of the transaction. f) Write a statement that outputs a record to the file "newmast.txt". The record is an object of type Account-use Formatter variable outNewMaster.

Short answer

Open files using Scanner for input and Formatter for output, read records from input files into corresponding objects, and write object's data to output file.

Step-by-step solution

- Opening 'oldmast.txt' for input

To open a file for input using the Scanner class, create an instance of the Scanner and pass the File object referring to 'oldmast.txt' to its constructor. The code will look like this:Scanner in01dMaster = new Scanner(new File('oldmast.txt'));

- Opening 'trans.txt' for input

Similarly, to open 'trans.txt' for input, instantiate another Scanner object and pass the File object referring to 'trans.txt'. The code is as follows:Scanner inTransaction = new Scanner(new File('trans.txt'));

- Opening 'newmast.txt' for output

To open a file for output using the Formatter class, create an instance of Formatter and pass the filename 'newmast.txt' as a String to its constructor. The code for this step is:Formatter outNewMaster = new Formatter('newmast.txt');

- Reading a record from 'oldmast.txt'

To read a record from 'oldmast.txt', use the Scanner object in01dMaster's various methods such as nextInt() and nextDouble() depending on the data types expected in the record from the file. Assume Account expects an integer account number and a double balance. For example:int accountNumber = in01dMaster.nextInt();double balance = in01dMaster.nextDouble();Account account = new Account(accountNumber, balance);

- Reading a record from 'trans.txt'

To read a record from 'trans.txt', use the Scanner variable inTransaction to get the values needed to create a TransactionRecord object. Suppose we are expecting an integer account number and a double transaction amount. The code might be:int accountNumber = inTransaction.nextInt();double amount = inTransaction.nextDouble();TransactionRecord transaction = new TransactionRecord();transaction.setAccount(accountNumber);transaction.setAmount(amount);

- Outputting a record to 'newmast.txt'

To output a record to 'newmast.txt', use the Formatter variable outNewMaster to write to the file. Assume the Account object needs to output an integer account number and a double balance. The statement should thus be written like this:outNewMaster.format('%d %f', account.getAccountNumber(), account.getBalance());

Key concepts

Understanding the Java Scanner Class

In Java, the Scanner class is a popular tool for reading input, including data from files, which is central to handling input and output (I/O) operations. To use the Scanner class for file input, you first need to import it from the java.util package by adding import java.util.Scanner; to your code.

Following the import, a Scanner object can be instantiated by passing a File object to its constructor, just as we've seen in the exercise with in01dMaster. This allows you to read data from 'oldmast.txt'. The methods nextInt(), nextDouble(), nextLine(), and others provided by the Scanner class facilitate the reading of numeric values, lines of text, or even individual words from the file.

For students looking to deepen their grasp of file I/O, it's crucial to also understand how to properly manage resources. In Java, this often includes pattern like 'try-with-resources' to ensure files are closed properly after use. Additionally, handling exceptions like FileNotFoundException is another important aspect of robust file I/O operations.

Java Formatter Class Explained

Complementing the Scanner class, Java's Formatter class is akin to a writer that formats and outputs text to a variety of destinations, including files, streams, or even strings. To use the Formatter for writing to a file, as seen with the variable outNewMaster in the exercise, you once again begin by importing it with import java.util.Formatter;.

Create a new Formatter instance by passing the filename as a string to its constructor. This is demonstrated in the solution provided where 'newmast.txt' is the target file. The format() method of the Formatter class enables you to write formatted data into the file. It works similarly to printf() in Java, allowing you to specify the format specifiers such as %d for integers, %f for floating-point numbers, and so on. The ability to provide formatted output is essential for creating readable and organized data files.

It's also vital to consider closing the Formatter to avoid resource leaks, which can be achieved by calling the close() method once you're done writing to the file. Understanding error handling with Formatter, like dealing with SecurityException or FormatterClosedException, is also important for robust file writing operations.

Object-oriented Programming in Java

Object-oriented programming (OOP) is a programming paradigm that uses 'objects' — data structures consisting of data fields and methods together with their interactions — to design applications and computer programs. Java, at its core, is an object-oriented language.

The concepts of OOP such as classes, objects, inheritance, encapsulation, polymorphism, and abstraction are fundamental in Java. In the exercise, you can see OOP in action where a Scanner instance is used to instantiate Account and TransactionRecord objects. These classes likely encapsulate their respective data and provide methods to manipulate it. This encapsulation is the principle that suggests keeping the data (variables) and the code (methods) that manipulates the data together in one place, which is the class.

Further, the use of methods like setAccount and setAmount is an example of abstraction as it allows the user to interact with objects without knowing the internal implementation. The solution steps highlight the creation of these objects and how they are manipulated, which is a practice of OOP. For a holistic understanding, exploring these OOP concepts and how they apply not just in exercises but also in larger-scale software development is crucial.