Where to add your code ---------------------- The framework source file you are
ID: 3868905 • Letter: W
Question
Where to add your code
----------------------
The framework source file you are to modify is the "Accounting.java" file.
There is only 1 part to change. As usual, it is indicated by a comment block
that starts with 5 asterisks (*****). As explained there, and in your textbook,
you are to provide the entire body of the "balanceCheckBook()" method.
Starter code
------------
Use the try-with-resources form of the "try" statement as shown in this
week's outline. To get you started on the right foot, here is the code for
the local variables and the beginning of the "try" block:
double balance = 0.00;
double currentAmount;
Transaction transaction;
try (FileInputStream fis = new FileInputStream("transactions.obj");
ObjectInputStream ois = new ObjectInputStream(fis);)
// fis and cis are resources that will be automatically closed.
{
"while" loop
------------
Within the "try" block, create a "while" loop to process the object file.
The "while" loop's condition is (true). For each iteration of the "while" loop,
get one object from the object file, assigning it to the "transaction" variable.
To do this, use the "ois" object and its "readObject()" function. In this assignment
statement, explicitly cast the returned "Object" type to a "Transaction" object type
(on the right hand side of the assignment operator).
After obtaining the "transaction" object, use its "getAmount()" function to assign
its amount to "currentAmount". Then use the new value of "currentAmount" to update
"balance". Next, call "animate" as detailed in the framework comments.
Since, we are using the try-with-resources form of the "try" statement, there is no
need to provide a statement to close the object file, because that will be done
automatically. This also means, only a single "try" statement is needed. There is
no need for another (nested) "try" statement.
Since the "while" loop condition should be "while (true)", it will just keep reading
objects from the file until an EOFException causes it to cease, at which point control
will be transferred to the EOFException catch block.
"catch" blocks
--------------
The "try" block should be followed by 4 "catch" blocks for the following
exceptions in the order shown:
a) FileNotFoundException
In this catch block, display the following message to the system console:
"The file transactions.obj was not found."
b) ClassNotFoundException
In this catch block, display the following message to the system console:
"A ClassNotFoundException was encountered."
Normally, the "ClassNotFoundException" exception could be used to flag and
ignore individual corrupted objects in the input object file. This would require
using a second (nested) "try" block inside the "while" loop. However, since the
provided input object file, transactions.obj", has no corrupted objects that could
cause this exception, and to avoid making things overly complicated for this activity,
do not take that approach.
c) EOFException
In this catch block, display the following message to the system console:
"The end of the file was reached."
d) IOException
In this catch block, display the following message to the system console:
"An IOException was encountered."
End-of-file exception
---------------------
Here is the code for the end of file "catch" block:
// An EOF exception is part of normal processing:
catch (EOFException eofe)
{
System.out.println("The end of the file was reached.");
}
This "catch" block is executed when the code in the "try" block
encounters the end of the input file. After this "catch" block
executes, the program flow continues with the code after the last
"catch" block. This trailing code is where you display messages
to the user on the system console and in a pop-up window.
Because we are using the "try-with-resources" form of the "try"
statement, there is no need for a "finally" block.
Output messages
---------------
After the "catch" blocks, display both the console and the pop-up dialog
messages as shown in the "Example Programming Activity 11-2 Output" document
on our course web page.
Skip optional part
------------------
Skip the optional part of the textbook instructions that is labeled
"If you have time...".
Watch the related video
-----------------------
This assignment involves some complex concepts. However, given all that has been provided,
it really is an exercise in following instructions, using what you have been given, and doing
things step-by-step in the correct ORDER and syntax. Don't forget that there is also a video
provided about reading objects from a file.
Your solution should be short
-----------------------------
The only code in the "try" block is the "while" block mentioned in the instructions.
Not counting comments, blank lines, or the "animate" call, the "while" block can
easily be coded with 3 simple lines of code--each mentioned in the instructions.
There is 1 line of code inside each of the catch blocks. Each of these writes a
message to the system console as detailed in the instructions. Make sure you put
your catch blocks in the correct ORDER, as given in the instructions.
The code following the last catch block needs only 3 statements to display the
ending balance to the system console and in a pop-up window.
/* Accounting class
*
*/
import javax.swing.JOptionPane;
import java.text.DecimalFormat;
import javax.swing.JFrame;
import java.awt.Graphics;
import java.util.ArrayList;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;
import java.io.EOFException;
import java.io.FileNotFoundException;
public class Accounting extends JFrame
{
private BankAccount bankAccount;
public Accounting()
{
super("Reading objects from a file");
bankAccount = new BankAccount(getBackground());
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(300, 300);
setVisible(true);
}
public void balanceCheckBook()
{
//
// ***** Student writes the body of this method *****
//
// Using a while loop, read the file transactions.obj
// The file transactions.obj contains transaction objects
//
// You will need to call the animate method inside
// the body of the loop that reads the objects
//
// The animate method takes two arguments:
// a Transaction object, representing the transaction
// a double, representing the new checkbook balance
// So if these two variables are transaction and balance,
// then the call to animate will be:
//
// animate(transaction, balance);
//
// You should make that call in the body of your while
// loop, after you have updated the checkbook balance
//
// Student code starts here:
// Student code ends here.
}
public void writeTransactions(ArrayList transactionList)
{
//
// writing to file transactions.obj
//
try
{
FileOutputStream fos = new FileOutputStream("transactions.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
Transaction tempTransaction;
for (int i = 0; i < transactionList.size(); i++)
{
tempTransaction = (Transaction) transactionList.get(i);
oos.writeObject(tempTransaction);
}
oos.close();
}
catch (IOException ioe)
{
System.out.println(ioe.toString());
System.out.println(ioe.getMessage());
}
}
public void animate(Transaction currentTransaction, double currentBalance)
{
// set the currentTransaction data member in the bankAccount object
bankAccount.setCurrentTransaction(currentTransaction);
// set the currentBalance data member in the bankAccount object
bankAccount.updateBalance(currentBalance);
repaint();
try
{
Thread.sleep(3000); // wait for the animation to finish
}
catch (Exception e)
{
}
}
public void paint(Graphics g)
{
super.paint(g);
if (bankAccount != null)
{
bankAccount.draw(g);
}
}
public static void main(String[] args)
{
Accounting app = new Accounting();
// Generate an ArrayList of Transaction objects to write to file Transaction.obj
ArrayList transactionList = new ArrayList();
Check c1 = new Check(-500.00);
transactionList.add(c1);
Deposit d1 = new Deposit(3000.00);
transactionList.add(d1);
Withdrawal w1 = new Withdrawal(-400.00);
transactionList.add(w1);
c1 = new Check(-300.00);
transactionList.add(c1);
// write transactions as objects to file transaction.obj
app.writeTransactions(transactionList);
// read transaction.obj, balance the checkbook
app.balanceCheckBook();
}
}
Explanation / Answer
Code=============================================
import java.awt.Graphics;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class Accounting extends JFrame {
private BankAccount bankAccount;
public Accounting() {
super("Reading objects from a file");
bankAccount = new BankAccount(getBackground());
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(300, 300);
setVisible(true);
}
public void balanceCheckBook() {
//
// ***** Student writes the body of this method *****
//
// Using a while loop, read the file transactions.obj
// The file transactions.obj contains transaction objects
//
// You will need to call the animate method inside
// the body of the loop that reads the objects
//
// The animate method takes two arguments:
// a Transaction object, representing the transaction
// a double, representing the new checkbook balance
// So if these two variables are transaction and balance,
// then the call to animate will be:
//
// animate(transaction, balance);
//
// You should make that call in the body of your while
// loop, after you have updated the checkbook balance
//
// Student code starts here:
try {
double balance = 0.00;
double currentAmount;
Transaction transaction;
try (FileInputStream fis = new FileInputStream("transactions.obj");
ObjectInputStream ois = new ObjectInputStream(fis);)
// fis and cis are resources that will be automatically closed.
{
while (true) {
//Reading object from file
transaction = (Transaction)ois.readObject();
currentAmount=transaction.getAmount();
//Updating balance
balance+=currentAmount;
//Calling animate
animate(transaction,balance);
}
}
} catch (FileNotFoundException e) {
//Message on pop-up window
JOptionPane.showMessageDialog(null, "The file transactions.obj was not found.");
//Message on console
System.out.println("The file transactions.obj was not found.");
} catch (ClassNotFoundException e) {
//Message on pop-up window
JOptionPane.showMessageDialog(null, "A ClassNotFoundException was encountered.");
//Message on console
System.out.println("A ClassNotFoundException was encountered.");
} catch (EOFException e) {
//Message on pop-up window
JOptionPane.showMessageDialog(null, "The end of the file was reached.");
//Message on console
System.out.println("The end of the file was reached.");
} catch (IOException e) {
//Message on pop-up window
JOptionPane.showMessageDialog(null, "The file transactions.obj was not found.");
//Message on console
System.out.println("The file transactions.obj was not found.");
}
// Student code ends here.
}
public void writeTransactions(ArrayList transactionList) {
//
// writing to file transactions.obj
//
try {
FileOutputStream fos = new FileOutputStream("transactions.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
Transaction tempTransaction;
for (int i = 0; i < transactionList.size(); i++) {
tempTransaction = (Transaction) transactionList.get(i);
oos.writeObject(tempTransaction);
}
oos.close();
} catch (IOException ioe) {
System.out.println(ioe.toString());
System.out.println(ioe.getMessage());
}
}
public void animate(Transaction currentTransaction, double currentBalance) {
// set the currentTransaction data member in the bankAccount object
bankAccount.setCurrentTransaction(currentTransaction);
// set the currentBalance data member in the bankAccount object
bankAccount.updateBalance(currentBalance);
repaint();
try {
Thread.sleep(3000); // wait for the animation to finish
} catch (Exception e) {
}
}
public void paint(Graphics g) {
super.paint(g);
if (bankAccount != null) {
bankAccount.draw(g);
}
}
public static void main(String[] args) {
Accounting app = new Accounting();
// Generate an ArrayList of Transaction objects to write to file
// Transaction.obj
ArrayList transactionList = new ArrayList();
Check c1 = new Check(-500.00);
transactionList.add(c1);
Deposit d1 = new Deposit(3000.00);
transactionList.add(d1);
Withdrawal w1 = new Withdrawal(-400.00);
transactionList.add(w1);
c1 = new Check(-300.00);
transactionList.add(c1);
// write transactions as objects to file transaction.obj
app.writeTransactions(transactionList);
// read transaction.obj, balance the checkbook
app.balanceCheckBook();
}
}
===================================
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.