Constructor issues with creating a new checking account object.

[Johnathan Beck]

Hi guys. I figured I would come here to get some help on some Java stuff. I am new to Java and taking it as part of my computer science major. I have been pretty good at it and I have learned a lot of things when it comes to Java. However I have hit a brick wall when it comes to a lab I am doing. Please be aware that these are academic exercises and I am not really looking for handouts since I do need to learn this. All I am asking for is some hints, suggestions, and some direction to the solution to the problem.

With that said here is where I am at.

I am working on a simulation of a bank with a series of checking and saving account objects to be stored in a database. I have created an ArrayList of type Account named accounts. However I am having a problem with adding a checking account object (and to a certain extent a savings account object. But once I figure this out adding a savings account object to the arraylist will be cake.) to my accounts ArrayList. At compile I am getting the following error:

Cannot find symbol - constructor Checking (java.lang.String,double,int)

I know I am on the right path but I can't seem to get past that whole constructor issue that the newChecking object is having. So that is where I am at a loss. Any thoughts and suggestions would be helpful and gratefully accepted.

Here's the code for the Bank class, Account class, and Checking class since they are related. If you want to look at the checking and savings classes let me know and I will post the code.

Bank class:

import java.util.ArrayList;
import java.util.Iterator;
import java.text.DecimalFormat;

/**
 * Manages a collection of bank accounts. 
 * 
 * @author Johnathan Beck 
 * @version 4/12/2011
 */
public class Bank
{
    private ArrayList<Account> accounts; //Declaration of a ArrayList of type Account called accounts
    private Account currentAccount; //The current account object
    private int accountNumber; //Declaration of the account number
    private double interestRate; //Declaration of the interest rate
    private DecimalFormat ir; //Call to the DecimalFormat library

    /**
     * Construct a empty bank account database
     */
    public Bank()
    {
        accounts = new ArrayList<Account>(); //Create the accounts ArrayList
        accountNumber = 1000; //Initalize accountNumber to 1000
        interestRate = 0.05; //Initialize the interest rate to 5%
        ir = new DecimalFormat();
        ir.applyPattern( "##0.00%; -##0.00%" );
    }

    /**
     * Create a new checking account
     * @param name  Acccount holder's name
     * @param balance   The initial account balance
     */
    public void newCheckingAccount(String name, double balance)
    {
        Checking newChecking = new Checking(name, balance, accountNumber); //This line has the constructor error
        if (balance >= 0) {
            //accounts.add(newChecking); //commented out to compile
            accountNumber++;
          }
        else {
            System.out.println("Error: Balance must be greater than or equal to zero to open new checking account");
        }
    }
}

Account Class:

import java.text.DecimalFormat;

/**
 * Simulates a bank account.
 * 
 * @author Johnathan Beck
 * @version 4/5/11
 */
public class Account
{
    private String name; //Declaration of the account holder's name.
    private int number; //Declaration of the account number.
    protected double balance; //Declaration of the account balance.
    private int type; //Declaration of the account type.
    protected DecimalFormat f; //Call to the DecimalFormat library.

    /**
     * Constructor for objects of class Account
     * @param name      The account holder's name
     * @param number    The account number
     * @param balance   The account balance
     * @parm type       The account type
     */
    public Account(String name, int number, double balance, int type)
    {
        this.name = name;
        this.number = number;
        if (balance < 0) { //Checks to see if the balance is less than 0
            balance = 0; //Sets the balance to 0 if condition is true
        }
        else {
            this.balance = balance; //initalize the balance as stated from the balance parameter
        }
        if (type == 0 || type == 1) { //Checks to see if the account type is 1 or 0
            this.type = type; //initalize the type as stated from the type parameter
        }
        else {
            type = 0; //Sets the account type to 0 (checking)
        }
        f = new DecimalFormat();
        f.applyPattern( "$#,##0.00;-$#,##0.00" );
    }
    
    /**
     * Prints out the account statement
     */
    public void print()
    {
        String accountType = ""; //Declaration of the account type string
        if (type == 0) { //Checks to see if account type is checking
            accountType = "Checking";
        }
        else if (type == 1) { //Checks to see if account type is savings
            accountType = "Savings";
        }
    System.out.println("Account Name = " + name);
    System.out.println("Account Number = " + number);
    System.out.println("Account Type = " + accountType);
    System.out.println("Account Balance = " + f.format(balance));
    }
    
    /**
     * Sets the account holder's name
     * @param owner     The account holder's name
     */
    public void setName(String owner)
    {
        name = owner;
    }
    
    /**
     * Sets the account number
     * @param accountNumber     The account number
     */
    public void setNumber(int accountNumber)
    {
        number = accountNumber;
    }
    
    /**
     * Sets the account balance
     * @param accountBalance    The account balance
     */
    public void setBalance (double accountBalance)
    {
        if (accountBalance < 0) { //checks condition if parameter entered is less than 0
            balance = 0;
        }
        else {
            balance = accountBalance; //Assigns accountBalance parameter to balance
        }
    }
    
    /**
     * Sets the account type
     * @param accountType   The account type
     */
    public void setType(int accountType)
    {
        if (accountType == 1 || accountType == 0) { //Checks to see if the accountType parameter is 1 or 0
            type = accountType; //the accountType parameter is assigned to type
        }
        else {
            type = 0;
        }
    }
    
    /**
     * Depositing funds to the account
     */
    public void deposit (double depositAmount)
    {
        if (depositAmount < 0) { //Checks to see if the depositAmount is less than 0
            System.out.println("Error: Deposit amount must be a positive number."); //Error statement
        }
        else {
            balance = balance + depositAmount; //Increase balance by deposit amount
        }
    }
    
    /**
     * Withdrawing funds from the account
     */
    public void withdrawal (double withdrawalAmount)
    {
        if (withdrawalAmount < 0) //Checks to see if the withdrawlAmount is less than 0
        {
            System.out.println("Error: Withdrawl amount must be a positive number."); //Error statement
        }
        else {
            balance = balance - withdrawalAmount; //Decrease balance by withdrawal amount
        }
    }
    
    /**
     * Returns the account holder's name
     * @return name
     */
    public String getName()
    {
        return name;
    }
    
    /**
     * Returns the account number
     * @return number
     */
    public int getNumber()
    {
        return number;
    }
    
    /**
     * Returns the account balance
     * @return balance
     */
    public double getBalance()
    {
        return balance;
    }
    
    /**
     * Returns the account type
     * @return type
     */
    public int type()
    {
        return type;
    }
}

Checking Class:

/**
 * Simulates a checking account
 * 
 * @author Johnathan Beck 
 * @version 4/7/11
 */
public class Checking extends Account
{
    private boolean overdrawn;

    /**
     * Constructor for objects of class Checking
     * @param name      Account holder's name
     * @param number    Account holder's number
     * @param balance   The account balance
     */
    public Checking(String name, int number, double balance)
    {
        super (name, number, balance, 0);
        overdrawn = false;
    }

    /**
     * Depositing funds to the checking account
     */
    public void deposit(double depositAmount)
    {
        super.deposit(depositAmount);
        if (getBalance() >= 0) { //Checks to see if the balance is greater than or equal to 0.
            overdrawn = false;
        }
        else {
            overdrawn = true;
        }
    }
    
    /**
     * Withdrawling funds from the checking account
     */
    public void withdrawal(double withdrawalAmount)
    {
        double maxWithdrawal = -(getBalance() * 0.10); //assigning local variable with formula for max withdrawal
        if (overdrawn == true) { //checks to see if the account is overdrawn
            System.out.println("Error: Account is overdrawn");
        }
        else if ((getBalance() - withdrawalAmount) >= maxWithdrawal) {
           //checks to see if the withdrawal request less than balance is greater than or equal to max withdrawal
            super.withdrawal(withdrawalAmount);
            System.out.println("Withdrawing " + f.format(withdrawalAmount));
            System.out.println();
            print();
            if (getBalance() < 0) //checks to see if the balance is less than 0
                overdrawn = true;
        }
        else {
            System.out.println("Error: Insufficient funds to withdraw " + f.format(withdrawalAmount) + " from this account");
        }
    }
    
    /**
     * Prints out the account statement
     */
    public void print()
    {
        super.print();
        System.out.println();
    }
}

[Henry Wong]

Johnathan Beck wrote:
Cannot find symbol - constructor Checking (java.lang.String,double,int)

Hint: Take a look at the parameters (specifically, the types) to your Checking class constructor. Do they match in how you are using it?

[Johnathan Beck]

Henry Wong wrote:

Johnathan Beck wrote:
Cannot find symbol - constructor Checking (java.lang.String,double,int)

Hint: Take a look at the parameters (specifically, the types) to your Checking class constructor. Do they match in how you are using it?

Well after your hint I looked at the checking class constructor and found out they did not match in how I was using it. Thank you so much for your hint. Without it I probably would of been looking at it for hours. Sometimes it takes another set of eyes to see what is going on.

I will remember to keep that in mind in the future. Thank you again for your help.