欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-07 18:03:27
题目类别: 实验关键字: 对象类型转换、覆盖、继承、多态内容要求:要求编写程序模拟银行账户的存、取款操作。按要求完成以下步骤: 步骤 1:编写程序 Account.java,其中定义银行账户类 Account。该类中有账号、姓名、存款余额等数据域,余额默认是 0;有存款、取款、获取当前余额等方法。其中账号为长度为 12 位数字的字符串,姓名为字符串,存款余额为 double。 步骤 2:编写名为...

题目类别: 实验



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



内容要求:

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

     步骤 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("销户失败!");
        }
    }
}



效果展示:
Java实验13 银行账户存取款业务

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

相关标签: java 实验