找到一个银行账户的总数

Question

我是一个学生刚刚完成我的第一年学习Java，并有一个问题“创建一个方法，返回在银行总资金？”在考试中。我已经包括下面的类。我得到了大部分正确的方法，包括addAccount（），getBalance（），withdraw（）等，但不确定这个答案是什么。这可能比我想象的简单并且更简单（我必须使用for循环或某种类型的两个循环），但只是为了澄清合计总和的正确方法。这也出现在一家杂货店的C＃作业中，客户从不同的产品（例如水果蔬菜等）购买了货物，并且必须计算总计。

预先感谢您...

保罗

代码： 超类：

/** 
    A bank account has a balance that can be changed by 
    deposits and withdrawals. 
*/ 
public class BankAccount 
{ 
    //Declare balance field 
    private double balance; 

    /** 
     Constructs a bank account with a zero balance. 
    */ 
    public BankAccount() 
    { 
     balance = 0; 
    } 

    /** 
     Constructs a bank account with a given balance. 
     @param initialBalance the initial balance 
    */ 
    public BankAccount(double initialBalance) 
    { 
     balance = initialBalance; 
    } 

    /** 
     Deposits money into the bank account. 
     @param amount the amount to deposit 
    */ 
    public void deposit(double amount) 
    { 
     balance = balance + amount; 
    } 

    /** 
     Withdraws money from the bank account. 
     @param amount the amount to withdraw 
    */ 
    public void withdraw(double amount) 
    { 
     if (balance >= amount) 
     { 
     balance = balance - amount; 
     } 
     else 
     { 
      System.out.println("Withdrawal error: insufficent funds"); 
     } 
    } 

    /** 
     Gets the current balance of the bank account. 
     @return the current balance 
    */ 
    public double getBalance() 
    { 
     return balance; 
    } 

    /** 
     Transfers money from the bank account to another account 
     @param amount the amount to transfer 
     @param other the other account 
    */ 
    public void transfer(double amount, BankAccount other) 
    { 
     withdraw(amount); 
     other.deposit(amount); 
    } 

    public String toString() 
    { 
     return "Your Balance: "+ balance; 
    } 
} 

子类的支票帐户：

/** 
    A checking account that charges transaction fees. 
*/ 
public class CheckingAccount extends BankAccount 
{ 
    private int transactionCount; 
    private int transaction; 

    private static final int FREE_TRANSACTIONS = 0; 
    private static final double TRANSACTION_FEE = 2.0; 

    /** 
     Constructs a checking account with a given balance. 
     @param initialBalance the initial balance 
    */ 
    public CheckingAccount(double initialBalance) 
    { 
     // Construct superclass 
     super(initialBalance); 

     // Initialize transaction count 
     transactionCount = 0; 
    } 

    public void deposit(double amount) 
    { 
     transactionCount++; 
     // Now add amount to balance 
     super.deposit(amount); 
    } 

    public void withdraw(double amount) 
    { 
     transactionCount++; 
     // Now subtract amount from balance 
     super.withdraw(amount); 
    } 

    /** 
     Deducts the accumulated fees and resets the 
     transaction count. 
    */ 
    public void deductFees() 
    { 
     if (transactionCount > FREE_TRANSACTIONS) 
     { 
     double fees = TRANSACTION_FEE * 
       (transactionCount - FREE_TRANSACTIONS); 
     super.withdraw(fees); 
     } 
     transaction = transactionCount; 
    } 

    public String toString() 
    { 

     return super.toString() + "\t Your Transactions: "+ transaction; 
    } 

} 

子类储蓄帐户：

/** 
    An account that earns interest at a fixed rate. 
*/ 
public class SavingsAccount extends BankAccount 
{ 
    private double interestRate; 

    /** 
     Constructs a bank account with a given interest rate. 
     @param rate the interest rate 
    */ 
    public SavingsAccount(double rate) 
    { 
     interestRate = rate; 
    } 

    /** 
     Constructs a bank account with a given interest rate. 
     @param rate the interest rate 
    */ 
    public SavingsAccount(double rate, double initBalance) 
    { 
     super(initBalance); 
     interestRate = rate; 
    } 

    /** 
     Adds the earned interest to the account balance. 
    */ 
    public void addInterest() 
    { 
     double interest = getBalance() * interestRate + 100; 
     deposit(interest); 
    } 

     public String toString() 
    { 

     return super.toString() + "\t Your Interest rate: "+ interestRate; 
    } 

} 

Answer 1

你说得对。

如果您拥有BankAccounts或其子类的集合，那么可以在for循环中将它们简单地相加。

可以说，你有这样的事情（我假设有包含一个函数，给了我所有账户以某种方式银行对象）：

Collection<BankAccount> accounts = Bank.getAccounts(); 
Double sum = 0.0; 
for (BankAccount account : accounts) { 
    sum += account.getBalance(); 
} 

Answer 2

您正在思考一个循环的正确轨道。只需总结余额。

public static double totalBalance(Collection<BankAccount> accounts){ 
    double sum = 0.0; 
    for(BankAccount b : accounts){ 
     sum += b.getBalance(); 
    } 
    return sum; 
}