Checking Account and help with code ?

Question

Hi all..my computer hung up on me, so I'm not sure if my last post went through. First of all thank you all for helping me out the other day with my question on the Bank Account. It continues :)
I'm trying to work on each class one by one..when I test my Checking Account, it isn't printing out the correct balance. The string method to print this is coming from the Withdrawal class...so I know it has to be somewhere in there but I can't seem to figure out why it isn't totalling the balance...or how to get it too.
Then when I test my MyBank class, it hangs up on line 63..which I could swear I have written correctly. Again I am getting a NullPointerException and I honestly think I have the line of code written right, but I'm guessing I dont.
Any help would be appreciated.
public abstract class BankAccount {
    public static final String bankName = "BrianBank";
    protected String custName;
    protected String pin;
    protected Transaction[] history;
    private double balance;
    private double amt, amount;
    private double bal, initBal;
    private int transactions;
    private final int MAX_HISTORY = 100;
    private int acct;
    protected BankAccount(String cname, String cpin, double initBal) {
     custName = cname;
     pin = cpin;
     balance = initBal;
     history = new Transaction[MAX_HISTORY];
     transactions =0;
    public double getBalance() {
     return balance;
    public void withdraw(double amt) {
     history [transactions] = new Withdrawal (bal, amt);
   balance = bal;
     amount = amt;
     balance -= amt;
   transactions = transactions + 1;     
    public void deposit(double amt) {     
     history [transactions] = new Deposit (bal, amt);
     balance = bal;
     amount = amt;
     balance += amt;
     transactions = transactions +1;
    // abstract method to return account number
    public abstract int getAcctNum();
    // abstract method to return a summary of transactions as a string
    public abstract String getStatement();
public class CheckingAccount extends BankAccount implements IncursFee
      private int transactions;
      private double balance, initBal, amt;
      private static final int NOFEE_WITHDRAWALS = 10;
      private static final double TRANSACTION_FEE = 5.00;
      public static final String bankName = "iBank";
      public static final int STARTING_ACCOUNT_NUMBER = 10000;
      private int checkingAccountNumber = STARTING_ACCOUNT_NUMBER;
      private static int accountNumberCounter = STARTING_ACCOUNT_NUMBER;
      private String custName;
      private String pin;
      public CheckingAccount (String cname, String cpin, double initBal)
         super (cname, cpin, initBal);
          custName = cname;
          pin = cpin;
         balance = initBal;
         accountNumberCounter++; 
         checkingAccountNumber = accountNumberCounter;
      //initialize a count of transactions
         transactions = 0;          
       public double getBalance()
         return balance;
       public void withdraw(double amt)
        super.withdraw (amt);
         transactions ++;
       public void deposit(double amt)
       super.deposit (amt);
         transactions ++;
       public int getAcctNum ()
         return checkingAccountNumber;     
       public String getStatement ()
         int i = 0;
         String output = "";
         while ( i < history.length && history[i] != null )
            output += history.toString () + "\n";
i++;
return output;     
public void deductFee(double fee)
if (transactions > NOFEE_WITHDRAWALS)
{  fee = TRANSACTION_FEE *(transactions - NOFEE_WITHDRAWALS);
super.withdraw(fee);
balance -=fee;
transactions = 0;
public interface IncursFee {
public abstract void deductFee(double fee);
public abstract class Transaction {
protected double initBal;
protected double tranAmt;
// constructor
protected Transaction(double bal, double amt) {
     initBal = bal;
     tranAmt = amt;
abstract public String toString();
public class Withdrawal extends Transaction
     private double initBal;
     private double amount;
     private static NumberFormat fmt = NumberFormat.getCurrencyInstance();
     public Withdrawal (double bal, double amt)
          super (bal, amt);
          initBal = bal;
          amount = amt;
     public String toString ()
     return "Balance : " + fmt.format(initBal) + "\n" + "Withdrawal : " + fmt.format(amount);
import java.text.NumberFormat;
public class Deposit extends Transaction
     private double initbal, balance;
     private double amount;
     private static NumberFormat fmt = NumberFormat.getCurrencyInstance();
     public Deposit (double bal, double amt)
     super (bal, amt);
     initbal = bal;
     amount = amt;
     public String toString ()
     return "Balance : " + fmt.format(initbal) + "\n" + "Deposit : " + fmt.format(amount);
public class TestCheckingAcct {
public static void main(String[] args) {
     BankAccount b1 = new CheckingAccount("Harry", "1234", 500.0);
     System.out.println (b1.getBalance ());
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.deposit(50);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.deposit(10);
     b1.withdraw(1);
     System.out.println(b1.getStatement());
// This interface specifies the functionality requirements of a bank
public interface Bank {
public abstract int openNewAccount(String customerName, String customerPIN, String accType, double initDepAmount);
public abstract void processWithdrawal(int accNum, String pin, double amount);
// executes a deposit on the specified acct by the amount
public abstract void processDeposit(int accNum, String pin, double amount);
// returns the balance of acct
public abstract double processBalanceInquiry(int accNum, String pin);
// returns summary of transactions
public abstract String processStatementInquiry(int accNum, String pin);
import java.util.ArrayList;
public class MyBank implements Bank
private ArrayList<BankAccount> savAccounts = new ArrayList<BankAccount>(); //dynamically grows
private ArrayList<BankAccount> chkAccounts = new ArrayList<BankAccount>(); //dynamically grows
private SavingsAccount sav;
private CheckingAccount chk;
private int accNum;
private String customerName, customerPIN, accType, pin;
private double initDepAmount, amount, balance;
public int openNewAccount(String customerName, String customerPIN, String accType, double initDepAmount)
this.customerName = customerName;
this.customerPIN = customerPIN;
this.accType = accType;
this.initDepAmount = initDepAmount;
if ( accType.equals("Savings"))
BankAccount savAcct = new SavingsAccount(customerName, customerPIN, initDepAmount);
try
savAccounts.add(savAcct);
catch (ArrayIndexOutOfBoundsException savAccounts)
return savAcct.getAcctNum();
else
CheckingAccount chkAcct = new CheckingAccount(customerName, customerPIN, initDepAmount);
     try
chkAccounts.add(chkAcct);
catch (ArrayIndexOutOfBoundsException chkAccounts)
return chkAcct.getAcctNum();
public void processWithdrawal (int accNum, String pin, double amount)
     this.accNum = accNum;
     this.pin = pin;
     this.amount = amount;
if (accNum >10000 && accNum < 20000)
     chk.withdraw (amount);
if (accNum >50000 && accNum <60000)
     sav.withdraw (amount);
public void processDeposit (int accNum, String pin, double amount)
     this.accNum = accNum;
     this.pin = pin;
     this.amount = amount;
if (accNum >10000 && accNum < 20000)
     chk.deposit (amount);
if (accNum >50000 && accNum <60000)
     sav.deposit (amount);
public double processBalanceInquiry (int accNum, String pin)
     this.accNum = accNum;
     this.pin = pin;
     this.balance = 0;
if (accNum >10000 && accNum <20000)
     balance = chk.getBalance ();
if (accNum >50000 && accNum <60000)
     balance = sav.getBalance ();
return balance;
public String processStatementInquiry(int accNum, String pin)
     this.accNum = accNum;
     this.pin = pin;
     this.statement = "";
if (accNum >10000 && accNum <20000)
statement = chk.getStatement ();
if (accNum >50000 && accNum <60000)
statement= sav.getStatement ();
     return statement;

Answer 1

Here's some quick code review:
public abstract class BankAccount {
public static final String bankName =
me = "BrianBank";
protected String custName;
protected String pin;
protected Transaction[] history;
private double balance;
private double amt, amount;
private double bal, initBal;
private int transactions;// make MAX_HISTORY private static final, too.
private final int MAX_HISTORY = 100;
private int acct;
protected BankAccount(String cname, String cpin,
pin, double initBal) {
     custName = cname;
     pin = cpin;
     balance = initBal;
     history = new Transaction[MAX_HISTORY];
     transactions =0;
public double getBalance() {
     return balance;
public void withdraw(double amt) {
     history [transactions] = new Withdrawal (bal, amt);
balance = bal;
     amount = amt;
     balance -= amt;// ++transactions above would be elegant.
transactions = transactions + 1;     
public void deposit(double amt) {     
     history [transactions] = new Deposit (bal, amt);
     balance = bal;
     amount = amt;
     balance += amt;
     transactions = transactions +1;
// abstract method to return account number// why abstract?
public abstract int getAcctNum();
// abstract method to return a summary of
y of transactions as a string// why abstract?
public abstract String getStatement();
public class CheckingAccount extends BankAccount
implements IncursFee
private int transactions;
private double balance, initBal, amt;
private static final int NOFEE_WITHDRAWALS =
WALS = 10;
private static final double TRANSACTION_FEE =
_FEE = 5.00;
public static final String bankName = "iBank";
public static final int STARTING_ACCOUNT_NUMBER
NUMBER = 10000;
private int checkingAccountNumber =
mber = STARTING_ACCOUNT_NUMBER;
private static int accountNumberCounter =
nter = STARTING_ACCOUNT_NUMBER;// BankAccount has a custName attribute; why does CheckingAccount need
// one if it extends BankAccount?
private String custName;
private String pin;
public CheckingAccount (String cname, String
String cpin, double initBal)
super (cname, cpin, initBal);
custName = cname;
pin = cpin;
balance = initBal;
accountNumberCounter++;
checkingAccountNumber =
tNumber = accountNumberCounter;
//initialize a count of transactions
transactions = 0;          
// same as BankAccount - why rewrite it?
public double getBalance()
return balance;
// same as BankAccount - why rewrite it?
public void withdraw(double amt)
super.withdraw (amt);
transactions ++;
// same as BankAccount - why rewrite it?
public void deposit(double amt)
super.deposit (amt);
transactions ++;
          // same as BankAccount - why rewrite it?
public int getAcctNum ()
return checkingAccountNumber;     
public String getStatement ()
int i = 0;
String output = "";
while ( i < history.length && history[i] !=
ory[i] != null )
output += history.toString () + "\n";
i++;
return output;     
public void deductFee(double fee)
if (transactions > NOFEE_WITHDRAWALS)
{  fee = TRANSACTION_FEE *(transactions -
ansactions - NOFEE_WITHDRAWALS);
super.withdraw(fee);
balance -=fee;
transactions = 0;
public interface IncursFee {
public abstract void deductFee(double fee);
public abstract class Transaction {
protected double initBal;
protected double tranAmt;
// constructor
// why protected? make it public.
protected Transaction(double bal, double amt) {
     initBal = bal;
     tranAmt = amt;
abstract public String toString();
public class Withdrawal extends Transaction
     private double initBal;
     private double amount;
private static NumberFormat fmt =
= NumberFormat.getCurrencyInstance();
     public Withdrawal (double bal, double amt)
          super (bal, amt);
          initBal = bal;
          amount = amt;
     public String toString ()
return "Balance : " + fmt.format(initBal) + "\n" +
+ "Withdrawal : " + fmt.format(amount);
import java.text.NumberFormat;
public class Deposit extends Transaction
     private double initbal, balance;
     private double amount;
private static NumberFormat fmt =
= NumberFormat.getCurrencyInstance();
     public Deposit (double bal, double amt)
     super (bal, amt);
     initbal = bal;
     amount = amt;
     public String toString ()
return "Balance : " + fmt.format(initbal) + "\n" +
+ "Deposit : " + fmt.format(amount);
public class TestCheckingAcct {
public static void main(String[] args) {
BankAccount b1 = new CheckingAccount("Harry",
, "1234", 500.0);
     System.out.println (b1.getBalance ());
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.deposit(50);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.withdraw(1);
     b1.deposit(10);
     b1.withdraw(1);
     System.out.println(b1.getStatement());
// This interface specifies the functionality
requirements of a bank
public interface Bank {
public abstract int openNewAccount(String
String customerName, String customerPIN, String
accType, double initDepAmount);
public abstract void processWithdrawal(int
(int accNum, String pin, double amount);
// executes a deposit on the specified acct by
t by the amount
public abstract void processDeposit(int accNum,
Num, String pin, double amount);
// returns the balance of acct
public abstract double processBalanceInquiry(int
(int accNum, String pin);
// returns summary of transactions
public abstract String
ring processStatementInquiry(int accNum, String
pin);
import java.util.ArrayList;
public class MyBank implements Bank
private ArrayList<BankAccount> savAccounts =
unts = new ArrayList<BankAccount>(); //dynamically
grows
private ArrayList<BankAccount> chkAccounts =
unts = new ArrayList<BankAccount>(); //dynamically
grows
private SavingsAccount sav;
private CheckingAccount chk;
private int accNum;
private String customerName, customerPIN,
erPIN, accType, pin;
private double initDepAmount, amount, balance;
public int openNewAccount(String customerName,
erName, String customerPIN, String accType, double
initDepAmount)
this.customerName = customerName;
this.customerPIN = customerPIN;
this.accType = accType;
this.initDepAmount = initDepAmount;
if ( accType.equals("Savings"))
BankAccount savAcct = new
vAcct = new SavingsAccount(customerName, customerPIN,
initDepAmount);
try
savAccounts.add(savAcct);
catch (ArrayIndexOutOfBoundsException
Exception savAccounts)
return savAcct.getAcctNum();
else
CheckingAccount chkAcct = new
hkAcct = new CheckingAccount(customerName,
customerPIN, initDepAmount);
     try
chkAccounts.add(chkAcct);
catch (ArrayIndexOutOfBoundsException
Exception chkAccounts)
return chkAcct.getAcctNum();
public void processWithdrawal (int accNum,
accNum, String pin, double amount)
     this.accNum = accNum;
     this.pin = pin;
     this.amount = amount;
if (accNum >10000 && accNum < 20000)
     chk.withdraw (amount);
if (accNum >50000 && accNum <60000)
     sav.withdraw (amount);
public void processDeposit (int accNum, String
String pin, double amount)
     this.accNum = accNum;
     this.pin = pin;
     this.amount = amount;
if (accNum >10000 && accNum < 20000)
     chk.deposit (amount);
if (accNum >50000 && accNum <60000)
     sav.deposit (amount);
public double processBalanceInquiry (int accNum,
String pin)
     this.accNum = accNum;
     this.pin = pin;
     this.balance = 0;
if (accNum >10000 && accNum <20000)
     balance = chk.getBalance ();
if (accNum >50000 && accNum <60000)
     balance = sav.getBalance ();
return balance;
public String processStatementInquiry(int accNum,
m, String pin)
     this.accNum = accNum;
     this.pin = pin;
     this.statement = "";
if (accNum >10000 && accNum <20000)
statement = chk.getStatement ();
if (accNum >50000 && accNum <60000)
statement= sav.getStatement ();
     return statement;
Very bad style with those brace placements. Pick a style and stick with it. Consistency is the key.
Your code isn't very readable.
You don't have a SavingsAccount here anywhere, even though your MyBank uses one.
You use JDK 1.5 generics yet you've got ArrayList as the static type on those declarations. Better to use the interface type List as the compile time type on the LHS.
You have a lot of compile time problems, and some incomprehensible stuff, but I was able to change it enough to my TestCheckingAcct run to completion. No NPE exceptions.
I'm not sure I agree with your design.
No SavingsAccount. The accounts I have ALL incur fees - no need for a special interface there. Savings accounts are usually interest bearing. That's the way they behave differently from checking accounts. Where do you have that?
You rewrite too much code. If you put behavior in the abstract BankingAccount class (a good idea), the whole idea is that concrete classes that extend BankingAccount don't need to overload any methods whose default behavior is correct for them.
I don't know that I'd have separate Deposit and Withdrawal to implement Transaction. I'd make Transaction concrete and have starting balance, ending balance, and a transaction type String (e.g., "DEPOSIT", "WITHDRAWAL")
It'd be good to see some thought put into exception handling. I don't see an OverdrawnException anywhere. Seems appropriate.
No transfer methods from one account to another. I often do that with my bank.
That's enough to get started.