Java实验13 银行账户存取款业务

题目类别: 实验

关键字: 对象类型转换、覆盖、继承、多态

内容要求:

要求编写程序模拟银行账户的存、取款操作。按要求完成以下步骤：

     步骤 1：编写程序 Account.java，其中定义银行账户类 Account。该类中有账号、姓名、存款余额等数据域，余额默认是 0；有存款、取款、获取当前余额等方法。其中账号为长度为 12 位数字的字符串，姓名为字符串，存款余额为 double。

     步骤 2：编写名为 CreditAccount 类的信用卡账户类。该类继承自 Account 类，增加一个透支限额(double)数据域，透支限额默认为 1000。同时该类账户取款时允许透支，但不能超过透支限额。

    步骤 3：编写名为 SavingAccount 的储蓄账户类 SavingAccount。该类继承自 Account 类。该类账户取款时不允许透支。

    步骤 4：编写名为 Bank 的模拟银行类，其中可以存储多个类型可能是信用卡账户或储蓄账户的对象(可以用数组或 ArrayList 实现)。该类包含以下方法:

开户：即增加一个新的账户，注意：不允许两个账户的账号相同

销户：即删除一个已有的账户

查询账户：根据一个账号，查询有无该账号的账户

统计目前银行的存款总余额的方法。

统计目前银行的信用卡账户总透支金额的方法。

统计目前总账户数。

统计目前信用卡账户数

统计目前储蓄卡账户数

    步骤 5：编写客户端类 Client.java 完成以下功能：

编写一个静态方法，创建一个银行对象，并随机生成 10 个账号从 1000 0000 0000 0000 到 1000 0000 0000 0009、类型不同的账户。

main 方法中模拟几次开户操作。

main 方法中模拟几次销户操作。

模拟几个对指定账号的存款和取款操作。

输出银行的总账户数、总余额、总透支数、各类具体账户数。

实现代码：

Account类：

package cn.zg;

/**
 * @author zg
 */
public class Account {
    /**
     * 账户
     */
    private String account;
    /**
     * 姓名
     */
    private String name;
    /**
     * 存款余额
     */
    private double money;

    /**
     * 构造
     */
    public Account() {
        this.money=0.0;
    }

    public Account(String account){
        this.account=account;
    }

    public Account(String account, String name, double money) {
        this.account = account;
        this.name = name;
        this.money = money;
    }

    /**
     *访问器和修改器
     */
    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    /**
     * 存款
     * @param money 存款金额
     * @return 是否存款成功
     */
    public boolean addMoney(double money){
        this.money+=money;
        return true;
    }

    /**
     * 取款
     * @param money 取款金额
     * @return 是否取款成功
     */
    public boolean minusMoney(double money){
        if(this.money-money>0){
            this.money-=money;
            return true;
        }
        return false;
    }
}

CreditAccount类：

package cn.zg;

/**
 * @author zg
 */
public class CreditAccount extends Account{
    /**
     * 透支限额
     */
    private double overdue;

    /**
     * 构造
     */
    public CreditAccount() {
    }

    public CreditAccount(String account, String name, double money, double overdue) {
        super(account, name, money);
        this.overdue = overdue;
    }

    /**
     * 访问器和修改器
     */
    public double getOverdue() {
        return overdue;
    }

    public void setOverdue(double overdue) {
        this.overdue = overdue;
    }

    /**
     * 取款时允许透支，但不能超过透支限额
     * @param money 透支金额
     * @return 是否透支成功
     */
    public boolean over(double money){
        if(overdue-money<0){
            return false;
        }
        overdue-=money;
        return true;
    }
}

>

SavingAccount类：

package cn.zg;

/**
 * @author zg
 */
public class SavingAccount extends Account{
    public SavingAccount() {
    }

    public SavingAccount(String account, String name, double money) {
        super(account, name, money);
    }
}

Bank类：

package cn.zg;

import java.util.ArrayList;

/**
 * @author zg
 */
public class Bank {
    /**
     * 存储多个类型可能是信用卡账户或储蓄账户的对象
     */
    ArrayList<Account> accounts=new ArrayList<>();

    /**
     * 开户
     * @param account 待开户账户
     * @return 是否开户成功
     */
    public boolean add(Account account){
        for (Account acc : accounts) {
            if(acc.getAccount().equals(account.getAccount())){
                //  不允许两个账户的账号相同
                return false;
            }
        }
        return accounts.add(account);
    }

    /**
     * 销户
     * @param account 待销户账户
     * @return 是否销户成功
     */
    public boolean delete(Account account){
        for (Account acc : accounts) {
            if(acc.getAccount().equals(account.getAccount())){
                return accounts.remove(acc);
            }
        }
        return false;
    }

    /**
     * 根据一个账号，查询有无该账号的账户
     * @param account 要查询的账号
     * @return 有无该账号的账户
     */
    public boolean query(Account account){
        for (Account acc : accounts) {
            if(acc.getAccount().equals(account.getAccount())){
                return true;
            }
        }
        return false;
    }

    /**
     *
     * @return 统计目前银行的信用卡账户总透支金额
     */
    public double sumOfOverdue(){
        double sum=0;
        for (Account account : accounts) {
            if(account instanceof CreditAccount){
                sum+=(1000-((CreditAccount) account).getOverdue());
            }
        }
        return sum;
    }

    /**
     *
     * @return 统计目前银行的存款总余额
     */
    public double sumOfMoney(){
        double sum=0;
        for (Account account : accounts) {
            sum+=account.getMoney();
        }
        sum-=sumOfOverdue();
        return sum;
    }

    /**
     *
     * @return 统计目前总账户数
     */
    public int count(){
        return  accounts.size();
    }

    /**
     *
     * @return 统计目前信用卡账户数
     */
    public int countOfCredit(){
        int count=0;
        for (Account account : accounts) {
            if(account instanceof CreditAccount){
                count++;
            }
        }
        return count;
    }

    /**
     *
     * @return 统计目前储蓄卡账户数
     */
    public int countOfSaving(){
        int count=0;
        for (Account account : accounts) {
            if(account instanceof SavingAccount){
                count++;
            }
        }
        return count;
    }
}

Client类：

package cn.zg;

import java.util.Random;

/**
 * @author zg
 */
public class Client {

    public static void main(String[] args) {
        Bank bank=create();

        //  模拟几次开户操作
        boolean zg = bank.add(new SavingAccount("1000000000000001", "zg", 0));
        //  1000000000000001账号已存在，开户失败
        print(zg);
        boolean zcg = bank.add(new SavingAccount("1000000000000010", "zcg", 0));
        print(zcg);
        boolean zzw = bank.add(new CreditAccount("1000000000000011", "zzw", 0,1000));
        print(zzw);

        //  模拟几次销户操作
        print2(bank.delete(new Account("1000000000000001")));
        print2(bank.delete(new Account("1000000000000006")));
        print2(bank.delete(new Account("1000000000000009")));

        //  模拟几个对指定账号的存款操作
        for (Account account : bank.accounts) {
            if("1000000000000011".equals(account.getAccount())){
                account.addMoney(100000);
            }else if("1000000000000001".equals(account.getAccount())){
                account.addMoney(1000);
            }else if("1000000000000005".equals(account.getAccount())){
                account.addMoney(1688);
            }
        }

        //  模拟几个对指定账号的取款操作
        for (Account account : bank.accounts) {
            if("1000000000000011".equals(account.getAccount())){
                account.minusMoney(111);
            }else if("1000000000000001".equals(account.getAccount())){
                account.minusMoney(111);
            }else if("1000000000000005".equals(account.getAccount())){
                account.minusMoney(111);
            }
        }

        //  模拟所有信用卡账号的透支操作
        for (Account account : bank.accounts) {
            if(account instanceof CreditAccount){
                ((CreditAccount)account).over(111);
            }
        }

        //  输出银行的总账户数、总余额、总透支数、各类具体账户数
        System.out.println("银行的总账户数:"+bank.count());
        System.out.println("银行的总余额:"+bank.sumOfMoney());
        System.out.println("银行的总透支数:"+bank.sumOfOverdue());
        System.out.println("银行的信用卡账户数:"+bank.countOfCredit());
        System.out.println("银行的储蓄卡账户数:"+bank.countOfSaving());

    }

    /**
     * 随机生成 10 个账号从 1000 0000 0000 0000 到 1000 0000 0000 0009、类型不同的账户。
     * @return Bank对象
     */
    public static Bank create(){
        Bank bank = new Bank();
        Random random = new Random();
        String prefix="100000000000000";
        while(bank.count()<10){
            int i=random.nextInt(10);
            if(i%2==0){
                bank.add(new CreditAccount(prefix+i,"小"+i,0,1000));
            }else{
                bank.add(new SavingAccount(prefix+i,"小"+i,0));
            }
        }
        return bank;
    }


    public static void print(boolean flag){
        if(flag){
            System.out.println("开户成功！");
        }else{
            System.out.println("开户失败！");
        }
    }

    public static void print2(boolean flag){
        if(flag){
            System.out.println("销户成功！");
        }else{
            System.out.println("销户失败！");
        }
    }
}

效果展示：

本文地址：https://blog.csdn.net/BitcoinR/article/details/111939916