Java银行账户管理系统实验总结

最新推荐文章于 2024-02-22 23:37:04 发布
最新推荐文章于 2024-02-22 23:37:04 发布
阅读量3.3k 收藏 18
点赞数 3
分类专栏： Java 文章标签： c++ java 编程语言 设计模式 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45750637/article/details/109298848
版权

银行账户管理系统

1. 代码编写过程说明

  • chapter4：使用基本面向对象思想实现简单功能，引入Account类；
  • chapter5: 在类中增添了静态属性与静态方法；
  • chapter6：增添字符串作为域变量，main方法中使用对象数组存储账户，引入Data类管理时间，与Account进行组合；
  • chapter7：使用了类的继承与派生，优化了类结构，父类为Account，子类为CreditAccount，引入Accumulate类，与Account类及其子类进行组合；
  • chapter8：运用了多态属性，将Account设为抽象类，CreditAccount为其实现类；
  • chapter9：使用ArrayList作为容器。
    类结构

2. 实现中发现的问题

C++中cosnt与Java中final的比较：

  • C++中：

    • const用于基本数据类型前修饰常量，其值不能更改；
    • const A *p = &a 表示其指向对象的内容不改变；
    • A cosnt *p = &a 表示其指向不能改变，即指针的值不能改变；
    • const修饰函数表示该函数为常成员函数，只能读取类中数据成员，不能修改；
    • public methodA(const classA *p){ }防止参数指针指向被修改；
    • public methodA(const int a){ }在程序中不能修改a的值。

  • Java中：

    • final用于基本数据类型前，为常量标识符；
    • final用于对象引用前，修饰常引用，其绑定对象不能改变为其他对象；
    • final用于类前修饰最终类，表示其不能有派生类；
    • final用于方法前修饰最终方法，表示其方法不能被其派生类覆盖，当可以在本类中重载；
    • final用在参数列表中不能表示其值不能修改的语义，要想达到此目的则在方法内部加入限制性操作语句。
C++中 虚函数与纯虚函数的区别 以及在Java中对应的思想与实现:
  • C++中，虚函数是实现多态的重要工具，对应java中的普通函数。
#include<iostream>
using namespace std;
class A
{
    public:
        void print()
        {		cout<<"This is A"<<endl;		}
};
 
class B : public A
{
    public:
        void print()
        {		cout<<"This is B"<<endl;		}
};
 int mian(){
    A a;
    B b;
    A *p1 = &a;
    A *p2 = &b;
    p1->print();
    p2->print();
    return 0;
 }

输出结果都为“This is A”

#include<iostream>
using namespace std;
class A
{
    public:
        virtual void print(){cout<<"This is A"<<endl;}
};
class B : public A
{
    public:
    void print(){cout<<"This is B"<<endl;}
};

int main(){
    A a;
    B b;
    A *p1 = &a;
    A *p2 = &b;
    p1->print();
    p2->print();
    return 0;
}

分别输出“This is A”和“This is B”

通过使用Virtual定义虚函数，使基类的对象指针可以通过统一的接口访问到基类及其派生类的同名函数。

class AClass {
    public void Print() {
        System.out.println("this is A");
    }
}

class BClass extends AClass {
    public void Print() {
        System.out.println("this is B");
    }
}

public class TestA {
    public static void main(String[] args) {
        AClass a = new AClass();
        BClass b = new BClass();
        AClass pa = a;
        AClass pb = b;
        a.Print();
        b.Print();
    }
}

分别输出“this is A”和“this is B”

在Java中，直接使用普通方法和基类引用即可访问到父类和其派生类的同名方法。

  • C++中的纯虚函数也是其实现多态的重要方式，对应着Java中的抽象方法。

C++中纯虚函数是只有声名没有实现的方法，其实现在其子类中。含有纯虚函数的类为抽象类

virtual void deposit(const Date &date, double amount, const std::string &desc) = 0;
	//取出现金，date为日期，amount为金额，desc为款项说明
	virtual void withdraw(const Date &date, double amount, const std::string &desc) = 0;
	//结算（计算利息、年费等），每月结算一次，date为结算日期
	virtual void settle(const Date &date) = 0;
	//显示账户信息

以上在Java中对应为：

	abstract public void deposit(Data data,double amount,String desc);
    abstract public void withdraw(Data data,double amount,String desc);
    abstract public void settle(Data data);

Java中，抽象方法只有声名没有实现，用关键词abstract修饰，含有抽象方法的类为抽象类，也用abstract修饰。其子类必须实现其方法。

3.代码展示

工程结构总预览
main方法

package chapter9;
import java.util.ArrayList;
import java.util.Scanner;

public class BankManageSystem {
    public static void main(String[] args) {
        Data data = new Data(2008,11,1);

        ArrayList<Account> account = new ArrayList<>();

        System.out.println("MENU\n"+
                "(a)add account \n"+
                "(d)deposit \n" +
                "(w)withdraw \n" +
                "(s)show \n" +
                "(c)change day \n" +
                "(n)next month \n" +
                "(e)exit");

        char cmd;
        Scanner scanner = new Scanner(System.in);

        do {
            data.show();
            System.out.print("\tTotal: "+Account.getTotal()+"\tcommand> ");

            char type;
            int index,day;
            double amount,credit,rate,fee;
            String decs,id;

            cmd = scanner.next().charAt(0);
            switch (cmd) {
                case 'a':
                    Scanner sc = new Scanner(System.in);
                    System.out.print("type> ");
                    type = scanner.next().charAt(0);
                    System.out.println(type);
                    System.out.print("ID> ");
                    id = sc.nextLine();
                    System.out.print("*"+id+"* ");
                    if(type == 's') {
                        System.out.print("rate> ");
                        rate = scanner.nextDouble();
                        account.add(new SavingAccount(data,id,rate));
                    } else {
                        System.out.print("credit rate fee> ");
                        credit = scanner.nextDouble();
                        rate = scanner.nextDouble();
                        fee = scanner.nextDouble();
                        account.add(new CreditAccount(data,id,credit,rate,fee));
                    }
                    break;

                case 'd':
                    System.out.print("index> ");
                    index = scanner.nextInt();
                    System.out.print("amount> ");
                    amount = scanner.nextInt();
                    System.out.print("desc> ");
                    decs = scanner.nextLine();
                    account.get(index).deposit(data,amount,decs);
                    break;

                case 'w':
                    System.out.print("index amount> ");
                    index = scanner.nextInt();
                    amount = scanner.nextInt();
                    System.out.print("desc> ");
                    decs = scanner.nextLine();
                    account.get(index).withdraw(data,amount,decs);
                    break;

                case 's':
                    for(int i = 0; i<account.size(); i++) {
                        System.out.print("["+i+"]");
                        account.get(i).show();
                    }
                    break;

                case 'c':
                    day = scanner.nextInt();
                    if(day > data.getDay()) {
                        System.out.print("You cannot specify a previous day");
                    } else if(day > data.getMaxDay()) {
                        System.out.print("Invalid day");
                    } else {
                        data = new Data(data.getYear(),data.getMonth(),day);
                    }
                    break;

                case 'n':
                    if(data.getMonth() == 12) {
                        data = new Data(data.getYear()+1,1,1);
                    } else {
                        data = new Data(data.getYear(), data.getMonth()+1, 1 );
                    }
                    for (Account value : account) {
                        value.settle(data);
                    }
                    break;

                default:
                    break;
            }

        } while (cmd != 'e');
    }
}

主体类

----------------------ACCOUNT----------------------------
abstract public class Account {
    private String id;
    private double balance;
    static private double total = 0;

    protected Account(Data data,String id) {
        this.id = id;
        balance = 0;
        data.show();
        System.out.println("\t#"+id+" created");
    }

    protected void record(Data data,double amount,String desc) {
        amount = Math.floor(amount*100 + 0.5)/100;
        balance += amount;
        data.show();
        System.out.println("\t#"+id+"\t"+amount+"\t"+balance+"\t"+desc);
    }

    protected void error(String msg) {
        System.out.println("ERROR(#"+id+"): "+msg);
    }

    public String getId() {
        return id;
    }

    public double getBalance() {
        return balance;
    }

    public static double getTotal() {
        return total;
    }

    public void show(){
        System.out.println(id+"\tBalance: "+balance);
    }

    abstract public void deposit(Data data,double amount,String desc);
    abstract public void withdraw(Data data,double amount,String desc);
    abstract public void settle(Data data);
}

---------------------CREDITACCOUNT-----------------------------

public class CreditAccount extends Account{
    private Accumulator acc;
    private double credit;
    private double rate;
    private double fee;

    public CreditAccount(Data data,String id,double credit,double rate,double fee) {
        super(data,id);
        this.credit = credit;
        this.rate = rate;
        this.fee = fee;
        acc = new Accumulator(data,0);
    }

    private double getDebt() {
        double balance = getBalance();
        return (balance<0 ? balance : 0);
    }

    public double getCredit() {
        return credit;
    }

    public double getRate() {
        return rate;
    }

    public double getFee() {
        return fee;
    }

    public double getAvailableCredit() {
        if(getBalance() < 0) {
            return credit + getBalance();
        } else {
            return credit;
        }
    }

    public void deposit(Data data,double amount,String desc) {
        record(data,amount,desc);
        acc.change(data,getDebt());
    }

    public void withdraw(Data data,double amount,String desc) {
        if(amount - getBalance() > credit) {
            error("not enough credit");
        } else {
            record(data,-amount,desc);
            acc.change(data,getDebt());
        }
    }

    public void settle(Data data) {
        double interest = acc.getSum(data)*rate;
        if(interest != 0) {
            record(data,interest,"interest");
        }
        if(data.getMonth() == 1) {
            record(data,-fee,"annual fee");
        }
        acc.reset(data,getDebt());
    }

    public void show() {
        super.show();
        System.out.println("\tAvailable credit:"+getAvailableCredit());
    }

}

----------------------SAVINGACCOUNT----------------------------

public class SavingAccount extends Account {
    private Accumulator acc;
    private double rate;

    public SavingAccount(Data data,String id,double rate) {
        super(data, id);
        this.rate = rate;
        acc = new Accumulator(data,0);
    }

    public double getRate(){
        return rate;
    }

    public void deposit(Data data,double amount,String desc) {
        record(data,amount,desc);
        acc.change(data,getBalance());
    }

    public void withdraw(Data data,double amount,String desc) {
        if (amount > getBalance()) {
            error("not enough money");
        } else {
            record(data,-amount,desc);
            acc.change(data,getBalance());
        }

    }

    public void settle(Data data) {
        if(data.getMonth() == 1) {
            double interest = (acc.getSum(data)*rate)/
                    (data.minus(new Data(data.getYear()-1,1,1)));
            if(interest != 0) {
                record(data,interest,"interest");
            }
            acc.reset(data,getBalance());
        }
    }
}

封装的其他类

----------------------DATA-------------------------
public class Data {
    private int year;
    private int month;
    private int day;
    private int totalDays = 0;
    final private int[] DAYS_BEFORE_MONTH;

    Data(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;

        DAYS_BEFORE_MONTH = new int[] { 0, 31, 59, 90, 120, 151,
                181, 212, 243, 273, 304, 334, 365 };

        if(day <= 0 || day > getMaxDay()) {
            System.out.print("Invalid data:");
            show();
            System.exit(1);
        }


        int years = year - 1;
        totalDays = year*365 + years/4 - years/100 + years/400
                + DAYS_BEFORE_MONTH[month - 1] + day;
        if (isLeapYear() && month > 2){
            totalDays++;
        }
    }

    /**
     * 判断是否为润年
     * @return 是否为润年
     */
    private boolean isLeapYear(){
        return year%4==0 && year%100!=0 || year%400==0 ;
    }

    public int getYear(){
        return year;
    }
    public int getDay() {
        return day;
    }
    public int getMonth() {
        return month;
    }

    public int getMaxDay(){
        if( isLeapYear() && month==2 ){
            return 29;
        } else {
            return DAYS_BEFORE_MONTH[month] - DAYS_BEFORE_MONTH[month-1];
        }
    }

    /**
     * 计算储蓄的时长
     * @param d 结算开始日期
     * @return  时长
     */
    public int minus(Data d){
        return this.totalDays - d.totalDays;
    }

    public void show(){
        System.out.println(getYear()+" - "+getMonth()+"-"+getMonth());
    }
}
----------------ACCUMULATOR----------------------
public class Accumulator {
    private Data lastData;
    private double value;
    private double sum;

    public Accumulator(Data data,double value) {
        lastData = data;
        this.value = value;
        sum = 0;
    }

    public double getSum(Data data) {
        return sum + value*(data.minus(lastData));
    }

    public void change(Data data,double value) {
        sum = getSum(data);
        lastData = data;
        this.value = value;
    }

    public void reset(Data data,double value) {
        lastData = data;
        this.value = value;
        sum = 0;
    }
}
YEE686
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java银行管理系统(实训项目)
05-18
大学实训项目，用java实现银行管理系统简单的开户、挂失、存、取、贷款、转账等一系列操作(数据库是mysql，加载一下驱动就可以运行了)
java银行账户管理系统
05-11
支持管理员登录，存款，取款，注册账户，注销账户，转账操作，利息计算以及退出系统操作。
Java银行管理系统总结
Loga6的博客
10-27 1668
银行管理系统总结 4_9： 对于所给的c++代码仅有一个cpp文件不同的时，首先在自己创建的project里的srf文件夹里创建了一个BankManageSystem的包，再在包中创建所需要的多个类。在这一部分的作业中，一共创建了两个类。分别是BankManageSystem与SavingAccount。其中前者包含了主函数，java与c++中的输出是有一定的差异的，目前使用的是System.out.println()，c++中的类中的属性定义，分部定义在private，public等中，而java则是直接
基于Java+Spring Boot+MySQL的银行管理系统
最新发布
2301_77541824的博客
02-22 723
伴随着信息技术与互联网技术的不断发展，人们进到了一个新的信息化时代，传统管理技术性没法高效率、容易地管理信息内容。为了实现时代的发展必须，提升管理高效率，各种各样管理管理体系应时而生，各个领域陆续进到信息内容管理时期。银行管理系统的实现是信息内容时代浪潮时代的产物之一。一切系统都要遵循系统设计的最基本全过程，系统也是如此。它还要通过市场调查、需求分析报告、汇总设计、详尽设计、编号和测试，根据Java语言表达设计，完成银行管理系统。
银行账户管理系统
m0_72438098的博客
04-10 1724
银行账户管理系统基于Java语言，JSP页面技术，Mysql数据库的银行账户管理系统。普通储户可以存款、取款、查看交易记录、个人信息管理。管理员可以开户、查看账户信息、冻结启动账户等。角色上分为：普通储户和银行管理员。
java银行账户管理系统（数据库）
ZQY的博客
06-18 4658
银行账户管理系统： 功能要求： （1）账户的增、删、查、改、浏览； （2）存、贷、还 （3）各种类别的统计 （4）账户交易历史的浏览
Java项目：个人银行账户管理系统课程设计报告
Xu__Y的博客
10-18 8631
个人银行账户管理系统课程设计报告 一、课程设计要求与目的 模仿个人银行账户管理系统的C++版本（第4章-第9章），使用Java语言重新实现该系统，比较C++与Java在实现上的异同，熟练掌握Java基础及语法。 根据业务需求的增加，对个人银行账户管理系统进行功能上的完善，利用面向对象的思想对代码进行重构，体会抽象、封装、继承、多态等特性在实际系统中的应用，掌握构造可复用、可扩展、可维护软件的基本技能。 二、课程设计版本记录 1. 个人银行账户管理系统版本0.1（对应第4章记录） 1.1 系统需
java实现银行管理系统
08-25
主要为大家详细介绍了java实现银行管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
实验室设备管理系统Java版
06-04
实验室设备管理系统Java版实验室设备管理系统Java版实验室设备管理系统Java版实验室设备管理系统Java版实验室设备管理系统Java版实验室设备管理系统Java版实验室设备管理系统Java版实验室设备管理系统Java版实验室...
python 银行管理系统 实验报告及源码
06-28
使用pycharm完成银行管理系统。实现功能有存钱、取钱、注册、注销等。实验报告也是用心完成的。适合学生，一杯奶茶钱，买不了吃亏~~虽然不算最优秀，但是很适合期末作业，没有华丽的代码，但是仍然可以是85的良好！
JAVA银行账户管理系统
12-23
期末大作业，一个简易的银行账户管理系统，包含swing界面
java银行管理系统_java实现银行管理系统_
10-03
java实现银行管理系统，有增删改查的功能，界面较为友好，代码简单
JAVA银行账户管理系统代码手册
01-11
这是一个基于JAVA银行账户管理系统的一个代码手册
Java银行管理系统+MySQL.rar
05-14
"【实例简介】JAVA+Mysql编写的银行管理系统 包括开户、存取、转账、改密、销户、 通过数据库进行增删改查、Java学习实战项目，本资源仅供参考学习、版权所有、严禁侵权！ 开发环境：myeclipse10+mysql+tomcat 开发...
java银行管理系统
08-25
主要为大家详细介绍了java银行管理系统源码，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JAVA学生信息管理系统实验报告.doc
08-27
JAVA学生信息管理系统实验报告.doc
JAVA项目--银行管理系统
热门推荐
weixin_44556353的博客
04-02 1万+
银行管理系统，支持登录注册功能，用户可进行存款、取款、转账、查询余额等业务
python课程设计-银行账户管理系统
T1798218285的博客
03-07 747
python课程设计---银行账号管理
java期末项目-银行管理系统(properties类+io流)
m0_73986197的博客
01-06 928
java期末项目——银行管理系统

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值