java课后作业Account类

于 2024-10-27 14:20:24 发布
阅读量510 收藏 14
点赞数 22
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80554347/article/details/143083178
版权

题目描述：

一个名为id的int类型的私有数据域    private int id;

一个名为dateCreated的Date类型的私有数据域    private Date dateCreated;

一个用于创建默认账户的无参构造方法为

与类名相同

在class Account中 写上 Account(){ ...}   ...是 数据域

eg. balance默认值为0   则在... 中写  balance=0;

一个用于创建带特定id的初始余额的账户   的 构造方法

则与类名相同  有参数，参数为 类中出现的 数据域

eg. Account(double new_balance){balance=new_balance} 

用Account类创建了一个a对象，a是Account类的一个实例化对象

创建一个id为1122的对象        用a.setId=1122;

import java.util.Date;
public class Experience09_07 {
    public static void main(String[] args) {
        Account a = new Account();
        a.setId(1122);
        a.setBalance(20000);
        a.setAnnualInterestRate(0.045);

        a.withdraw(2500);
        a.deposit(3000);
        System.out.println("余额："+a.getBalance());
        System.out.println(a.getMonthlyInterestRate());
        //开户日期
       // a.setDateCreated(new Date());  //若未初始化（即下面的(1)、(2)）  传入一个日期类
        System.out.println(a.getDateCreated().toInstant());

    }
}

class Account{
//私有数据域
    private int id;
    private double balance,annualInterestRate;
    private Date dateCreated;



    Account(){//用于创建默认账户的无参构造方法
        id=0;
        balance=0;
        annualInterestRate=0;

        dateCreated=new Date(); //  (1)  构建Date日期 调用无参的构造方法
    }

    Account(int id,double balance,Date dateCreated)
    {//用于创建带特定id和初始余额的账号的构造方法
        this.id=id;
        this.balance=balance;
//        this去指向本类，赋值成功
       this. dateCreated=dateCreated; // (2) 调用有参的构造方法 第三个参数是 new Date()
    }

//访问器（get）、修改器（set）
    public int getId()
    {
        return id;
    }

    public double getBalance(){
        return balance;
    }
    public double getAnnualInterestRate(){
        return annualInterestRate;
    }

    public void setId(int newId){
        this.id=newId;
    }
    public void setBalance(double newBalance){
        this.balance=newBalance;
    }
    public void setAnnualInterestRate(double newAnnualInterestRate){
        this.annualInterestRate=newAnnualInterestRate;
    }

//dateCreated访问器

    public void setDateCreated(Date dateCreated){
        this.dateCreated=dateCreated;
    }

    public Date getDateCreated() {
        return dateCreated;
    }





//返回月利率
    public double getMonthlyInterestRate(){
        double MonthlyInterestRate=annualInterestRate/12; //
        return balance*MonthlyInterestRate;
    }
//存钱
   public void withdraw(double amount)
   {
       if(amount>balance) System.out.println("Insufficient funds");
       else
           balance-=amount;
   }
//取钱
   public void deposit(double amount)
   {
       balance+=amount;
   }


}



题目升级

ATM

Account[] accounts = new Account[10];   创建一个长度为10的 Account对象数组

accounts[i] = new Account(i,100);          循环为每个账户分配一个初始值为100的Account对象

boolean f=true; 是一个判断标准，用于控制代码走到哪行

case 4时 设置f为false

若f为false 提示用户是否继续操作

 -若用户输入值  非1 

提示"Enter an id(0-9): "

--若输入id非有效 

提示“请问是否需要继续？？”

-直至 用户输入值 为1   f为true

提示"Enter an id(0-9): "

--输入id有效

打印菜单 可执行ATM操作

import java.util.Scanner;
public class bit1007 {
    public static void main(String[] args) {
        Account[] accounts=new Account[10]; //
        for(int i=0;i<accounts.length;i++){
            accounts[i]=new Account(i,100);//
        }

        System.out.print("Enter an id(0-9): ");
        Scanner input=new Scanner(System.in);
        int account_id=input.nextInt();
        boolean f = true;
        while (true){
            if (f){
                if(account_id>9||account_id<0) {
                    System.out.print("Enter again: ");
                    continue;//
                }
                System.out.println();
                menu();



                System.out.print("Enter a choice: ");
                int choice_num=input.nextInt();

                Account account=accounts[account_id]; //

                switch (choice_num){
                    case 1:
                        System.out.println("The balance is "+account.getBalance());
                        break;
                    case 2:
                        System.out.print("Enter an amount to withdraw: ");
                        double withdraw_A=input.nextDouble();
                    /*    if(account.withdraw(withdraw_A)){
                            System.out.println("取款成功 "+account.getBalance());
                        }
                      */
                        account.withdraw(withdraw_A);
                        break;
                    case 3:
                        System.out.println("Enter an mount to deposit: ");
                        int deposit_A=input.nextInt();
                        accounts[account_id].deposit(deposit_A);
                        break;

                    case 4:
                    {
                        f=false;
                        break;
                    }
                }
            }else {
                System.out.println("请我是否需要继续??如果继续请输入1");
                int choice_num=input.nextInt();
                    if(choice_num==1){
                        f=true;
                }
                System.out.print("Enter an id(0-9): ");
                account_id=input.nextInt();

            }

        }


    }
    public static void menu(){
        System.out.println("Main menu");
        System.out.println("1: check balance");
        System.out.println("2: withdraw");
        System.out.println("3: deposit");
        System.out.println("4: exit");
    }



}

class Account1{
    private int id;
    private double balance;

    public Account1(int id,double balance){
        this.id=id;
        this.balance=balance;
    }  //若不写这行 main中会报错  accounts[i]=new Account(i,100)
    // 应写入0个实参 但实际写了 2个


    public double getBalance(){
        return balance;
    }

    public boolean deposit(double amount){
        balance+=amount;
        return true;
    }

    public boolean withdraw(double amount){ //上面case2中 if语句需要boolean类型
        balance-=amount;
        return true;
    }

}

遇到问题

多测试几个不同的运行状态，会发现存在一些问题，例如:
(1)id输入范围应该是0-9，在输入此范围之外的数字程序会提示"Please enter avalid id:"进行重输，
但无论再输入什么数字，都跳不出这个循环;

(2)在menu提示下，输入4执行exit操作，但这里输入4后就无任何信息显示，没有达到题目示意图中的效果;

解决（1）

import java.util.Scanner;
public class Experience10_07 {
    public static void main(String[] args) {
        Account[] accounts=new Account[10]; //
        for(int i=0;i<accounts.length;i++){
            accounts[i]=new Account(i,100);//
        }


        Scanner input=new Scanner(System.in);
     /*
        System.out.print("Enter an id(0-9): ");
        int account_id=input.nextInt();
*/


        int account_id=-1;
        while(account_id<0||account_id>9){
            System.out.println("Enter an id(0-9): ");

            account_id=input.nextInt();
/*
            if(account_id<0||account_id>9){
                System.out.println("Invalid id,please enter a valid number(0-9)");
            }

 */
            //在主循环中添加 while循环 用于验证用户输入的id是否在0-9之间，
            // 如果输入无效，会显示"Enter an id(0-9): "
            //提示用户重新输入
        }


        while (true){
          /*
            if(account_id>9||account_id<0) {
                System.out.print("Enter again: ");
                continue;
            }//continue此处 若输入此范围之外的数，会一直循环"Enter again: "

//因为打印 "Enter again" 会执行 continue 语句
//continue 语句跳过当前循环体剩余部分， 并重开始下一次循环迭代
//意味程序不会重新读取用户的输入，继续使用之前的无效id， 所以会无限循环

           */

            System.out.println();
            menu();



            System.out.print("Enter a choice: ");
            int choice_num=input.nextInt();

            Account account=accounts[account_id]; //


            switch (choice_num){
                case 1:
                    System.out.println("The balance is "+account.getBalance());
                    break;
                case 2:
                    System.out.print("Enter an amount to withdraw: ");
                    double withdraw_A=input.nextDouble();
               /*     if(account.withdraw(withdraw_A)){
                        System.out.println("取款成功 "+account.getBalance());
                    }
                */
                    account.getBalance();
                    break;
                case 3:
                    System.out.print("Enter an mount to deposit: ");
                    double deposit_A=input.nextDouble();

                    account.deposit(deposit_A);
                    break;

                case 4:
                    System.out.println();
                    System.out.println("Enter an id:");
                    break;  //退出 switch

            }

            if (choice_num == 4) {
                break;
            }

        }




    }

    public static void menu(){
        System.out.println("Main menu");
        System.out.println("1: check balance");
        System.out.println("2: withdraw");
        System.out.println("3: deposit");
        System.out.println("4: exit");
    }



}

class Account {
    private int id;
    private double balance;

    public Account(int id,double balance){
        this.id=id;
        this.balance=balance;
    }  //若不写这行 main中会报错  accounts[i]=new Account(i,100)
    // 应写入0个实参 但实际写了 2个


    public double getBalance(){
        return balance;
    }

    public boolean deposit(double amount){
        balance+=amount;
        return true;
    }

    public boolean withdraw(double amount){ //上面case2中 if语句需要boolean类型
        balance-=amount;
        return true;
    }

}

解决（2）

输入4时 退出当前循环，并打印"Enter an id(0-9): "

可在case4中增加逻辑 获取有效id 

将 获取有效id 的逻辑提取到一个单独的方法 getValidAccount中，便于调用

import java.util.Scanner;
public class Test10_07 {

    public static void main(String[] args) {
        Account1[] accounts=new Account1[10]; //
        for(int i=0;i<accounts.length;i++){
            accounts[i]=new Account1(i,100);//
        }


        Scanner input=new Scanner(System.in);

        int account_id=getValidAccount(input);
     /*  粘贴到下面 getValidAccount 函数中
        while(account_id<0||account_id>9){
            System.out.println("Enter an id(0-9): ");

            account_id=input.nextInt();

            if(account_id<0||account_id>9){
                System.out.println("Invalid id,please enter a valid number(0-9)");
            }

 */




        while (true){
     
            System.out.println();
            menu();



            System.out.print("Enter a choice: ");
            int choice_num=input.nextInt();

            Account1 account=accounts[account_id]; //


            switch (choice_num){
                case 1:
                    System.out.println("The balance is "+account.getBalance());
                    break;
                case 2:
                    System.out.print("Enter an amount to withdraw: ");
                    double withdraw_A=input.nextDouble();
               /*     if(account.withdraw(withdraw_A)){
                        System.out.println("取款成功 "+account.getBalance());
                    }
                */
                    account.getBalance();
                    break;
                case 3:
                    System.out.print("Enter an mount to deposit: ");
                    double deposit_A=input.nextDouble();

                    account.deposit(deposit_A);
                    break;

                case 4:
                    account_id=getValidAccount(input); //调用getValidAccount方法 重新获取有效的账户id
                    break;  //退出 switch

                default:
                    System.out.println("Invalid choice,please enter again.");

            } //switch



        }//while

    }//main

    //将有效账户id的逻辑 放在 以下方法中， 目的是在需要 重新获取账户id时可复用该方法
    public static int getValidAccount(Scanner input){
        int account_id=-1;

        while(account_id<0||account_id>9) {
            System.out.println("Enter an id(0-9): ");
            account_id = input.nextInt();

            if (account_id < 0 || account_id > 9) {
                System.out.println("Invalid id,please enter a valid number(0-9)");
            }
        }

        return account_id;
    }

    public static void menu(){
        System.out.println("Main menu");
        System.out.println("1: check balance");
        System.out.println("2: withdraw");
        System.out.println("3: deposit");
        System.out.println("4: exit");
    }





}

class Account1 {
    private int id;
    private double balance;

    public Account1(int id,double balance){
        this.id=id;
        this.balance=balance;
    } 

    public double getBalance(){
        return balance;
    }

    public boolean deposit(double amount){
        balance+=amount;
        return true;
    }

    public boolean withdraw(double amount){ 
        if(amount<=balance){//检查余额是否充足
            balance-=amount;
            return true;
        }
        else return false;

    }

}

Account类的子类

super()是一个关键字

用于调用父类的构造函数     

用于子类构造函数的开头，以确保再创在子类对象时，先执行父类的构造函数

若不调用super() ，Account类中的成员变量id、balance、annualInterestRate、dateCreated 将不会被初始化

显示地调用super() 可使代码更加清晰，增加代码可读性    表示正在调用父类的构造函数 ，即父类的构造函数被正确调用，即使父类没有无参构造函数

若不显示地调用super()  ，编译器也会自动插入一个默认的super() 调用，即调用父类的无参构造函数


import java.util.Date;

public class Experience11_03 {
    public static void main(String[] args) {
        Account account=new Account();
        CheckingAccount checkingAccount=new CheckingAccount();
        SavingAccount savingAccount=new SavingAccount();

        System.out.println(account);
        System.out.println(checkingAccount);
        System.out.println(savingAccount);
    }

}

class Account{

    private int id;
    private double balance,annualInterestRate;
    private Date dateCreated;



    Account(){//用于创建默认账户的无参构造方法
        id=0;
        balance=0;
        annualInterestRate=0;

        dateCreated=new Date();// 构建Date日期 调用无参的构造方法
    }


    public String toString(){ //不要忘了 toString()
        return "Account{: id="+id+" balance="+balance+" annualInterestRate="
                +annualInterestRate+" dateCreated： "+dateCreated+" }";
    }
}


class CheckingAccount
        extends Account{
    private double overdraft;

    CheckingAccount(){
        super();
        overdraft=-500;//不能透支，所以设为0
    }


    public String toString(){
        return "CheckingAccount{:  overdraft="+overdraft+" "+super.toString()+" }";
    }

}

class SavingAccount
        extends Account{
    private double overdraft;

    SavingAccount(){
        super();
        overdraft=0;//不能透支，所以设为0
    }


    public String toString(){
        return "SavingAccount{:  overdraft="+overdraft+" "+super.toString()+" }";
    }

}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值