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

你正在考虑循环的正确轨道。只需总结余额。

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

Answer 2

你是对的。

如果您有BankAccounts或其子类的集合，您可以在for循环中简单地对它们求和。

假设你有类似的东西（我假设有一个Bank对象包含一个以某种方式给我所有帐户的函数）：

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

查找银行帐户的总计

2 个答案: