精华内容
下载资源
问答
  • BAM银行账户管理系统ATM管理系统 本系统采用JAVA语言并在eclipse环境下编写测试完成涉及类的概念以及面向对象的几大特性继承封装多态抽象也有异常处理机制基本可以满足大多数BAM系统的相关实现且代码内标注大量注释...
  • 编辑一个银行账户管理程序。通过此次课程设计,来巩固所学Java语言基本知识,加深对循环语句、选择语句的熟练程度,以及对面向对象、继承的理解等。掌握JDK、JCreator等开发工具的运用,拓宽常用类库的应用。
  • 1.java是一门面向对象的语言,在个人银行账户管理系统的改写中,深刻体会到了面向对象的好处,那就是易维护、质量高、效率高、易扩展。 2.在对第4章的改写中,将id, lastDate,balance, rate, accumulation定义为...

    一、
    java是一门面向对象的语言,在个人银行账户管理系统的改写中,深刻体会到了面向对象的好处,那就是易维护、质量高、效率高、易扩展。
    二、
    在对第4章的改写中,将id, lastDate,balance, rate, accumulation定义为私有变量,体现出了面向对象的封装性,通过公共方法才可以访问它们,保障了数据的安全与稳定。利息的计算方法和记录也是私有的,用户不可以进行修改。
    普通类:

    public class SavingsAccount {
    	private int id, lastDate;
    	private double balance, rate, accumulation;
    
    	private double accumulate(int data) {
    		return accumulation + balance * (data - lastDate);
    	}
    
    	private void record(int data, double amount) {
    		accumulation = accumulate(data);
    		lastDate = data;
    		balance += amount;
    		System.out.println(data + "  #" + id + "   " + String.format("%.2f", amount) + "    "
    				+ String.format("%.2f", balance) + "\n");
    	}
    
    	public SavingsAccount(int data1, int id1, double rate1) {
    		id = id1;
    		lastDate = data1;
    		rate = rate1;
    		System.out.println(data1 + "\t#" + id1 + " is created\n");
    	}
    
    	public int getid() {
    		return id;
    	}
    
    	public double getBalance() {
    		return balance;
    	}
    
    	public double getRate() {
    		return rate;
    	}
    
    	public void deposit(int date, double amount) {
    		record(date, amount);
    	}
    
    	public void withdraw(int date, double amount) {
    		if (getBalance() < amount) {
    			System.out.println("Error: not enough money");
    		} else
    			record(date, -amount);
    	}
    
    	public void settle(int date) {
    		double inter = accumulate(date) * rate / 365;
    		if (inter != 0)
    			record(date, inter);
    		accumulation = 0;
    	}
    
    	public void show() {
    		System.out.println("#" + getid() + "    Balance: " + String.format("%.2f", getBalance()));
    	}
    
    	public static void main(String[] args) {
     		SavingsAccount s0 = new SavingsAccount(1, 21325302, 0.015);
    		SavingsAccount s1 = new SavingsAccount(1, 58320212, 0.015);
    		s0.deposit(5, 5000);
     		s1.deposit(25, 10000);
    		s0.deposit(45, 5500);
    		s1.withdraw(60, 4000);
    		s0.settle(90);
    		s1.settle(90);
    		s0.show();
    		s1.show();
    	}
    }
    

    三、
    在对第5章的改写中,增添静态属性与方法,增加静态的属性total,方便记录所有账号的总金额,同时静态方法,方便查询total,这种操作使得不需要在进行实例化。静态变量的值,直接赋新值即可,不需要参数传递,之后可以直接进行参数引用即可;静态方法可以直接通过"类名.方法"的形式进行方法调用。通常方法被多次调用,并且方法中没有动态方法引用的时候使用比较方便。
    静态属性与方法:

    private static double total;
    public static double getTotal() {
    		return total;
    }
    

    四、
    在对第6章的改写中,使用了对象数组,并且增添了字符串,java里的数组本书就是引用,在建立Account数组的时候同时为对象申请空间否则会造成NullPoint。这里是java对象数组与c++不同之处。

    public static void main(String []args) {
    		date data=new date(2008,11,5);
    		Account a[]= {
    			new Account(data,"S3755217",0.015),
    			new Account(data,"02342342",0.015)
    		};
    		a[0].deposit(new date(2008,11,5), 5000, "salary");
    		a[1].deposit(new date(2008, 11, 25), 10000, "sell stock 0323");
    		a[0].deposit(new date(2008, 12, 5), 5500, "salary");
    		a[1].withdraw(new date(2008, 12, 20), 4000, "buy a laptop");
    		System.out.println("\n");
    		for(int i=0;i<2;i++) {
    			a[i].settle(new date(2009, 1, 1));
    			a[i].show();
    			System.out.println("\n");
    		}
    		System.out.println("Total: "+Account.getTotal()+"\n");
    	}
    

    五、
    在对第7章的改写中,抽象出了父类使得代码扩展性更高,父类Account,派生出子类creditAccount和savingsaccount,同样的代码不需要重复写,直接继承父类,使得代码更加简洁,也更好纠错。

    学会java继承的语法:

    public class CreditAccount extends Account
    public class SavingsAccount extends Account
    

    六、
    在对第8章的改写中,使用了多态的性质,java里的多态主要体现在重载和覆盖,注意java里没有运算符的重载。类似c++里的虚函数,java里面有abstract关键字,只要某给个类里含有abstract方法,就必须在类前声明abstract,这是java里面的抽象类的概念,有了抽象类,个人理解就像是给了招牌,通过这个招牌可以理解子类的共同作用。通过这个地方感受到了c++与java在抽象类的不同。
    抽象类:

    public abstract class Account {
    	private String id;
    	private double balance;
    	private static double total;
    	protected Account(date d,String s){
    			id=s;balance=0;
    			d.show();
    			System.out.println("\t#"+id+" created");
    	}
    	protected void record(date d,double amount,String desc) {
    		balance+=amount;
    		total+=amount;
    		d.show();
    		System.out.println("\t#"+id+"\t"+String.format("%10.2f",amount)+"\t"+String.format("%10.2f", balance)+"\t"+desc);
    	}
    	protected void error(String s) {
    		System.out.println("Error(#"+id+"): "+s);
    	}
    	public String getId() {
    		return id;
    	}
    	public double getBalance() {
    		return balance;
    	}
    	public static double getTotal() {
    		return total;
    	}
    	public abstract void deposit(date data, double amount,String desc);
    	public abstract void show();
    	public abstract void withdraw(date data, double amount,String desc);
    	public abstract void settle(date data);
    }
    

    七、
    在对第9章的改写中,使用了容器来代替数组,注意到java中没有指针和模板,改写起来还是有点难度的。同时java里也没有char,我是按照输入字符串然后通过charAt(0)取出第一个字符。
    主要的选择片段:

    do {
    			d.show();
    			System.out.println("\tTotal: "+Account.getTotal()+"\tcommand> ");
    			int index, day;
    			double amount;
    			String desc;
    			Scanner input=new Scanner(System.in);
    			String c=input.next();
    			cmd=c.charAt(0);
    			switch(cmd) {
    			case 'd':
    				index=input.nextInt();
    				amount=input.nextDouble();
    				desc=input.next();
    				accounts[index].deposit(d, amount, desc);
    				break;
    			case 'w':	//取出现金
    				index=input.nextInt();
    				amount=input.nextDouble();
    				desc=input.next();
    				accounts[index].withdraw(d, amount, desc);
    				break;
    			case 's':	//查询各账户信息
    				for (int i = 0; i < 3; i++) {
    					System.out.print("["+i+"] ");
    					accounts[i].show();
    				}
    				break;
    			case 'c':	//改变日期
    				day=input.nextInt();
    				if (day < d.getDay())
    					System.out.println("You cannot specify a previous day");
    				else if (day > d.getMaxday())
    					System.out.println("Invalid day");
    				else
    					d = new date(d.getYear(), d.getMonth(), day);
    				break;
    			case 'n':	//进入下个月
    				if (d.getMonth() == 12)
    					d = new date(d.getYear() + 1, 1, 1);
    				else
    					d = new date(d.getYear(), d.getMonth() + 1, 1);
    				for (int i = 0; i < 3; i++)
    					accounts[i].settle(d);
    				break;
    			}
    		}while(cmd !='e');
    
    展开全文
  • 银行账户管理系统 基于Java开发
  • java银行账户管理系统

    2018-05-11 16:50:33
    支持管理员登录,存款,取款,注册账户,注销账户,转账操作,利息计算以及退出系统操作。
  • 这是一个银行账户管理系统,用户可以通过ATM终端界面来操作自己的银行账户.
  • 这是一个基于JAVA银行账户管理系统的一个代码手册
  • 通过银行管理系统一方面加快了客户的服务,提高的服务质量,另一方面减轻了员工的工作复杂度,提高了工作效益,实现银行帐户管理的系统化、规范化、自动化和智能化。系统具体实现的目标如下: (1)键盘操作,快速...
  • 账户管理系统银行的atm机使用的微型管理系统模拟
  • 银行账户管理系统1. 代码编写过程说明2. 实现中发现的问题C++中常成员函数在 java中的含义与实现:const 在C++和Java中的区别,以及Java实现其在C++中功能的方法:C++中 虚函数与纯虚函数的区别 以及在Java中对应的...




    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;
        }
    }
    
    
    
    展开全文
  • 项目描述原生GUI 的界面设计很丑,这次介绍一款Java Swing跨平台外观,它就是BeautyEye运行环境eclipse+jdk8+jdbc+mysql项目技术(必填)swing 美化包beautyeye+windowbuilder可视化插件数据库文件链接: ...

    项目描述

    原生GUI 的界面设计很丑,这次介绍一款Java Swing跨平台外观,它就是BeautyEye

    运行环境

    eclipse+jdk8+jdbc+mysql

    项目技术(必填)

    swing 美化包beautyeye+windowbuilder可视化插件

    数据库文件

    链接: https://pan.baidu.com/s/1sWjeNHmej7qav_j5bTZ4Jw 提取码: a8sy

    依赖包文件(可选)

    压缩包自带

    5f44669d9023f819b9cfa4031178418d.png

    资源包文件(可选)

    阿里巴巴矢量图官方下载地址

    https://www.iconfont.cn/collections/index?spm=a313x.7781069.1998910419.3

    展开全文
  • Java-dos模式、银行账户管理系统论文
  • 精选范本 精选范本 AM银行账户管理系统ATM管理系统 本系统采用JAVA语言并在eclipse环境下编写测试完成涉及类的概念以及面向对象 的几大特性继承封装多态抽象也有异常处理机制基本可以满足大多数 BAM系 统的相关实现...
  • 论文讨论了一种通过Java语言构建的银行账户管理系统的方案。
  • 银行账户管理系统

    2019-03-24 02:13:09
    银行帐目管理系统是针对银行帐目的日常管理而设计。银行帐目管理系统不仅要求操作方便而且要求界面简洁,它还需要实现帐目管理,用户查询和查询统计功能。 针对上述情况和要求,采用软件工程的开发原理,依据软件...
  • 银行账户管理系统。。
  • 一个简单的java程序,一个银行账户管理系统,用MySQL做数据库,java做底层操作及窗口
  • 1、模仿个人银行账户管理系统的C++版本(第4章-第8章),使用Java语言重新实现该系统,比较C++与Java在实现上的异同,熟练掌握Java基础及语法。 2、根据系统需求的演化,逐步完善个人银行账户管理系统的功能,改进...

    要求:
    1、模仿个人银行账户管理系统的C++版本(第4章-第8章),使用Java语言重新实现该系统,比较C++与Java在实现上的异同,熟练掌握Java基础及语法。
    2、根据系统需求的演化,逐步完善个人银行账户管理系统的功能,改进代码,体会面向对象思想的封装、继承、多态特性在实际系统中的应用,初步掌握使用Java编写可复用、可扩展、可维护代码的基本技能。

    第四章
    1.Java里面没有c++ 里的namespace,而是换成了package。
    2.private,public等在Java里面需要单独写在每一个成员前面。
    3.c++ 里面void test (int _x) const{}时const指该函数不能修改类的成员,而Java 里面final void。
    4.test(){}时final表示该函数不能被重写。Java里没有const。
    5.Java里的输出是语句是System.out.println(变量名 + “字符串”)。
    6.c++ 里面建立类的对象可以直接:类名 对象名(参数),而Java里面需要:类名 对象名 = new 类名(参数)。

    package ob1;
    
    public class SavingsAccount {
    	//储蓄账户类
    	   private int id; //账号
    	   private double balance;//余额
    	   private double rate;//存款的年利率
    	   private int lastDate;		//上次变更余额的时期
    	   private double accumulation;	//余额按日累加之和
    	   //获得到指定日期为止的存款金额按日累积值
    	 	private double accumulate(int date){
    	 		return accumulation + balance * (date - lastDate);
    	 	}
    
    		//记录一笔帐,date为日期,amount为金额,desc为说明
    	    private void record(int date, double amount){
    	    	accumulation=accumulate(date);
    	    	lastDate=date;
    	    	amount = Math.floor(amount * 100 + 0.5) / 100;//保留小数点后两位
    	    	
    	    	balance += amount;
    	    	System.out.println(date+"\t#"+id+"\t"+amount+"\t"+balance);
    	    }
    		
    			
    
    		//构造函数
    		public SavingsAccount(int date, int id, double rate){
    			this.id=id;
    			this.balance=0;
    			this.rate=rate;
    			this.lastDate=date;
    			this.accumulation=0;
    			System.out.println(date+"\t#"+id+"is created");
    		}
    		public final int getId() { return id; }
    		public double getBalance() { return balance; }
    		public double getRate() { return rate; }
    
    			//存入现金
    		public void deposit(int date, double amount){
    			record(date, amount);
    		}
    			//取出现金
    		public void withdraw(int date, double amount){
    			if(amount > getBalance())
    				System.out.println("Error: not enough money");
    			else
    				record(date,-amount);
    		}
    			//结算利息,每年1月1日调用一次该函数
    		public void settle(int date){
    			double interest = accumulate(date) * rate / 365;	//计算年息
    			if (interest != 0)
    				record(date, interest);
    			accumulation = 0;
    		}
    			//显示账户信息
    		public void show(){
    			System.out.println("#"+id+"\tBalance: "+balance);
    		}
    		
    
    
    }
    
    package ob1;
    
    public class Run {
    	public static void main(String[] args){
    		//建立几个账户
    		SavingsAccount sa0=new SavingsAccount(1, 21325302, 0.015);
    		SavingsAccount sa1=new SavingsAccount(1, 58320212, 0.015);
    		//几笔账目
    		sa0.deposit(5, 5000);
    		sa1.deposit(25, 10000);
    		sa0.deposit(45, 5500);
    		sa1.withdraw(60, 4000);
    		//开户后第90天到了银行的计息日,结算所有账户的年息
    		sa0.settle(90);
    		sa1.settle(90);
    		//输出各个账户信息
    		sa0.show();
    		System.out.println("\n");
    		sa1.show();
    		System.out.println("\n");
    		
    }
    }
    
    展开全文
  • JAVA编程-银行账户管理系统 简称BAM(项目介绍及源码)绝对精典
  • 个人银行账户管理系统实验 实验内容:将C++代码转为Java 实验总结: public,private,protect要单独写在每一个函数前面 函数体和函数声明不能分开 Java中没有运算符重载,指针等 Java提供包机制,用于区别类名的...
  • Java银行账户管理系统

    千次阅读 多人点赞 2019-07-17 16:43:41
    用的Java语言,开发平台是eclipse,借助Java的GUI来实现,通过文件储存数据。自己来写界面的话当然比较烦,于是我用的eclipse的插件WindowBuilder,通过可视化拖拽的方式来生成各个界面。点击查看WindowBuilder的 ...
  • C++的银行账户管理系统分为几个章节 实验课改写了 4-8 章 下面是在改写过程中体会到了C++与Java的不同之处,对于理解Java特性和C++的不同、相同有很大作用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,494
精华内容 4,197
关键字:

银行账户管理系统java

java 订阅