Bank项目

Accout.java

/**
 * 修改 Account 类
4． 重写 withdraw 方法使它不返回值（即 void）.声明方法抛出overdraftException异常
5． 修改代码抛出新异常，指明“资金不足”以及不足数额（请求的数额 扣除 当前余额）
 */
//修改 Account 类
//a. 修改 deposit 方法返回 true（意味所有存款是成功的）。
//b. 修改 withdraw 方法来检查提款数目是否大于余额。如果amt小于balance, 则从余额中扣除提款数目并返回 true，否则余额不变返回false。

public class Account {

//  创建 Account 类的两个子类：SavingAccount 和 CheckingAccount 子类

//  b. 创建 SavingAccount 类，该类继承 Account 类
//  c. 该类必须包含一个类型为 double 的 interestRate 属性
//  d. 该类必须包括带有两个参数（balance 和 interest_rate）的公有构造器。该构 造器必须通过调用 super(balance)将 balance 参数传递给父类构造器

    //  a. 修改 Account 类；将 balance 属性的访问方式改为 protected
    protected double balance;//余额,全局变量

    public Account(double init_balance){//初始化余额，参数传递给余额
        balance = init_balance;
    }

    public double getBalance(){//获取余额
        return balance;
    }

    public boolean deposit(double amt){//存款，增加金额,返回布尔值
        balance += amt;
        return true;
    }

    public void withdraw(double amt){//取款amt数额，减少余额,判断后，返回布尔值
        if (balance < amt) {//balance是余额 ，先判断           
            throw new OverdraftException("资金不足", (amt - balance));  //修改代码抛出新异常，指明“资金不足”以及不足数额（请求的数额 扣除 当前余额）       
        }
        this.balance -= amt;//判断过了再减少余额
    }

}

Bank.java

import java.util.*;

/**
 * 修改 Bank 类
修改 Bank 类，利用 ArrayList 实现多重的客户关系，不要忘记倒入必须的java.uti类
1． 将 Customer 属性的声明修改为List 类型，不再使用numberOfCustomers 属性。
2． 修改 Bank 构造器，将 customers 属性的声明修改为List 类型，不再使用numberOfcustomers 属性
3． 修改 addCustomer 方法，使用 add 方法
4． 修改 getCustomer 方法，使用 get 方法
5． 修改 getNumofCustomer 方法，使用 size 方法
*/

//a. 创建 Bank 类
public class Bank {
//1． 将 Customer 属性的声明修改为List 类型，不再使用numberOfCustomers 属性。
    private List<Customer> customers;

//  2． 修改 Bank 构造器，将 customers 属性的声明修改为List 类型，不再使用numberOfcustomers 属性
    private Bank(){
        customers = new ArrayList<Customer>();
    }

    // 修改 Bank 类，创建名为 getBanking 的公有静态方法，它返回一个 Bank类的实例。
    public static Bank getBank() {
        return bank;
    }

    // 单个的实例应是静态属性，且为私有。同样，Bank 构造器也应该是私有的
    private static Bank bank = new Bank();

//  3． 修改 addCustomer 方法，使用 add 方法  
    public void addCustomer(String f,String l){
        customers.add(new Customer(f, l));//List的add方法，存入元素
    }

//  4． 修改 getCustomer 方法，使用 get 方法
    public Customer getCustomer(int index) { 
        return customers.get(index);
    }

    public Iterator<Customer> getCustomers(){
        return customers.iterator();
    }

//  5． 修改 getNumofCustomer 方法，使用 size 方法
    public int getNumOfCustomers() {
        return customers.size();
    }

}

CheckingAccout.java

/**
1． CheckingAccount 类必须扩展 Account 类
2． 该类必须包含一个类型为 double 的 overdraftProtection 属性。
3． 该类必须包含一个带有参数（balance）的共有构造器。该构造器必须通过调用 super(balance)将 balance 参数传递给父类构造器。
4． 给类必须包括另一个带有两个参数（balance 和 protect）的公有构造器。该构造器必须通过调用 super(balance)并设置 overdragtProtection 属性，将 balance 参数传递给父类构造器。
5． CheckingAccount 类必须覆盖 withdraw 方法。此方法必须执行下列检查。如 果当前余额足够弥补取款 amount,则正常进行。如果不够弥补但是存在透支 保护，则尝试用 overdraftProtection 得值来弥补该差值（balance-amount）. 如果弥补该透支所需要的金额大于当前的保护级别。则整个交易失败，但余 额未受影响。
*/
public class CheckingAccount extends Account{
    private double overdraftProtection = -1;//透支保护.如果是-1，表示没有透支保护

    public CheckingAccount(double init_balance) {
        super(init_balance);
    }

    public CheckingAccount(double init_balance, double overdraftProtection) {
        super(init_balance);
        this.overdraftProtection = overdraftProtection;
    }   
//  修改 CheckingAccount 类
//  6． 重写 withdraw 方法使它不返回值（即 void）.声明方法抛出  overdraftException
//  7． 修改代码使其在需要时抛出异常。两种情况要处理：第一是存在没有透支保
//  护的赤字，对这个异常使用“no overdraft protection”信息。
//第二是 overdraftProtection 数 额 不 足 以 弥 补 赤 字 ： 对 这 个 异 常 可 使 用 ”Insufficient funds for overdraft protection” 信息
    public void withdraw(double amt) {
        //余额足够
        if (balance >= amt){//余额 大于 提取额
            balance -= amt;//余额 减少 提取额
        }else{

            if (overdraftProtection == -1){//没有透支保护
                throw new OverdraftException("no overdraft protection", amt - balance);
            }

            //透支保护足够
            if(overdraftProtection >= (amt - balance) ){//透支保护 大于 提取-余额
                overdraftProtection -= (amt - balance);//透支保护 减少 差额
                balance = 0;//余额清零
            }
            //余额不足，且透支保护不足
            else{
                throw new OverdraftException("Insufficient funds for overdraft protection", amt - balance);
            }
        }

    }
}

Customer.java

import java.util.*;

//修改 Customer 类
//6． 修改 Customer 类，使用 ArrayList 实现多重的账户关系。修改方法同上。

//创建Customer类
public class Customer {

//  a. 声明三个私有对象属性：firstName、lastName 和 account。
    private String firstName;
    private String lastName;
    //private Account[] accounts;//自定义的Account类 作为对象的属性
    //private int numberOfAccounts;//数组下标
    private List<Account> accounts;

//  b. 声明一个公有构造器，这个构造器带有两个代表对象属性的参数（f 和 l）  
    public Customer(String f, String l) {//构造器      
        firstName = f;
        lastName = l;
//      accounts = new Account[2];
        accounts = new ArrayList<Account>();
    }

//  c. 声明两个公有存取器来访问该对象属性，
//  方法 getFirstName 和 getLastName   返回相应的属性。
    public String getFirstName() {
        return firstName;
    }   
    public String getLastName() {
        return lastName;
    }

//  addAccount(Account) 方法来对 accounts[] 赋值。 
    public void addAccount(Account account) {
        //accounts[numberOfAccounts ++] = account;//数组下标自增
        accounts.add(account);//从参数传进去
    }

//  e. 声明 getAccount 方法以获取 account 属性。
    public Account getAccount(int index) {
        //return accounts[index];
        return accounts.get(index);
    }

    public int getNumOfAccounts(){//获取数组accounts下标
//      return numberOfAccounts;
        return accounts.size();//
    }

    public Iterator<Account> getAccounts(){
        return accounts.iterator();
    }

}

CustomerReport.java

import java.util.*;

/**
可选：修改 CustomerReport 类
修改 CustomerReport 类，使用 Iterator 实现对客户的迭代
1． 在 Bank 类中，添加一个名为 getCustomers 的方法，该方法返回一个客户列 表上的 iterator
2． 在 Customer 类中，添加一个名为个体 Accounts 的方法，该方法返回一个帐 户列表上的 iterator
3． 修改 CustomerReport 类，使用一对嵌套的 while 循环（而不是使用嵌套的for 循环），在客户的 iterator 与帐户的 iterator 上进行迭代
4． 重新编译运行 TestBanking 程序，应看到与上面一样的输出结果
 */
public class CustomerReport {

    public void generateReport() {

        Bank bank = Bank.getBank();//从Bank获取bank对象 保证 单例模式      
        Customer customer = null;

        System.out.println("\t\t\tCUSTOMERS REPORT");
        System.out.println("\t\t\t================");

        Iterator<Customer> customerIterator = bank.getCustomers();
        //for (int cust_idx = 0; cust_idx < bank.getNumOfCustomers(); cust_idx++) {
        while(customerIterator.hasNext()){
            //customer = bank.getCustomer(cust_idx);
            customer = customerIterator.next();

            System.out.println();
            System.out.println("Customer: " + customer.getLastName() + ", "
                    + customer.getFirstName());

            Iterator<Account> accountIterator = customer.getAccounts();

            while(accountIterator.hasNext()){
            //for (int acct_idx = 0; acct_idx < customer.getNumOfAccounts(); acct_idx++) {
                //Account account = customer.getAccount(acct_idx);
                Account account = accountIterator.next();

                String account_type = "";

                // Determine the account type
                /***
                 * Step 1: Use the instanceof operator to test what type of
                 * account we have and set account_type to an appropriate value,
                 * such as "Savings Account" or "Checking Account".
                 ***/
                if (account instanceof SavingAccount) {
                    account_type = "Savings Account";
                } else if (account instanceof CheckingAccount) {
                    account_type = "Checking Account";
                }

                // Print the current balance of the account
                /***
                 * Step 2: Print out the type of account and the balance. Feel
                 * free to use the currency_format formatter to generate a
                 * "currency string" for the balance.
                 ***/
                System.out.println(account_type + ": current balance is ￥"
                        + account.getBalance());
            }
        }

    }

}

OverdraftException.java

public class OverdraftException extends RuntimeException {


    private static final long serialVersionUID = 1L;
    /**
     * 创建 OverdraftException 类
1． 在 banking.domain 包中建立一个共有类 OverdraftException. 这个类扩展 Exception 类。
2． 添加一个 double 类型的私有属性 deficit.增加一个共有访问方法getDeficit
3． 添加一个有两个参数的共有构造器。deficit 参数初始化 deficit 属性
     */


    private double deficit;//亏损额

    public double getDeficit() {
        return deficit;
    }

    public OverdraftException(String msg,double deficit) {
        super(msg);
        this.deficit = deficit;
    }


}

SavingAccount.java

/**
    1. 创建 SavingAccount 类，该类继承 Account 类
//  2. 该类必须包含一个类型为 double 的 interestRate 属性
//  3. 该类必须包括带有两个参数（balance 和 interest_rate）的公有构造器。该构 造器必须通过调用 super(balance)将 balance 参数传递给父类构造器

 * @author Administrator
 *
 */
public class SavingAccount extends Account{
    private double interestRate;//加成员 利率

    public SavingAccount(double init_balance,double interestRate){
        super(init_balance);//调用父类的带参数构造器
        this.interestRate = interestRate;//传递参数
    }
}

TestBanking.java

public class TestBanking {

  public static void main(String[] args) {
    Bank     bank = Bank.getBank();
    Customer customer;
    CustomerReport report = new CustomerReport();

    // Create several customers and their accounts
    bank.addCustomer("Jane", "Simms");
    customer = bank.getCustomer(0);
    customer.addAccount(new SavingAccount(500.00, 0.05));
    customer.addAccount(new CheckingAccount(200.00, 400.00));

    bank.addCustomer("Owen", "Bryant");
    customer = bank.getCustomer(1);
    customer.addAccount(new CheckingAccount(200.00));

    bank.addCustomer("Tim", "Soley");
    customer = bank.getCustomer(2);
    customer.addAccount(new SavingAccount(1500.00, 0.05));
    customer.addAccount(new CheckingAccount(200.00));

    bank.addCustomer("Maria", "Soley");
    customer = bank.getCustomer(3);
    // Maria and Tim have a shared checking account
    customer.addAccount(bank.getCustomer(2).getAccount(1));
    customer.addAccount(new SavingAccount(150.00, 0.05));

    // Generate a report
    report.generateReport();
  }
}