ATM 系统（Java基础项目）

已于 2024-06-30 11:16:22 修改
阅读量171 收藏 1
点赞数 2
文章标签： java 前端 开发语言 intellij-idea
于 2024-06-30 00:24:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianyinghang/article/details/140072946
版权

第一次编写——照猫画虎

系统功能分析

  1. 技术选型：

    1. 面向对象编程

          每一个账户都是一个账户对象：所以需要设计账户类 Account，用于创建账户对象封装账户信息。ATM 同样是一个对象，需要设计 ATM 类，代表 ATM 管理系统，负责对账户的管理

    2. 使用集合容器

          ATM 管理类中需要提供一个容器用于存储系统全部账户对象的信息，选用 ArrayList 集合

    3. 程序流程控制

          需要结合分支、循环、跳转关键字等程序流程控制的知识，用来控制系统的业务流程

    4. 使用常见 API

          登录信息的内容比较，数据的分析，处理等都需要常用 API 来解决，如使用 String

  1. 系统架构搭建

    1. 定义一个账户类 Account，至少需要包含（卡号、姓名、性别、密码、余额、每次取现额度）

    2. 定义一个 ATM 类，用来代表 ATM 系统，负责提供所有的业务需求，比如：展示 ATM 的系统欢迎页、开通账户、转账……

    3. 定义一个测试类 Test，负责对开发的 ATM 系统进行测试

  2. 系统欢迎页设计

    1. 在 ATM 类中设计一个 start()，方法里负责展示欢迎界面

  1. 用户开户功能

    1. 新增一个账户，即往系统的账户集合中添加一个账户对象

  2. 账户的要求

    1. 用户信息包含：姓名、性别、密码、每次取现额度、卡号

    2. 卡号由系统生成，要求是 8位的数字组成的（且卡号不能重复）

    3. 新卡号得到后，赋值给当前账户对象

  1. 用户登录功能

    1. 如果系统没有任何账户对象，则不允许登录

    2. 让用户输入登录的卡号，先判断卡号是否正确，如果不正确要给出提示

    3. 如果卡号正确，再让用户输入账户密码， 如果密码不正确要给出提示， 如果密码也正确，则给出登录成功的提示

  1. 用户操作页设计、查询账户、退出账户功能

    1. 用户登录成功后，需要进入用户操作页

    2. 查询就是直接展示当前登录成功的用户的账户信息

    3. 退出账户就是回到欢迎页面

  1. 用户存款功能

    1. 用户为自己的账户存钱，存钱后更新账户的余额即可

  2. 用户取款功能

    1. 从自己的账户中取钱，取钱要求：

      • 需要先判断账户的余额是否大于等于 100元，如果够，让用户输入取款金额

      • 需要判断取款余额是否超过了当次限额，以及余额是否足够

  1. 用户转账功能

    1. 把钱转给别人，转账前需要判断：

      • 自己账户是否有钱，系统中是否有其他账户

      • 接下来让用户输入对方卡号，判断对方账户是否存在，账户如果存在，还需要认证对方账户的户主姓氏

  1. 销户操作

    1. 销户就是从系统中删除当前账户，销户的要求：

      • 首先要询问用户是否确定要销户，如果不确定，则回到操作界面

      • 如果确定，要判断用户的账户中是否有钱，有则不允许销户，并回到操作界面

      • 如果没钱，则完成销户，并回到欢迎页

  1. 用户密码修改

    1. 更改账户的密码，修改密码的要求：

      • 需要先认证用户当前的密码

      • 认证通过后，需要让用户输入2次密码

      • 两次密码一样，则更新账户密码，并回到欢迎界面

Account 类

      
package com.qszl;

/**
 * @author Bourbon
 * @version 1.0
 */
public class Account {
    private String cardId;
    private String userName;
    private char sex;
    private String passWord;
    private double money;
    private double limit;

    public Account() {
    }

    public Account(String cardId, String userName, char sex, String passWord, double money, double limit) {
        this.cardId = cardId;
        this.userName = userName;
        this.sex = sex;
        this.passWord = passWord;
        this.money = money;
        this.limit = limit;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public String getUserName() {
        return userName + (sex == '男' ? "先生" : "女士");
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public double getMoney() {
        return money;
    }

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

    public double getLimit() {
        return limit;
    }

    public void setLimit(double limit) {
        this.limit = limit;
    }
}

ATM 类（13.72KB）

      
package com.qszl;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/**
 * @author Bourbon
 * @version 1.0
 */
public class ATM {
    private ArrayList<Account> accounts = new ArrayList<>();
    private Scanner sc = new Scanner(System.in);
    private Account loginAcc;//记录登录后的用户账户

    //启动系统，展示欢迎界面
    public void start() {
        while (true) {
            System.out.println("===欢迎进入 ATM 系统===");
            System.out.println("1. 用户登录");
            System.out.println("2. 用户开户");
            System.out.println("请选择：");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    login();
                    break;
                case 2:
                    creatAccount();
                    break;
                default:
                    System.out.println("没有该操作");
            }
        }
    }

    //完成用户的登录操作
    private void login() {
        System.out.println("==系统登录==");
        //1. 判断系统中是否存在账户对象，存在才能登陆，如果不存在，直接结束登录操作
        if (accounts.size() == 0) {
            System.out.println("系统中无任何账户，请先开户再登录");
            return;
        }
        //2. 系统中存在账户对象，开始进行登录操作
        while (true) {
            System.out.println("请输入登录卡号：");
            String cardId = sc.next();
            //3. 判断卡号是否存在
            Account acc = getAccountByCardId(cardId);
            if (acc == null) {
                System.out.println("登录卡号不存在");
            } else {
                while (true) {
                    System.out.println("请输入登录密码");
                    String passWord = sc.next();
                    //4. 判断密码是否正确
                    if (acc.getPassWord().equals(passWord)) {
                        loginAcc = acc;
                        System.out.println("恭喜您" + acc.getUserName() + "成功登录系统，您的卡号是：" + acc.getCardId());
                        //登录后的操作界面
                        showUserCommand();
                        return;//跳出并结束当前登录方法
                    } else {
                        System.out.println("输入的密码不正确");
                    }
                }
            }
        }
    }

    //展示登录后的操作界面
    private void showUserCommand() {
        while (true) {
            System.out.println(loginAcc.getUserName() + "您可以选择如下功能进行账户的处理===");
            System.out.println("1. 查询账户");
            System.out.println("2. 存款");
            System.out.println("3. 取款");
            System.out.println("4. 转账");
            System.out.println("5. 密码修改");
            System.out.println("6. 退出");
            System.out.println("7. 注销当前账户");
            System.out.println("请选择：");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    showLoginAccount();
                    break;
                case 2:
                    depositMoney();
                    break;
                case 3:
                    drawMoney();
                    break;
                case 4:
                    transferMoney();
                    break;
                case 5:
                    updatePassWord();
                    return;//跳出操作界面，依次回到欢迎界面
                case 6:
                    System.out.println(loginAcc.getUserName() + "您退出系统成功");
                    return;//跳出并结束当前方法
                case 7:
                    if (deleteAccount()) {
                        //销户成功，回到欢迎界面
                        return;
                    }
                    break;
                default:
                    System.out.println("当前选择的操作不存在");
            }
        }
    }

    //账户密码修改
    private void updatePassWord() {
        System.out.println("==账户密码修改操作==");
        //1. 提醒用户认证当前密码
        while (true) {
            System.out.println("请输入当前账户的密码：");
            String passWord = sc.next();
            //2. 认证当前密码是否正确
            if (loginAcc.getPassWord().equals(passWord)) {
                //认证通过
                while (true) {
                    //3. 真正开始修改密码
                    System.out.println("请输入新密码：");
                    String newPassWord = sc.next();
                    System.out.println("请输入确认密码");
                    String okPassWord = sc.next();

                    //4. 判断两次密码是否一致
                    if (okPassWord.equals(newPassWord)) {
                        //修改秘密
                        loginAcc.setPassWord(okPassWord);
                        System.out.println("恭喜您，密码修改成功");
                        return;
                    } else {
                        System.out.println("您输入的两次密码不一致");
                    }
                }
            } else {
                System.out.println("您当前输入的密码不正确");
            }
        }

    }

    //销户操作
    private boolean deleteAccount() {
        System.out.println("==进行销户操作==");
        //1. 询问用户是否确定要销户
        System.out.println("请问您确认销户吗？Y/N");
        String command = sc.next();
        switch (command) {
            case "Y":
                //确认销户
                //2. 判断用户的账户中是否有钱
                if (loginAcc.getMoney() == 0) {
                    accounts.remove(loginAcc);
                    System.out.println("您好，您的账户已成功销户");
                    return true;
                } else {
                    System.out.println("对不起，您的账户中存有金额，不允许销户");
                    return false;
                }
            default:
                System.out.println("好的，您的账户保留");
                return false;
        }
    }

    //转账
    private void transferMoney() {
        System.out.println("==用户转账==");
        //1. 判断系统中是否存在其他账户
        if (accounts.size() < 2) {
            System.out.println("当前系统中只有你一个账户，无法为其他账户转账");
            return;
        }

        //2. 判断自己的账户中是否有钱
        if (loginAcc.getMoney() == 0) {
            System.out.println("您自己都没钱，别转了");
            return;
        }

        while (true) {
            //3. 真正开始转账
            System.out.println("请输入对方对方卡号：");
            String cardId = sc.next();
            //4. 判断卡号是否正确
            Account acc = getAccountByCardId(cardId);
            if (acc == null) {
                System.out.println("您输入的对方卡号不存在");
            } else {
                //对方账户存在，继续让用户认证姓氏
                String name = "*" + acc.getUserName().substring(1);
                System.out.println("请您输入【" + name + "】姓氏");
                String preName = sc.next();
                //5. 判断姓氏是否正确
                if (acc.getUserName().startsWith(preName)) {
                    while (true) {
                        System.out.println("请输入转账给对方的金额");
                        double money = sc.nextDouble();
                        //6. 判断金额是否未超过自己的余额
                        if (loginAcc.getMoney() >= money) {
                            //转给对方，更新自己的账户余额
                            loginAcc.setMoney(loginAcc.getMoney() - money);
                            //更新对方的账户余额
                            acc.setMoney(acc.getMoney() + money);
                            return;//跳出转账方法
                        } else {
                            System.out.println("您余额不足，无法给对方转这么多钱，最多可转：" + loginAcc.getMoney());
                        }
                    }
                } else {
                    System.out.println("对不起，您认证的姓氏有问题");
                }
            }
        }
    }

    //取钱
    private void drawMoney() {
        System.out.println("==取钱操作==");
        //1. 判断账户余额是否达到了 100元，如果不够 100元，就不让用户取钱
        if (loginAcc.getMoney() < 100) {
            System.out.println("您的账户余额不足100元，不允许取钱");
            return;
        }
        //2. 让用户输入取款金额
        while (true) {
            System.out.println("请输入取款金额：");
            double money = sc.nextDouble();
            //3. 判断账户余额是否足够
            if (loginAcc.getMoney() >= money) {
                //4. 判断当前取款金额是否超过每次限额
                if (money > loginAcc.getLimit()) {
                    System.out.println("您当前取款金额超过了每次限额，您每次最多可取：" + loginAcc.getLimit());
                } else {
                    loginAcc.setMoney(loginAcc.getMoney() - money);
                    System.out.println("您取款" + money + "成功，取款后剩余" + loginAcc.getMoney());
                    break;
                }
            } else {
                System.out.println("余额不足，您的账户中的余额是" + loginAcc.getMoney());
            }
        }
    }

    //存钱
    private void depositMoney() {
        System.out.println("==存钱操作==");
        System.out.println("请输入存款金额：");
        double money = sc.nextDouble();

        //更新当前登录账户的余额
        loginAcc.setMoney(loginAcc.getMoney() + money);
        System.out.println("恭喜您，您存钱：" + money + "成功，存钱后余额是" + loginAcc.getMoney());
    }

    //显示当前登录的账号信息
    private void showLoginAccount() {
        System.out.println("==当前您的账户信息如下==");
        System.out.println("卡号：" + loginAcc.getCardId());
        System.out.println("户主：" + loginAcc.getUserName());
        System.out.println("性别：" + loginAcc.getSex());
        System.out.println("余额：" + loginAcc.getMoney());
        System.out.println("每次取现额度：" + loginAcc.getLimit());
    }

    //完成开户操作
    private void creatAccount() {
        //1. 创建一个账户对象，用于封装用户的开户信息
        Account acc = new Account();
        //2. 需要用户输入自己的开户信息，赋值给账户对象
        System.out.println("请输入账户名称：");
        String name = sc.next();
        acc.setUserName(name);
        //--------------------------
        while (true) {
            System.out.println("请输入性别：");
            char sex = sc.next().charAt(0);
            if (sex == '男' || sex == '女') {
                acc.setSex(sex);
                break;
            } else {
                System.out.println("输入性别有误");
            }
        }
        //--------------------------
        while (true) {
            System.out.println("请输入账户密码：");
            String passWord = sc.next();
            System.out.println("请输入确认密码：");
            String okPassWord = sc.next();

            if (okPassWord.equals(passWord)) {
                acc.setPassWord(okPassWord);
                break;
            } else {
                System.out.println("输入的2次密码不一致，请重新确认");
            }
        }
        //--------------------------
        System.out.println("请输入取现额度：");
        double limit = sc.nextDouble();
        acc.setLimit(limit);
        //--------------------------
        String newCardId = creatCardId();
        acc.setCardId(newCardId);
        //3. 把这个账户对象，存入到账户集合中去
        accounts.add(acc);
        System.out.println("恭喜你" + acc.getUserName() + "开户成功，您的卡号是：" + acc.getCardId());
    }

    //生成新卡号
    private String creatCardId() {
        while (true) {
            //1. 定义一个 String 类型的变量存储 8 位数字作为一个卡号
            String cardId = "";
            //2. 使用循环，循环 8 次，每次产生一个随机数给 cardId 连接起来
            Random r = new Random();
            for (int i = 0; i < 8; i++) {
                int data = r.nextInt(10);
                cardId += data;
            }
            //3. 判断 cardId 中记住的卡号，是否与其他账户的卡号重复了，没有重复，才能作为一个新卡号返回
            Account acc = getAccountByCardId(cardId);
            if (acc == null) {
                return cardId;
            }
        }
    }

    //根据卡号查询账户
    private Account getAccountByCardId(String cardId) {
        for (int i = 0; i < accounts.size(); i++) {
            Account acc = accounts.get(i);
            if (acc.getCardId().equals(cardId)) {
                return acc;
            }
        }
        return null;
    }
}

Test 类

      
import com.qszl.ATM;

/**
 * @author Bourbon
 * @version 1.0
 */
public class Main {
    public static void main(String[] args) {
        ATM atm = new ATM();

        atm.start();
    }
}

第二次编写——不伦不类

ATM 类（10.20KB）

package com.qszl;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;


/**
 * @author Bourbon
 * @version 2.0
 */
public class ATM {
    private ArrayList<Account> accounts = new ArrayList<>();
    private Scanner sc = new Scanner(System.in);
    private Account loginAcc = new Account();

    public void start() {
        while (true) {
            System.out.println("===欢迎启动 ATM 系统===");
            System.out.println("1. 用户登录");
            System.out.println("2. 用户注册");
            System.out.println("请选择: ");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    login();
                    break;
                case 2:
                    createAccount();
                    break;
                default:
                    System.out.println("操作错误，请重新操作");
                    break;
            }
        }

    }

    private void createAccount() {
        System.out.println("===用户注册===");
        Account acc = new Account();

        System.out.println("请输入用户名: ");
        String userName = sc.next();
        acc.setUserName(userName);

        while (true) {
            System.out.println("请输入性别: ");
            char sex = sc.next().charAt(0);
            if (sex == '男' || sex == '女') {
                acc.setSex(sex);
                break;
            } else {
                System.out.println("输入有误，请重新操作");
            }
        }

        while (true) {
            System.out.println("请输入密码: ");
            String passWord = sc.next();
            System.out.println("请确认密码: ");
            String okPassWord = sc.next();
            if (okPassWord.equals(passWord)) {
                acc.setPassWord(okPassWord);
                break;
            } else {
                System.out.println("两次输入不一致，请重新操作");
            }
        }


        System.out.println("请输入取款限额: ");
        double limit = sc.nextDouble();
        acc.setLimit(limit);

        while (true) {
            String cardId = createCardId();
            if (acc.equals(getAccountByCardId(cardId))) {
                System.out.println("已有用户，请重新生成");
            } else {
                acc.setCardId(cardId);
                System.out.println("生成卡号" + cardId);
                break;
            }
        }
        accounts.add(acc);

    }

    private String createCardId() {
        Random r = new Random();
        String cardId = "";
        for (int i = 0; i < 8; i++) {
            int data = r.nextInt(10);
            cardId += data;
        }
        return cardId;
    }

    private void login() {
        if (accounts.size() == 0) {
            System.out.println("系统中没有任何用户记录，请创建用户");
            return;
        }

        while (true) {
            System.out.println("请输入用户卡号: ");
            String cardId = sc.next();
            //判断卡号格式是否正确，是否在系统数据库中
            Account acc = getAccountByCardId(cardId);
            if (acc == null) {
                System.out.println("卡号错误或者不存在");
            } else {
                //卡号正确且存在，进一步判断密码是否正确匹配
                while (true) {
                    System.out.println("请输入密码: ");
                    String passWord = sc.next();
                    if (passWord.equals(acc.getPassWord())) {
                        //密码正确，进入系统
                        System.out.println("密码输入正确");
                        loginAcc = acc;
                        showUserCommand();
                        return;
                    } else {
                        System.out.println("密码错误，请重新操作");
                    }
                }
            }
        }

    }

    private void showUserCommand() {
        while (true) {
            System.out.println("===欢迎进入系统功能界面===");
            System.out.println("1. 查询用户信息");
            System.out.println("2. 存款");
            System.out.println("3. 取款");
            System.out.println("4. 转账");
            System.out.println("5. 修改密码");
            System.out.println("6. 退出功能界面");//进入启动界面
            System.out.println("7. 注销当前用户");
            System.out.println("请进行功能选择: ");

            int command = sc.nextInt();
            switch (command) {
                case 1:
                    showLoginAccount();
                    break;
                case 2:
                    depositMoney();
                    break;
                case 3:
                    drawMoney();
                    break;
                case 4:
                    transferMoney();
                    break;
                case 5:
                    updatePassWord();
                    break;
                case 6:
                    System.out.println("恭喜你，成功退出系统");
                    return;//返回登录界面
                case 7:
                    deleteAccount();
                    return;//返回登录界面
                default:
                    System.out.println("操作有误，请重新操作");
                    break;
            }
        }
    }

    private void deleteAccount() {
        System.out.println("===注销当前用户===");
        while (true) {
            System.out.println("确认注销当前用户？Y/N");
            char command = sc.next().charAt(0);
            switch (command) {
                case 'Y':
                    accounts.remove(loginAcc);
                    System.out.println("注销用户成功");
                    return;
                case 'N':
                    return;
                default:
                    System.out.println("操作有误，请重新操作");
                    break;
            }
        }
    }

    private void updatePassWord() {
        System.out.println("===修改密码===");
        while (true) {
            System.out.println("请输入原密码: ");
            String passWord = sc.next();
            if (passWord.equals(loginAcc.getPassWord())) {
                System.out.println("开始修改密码");
                while (true) {
                    System.out.println("请输入新密码: ");
                    String newPassWord = sc.next();
                    System.out.println("请重新输入密码: ");
                    String okPassWord = sc.next();
                    if (okPassWord.equals(newPassWord)) {
                        loginAcc.setPassWord(okPassWord);
                        System.out.println("密码修改成功");
                        return;
                    } else {
                        System.out.println("两次密码输入不一致，请重新操作");
                    }
                }
            } else {
                System.out.println("填写失败，请重新操作");
            }
        }
    }

    private void transferMoney() {
        System.out.println("===转账===");
        //是否有其他用户
        if (accounts.size() < 2) {
            System.out.println("无其他可用于转账的用户");
            return;
        }

        while (true) {
            System.out.println("请输入转账用户的卡号: ");
            String cardId = sc.next();
            Account acc = getAccountByCardId(cardId);

            if (acc == null) {
                //转账用户不存在
                System.out.println("转账用户不存在，请重新操作");
                continue;
            }

            while (true) {
                System.out.println("请输入转账金额: ");
                double money = sc.nextDouble();
                if (money > loginAcc.getMoney()) {
                    System.out.println("超出限额，请重新操作");
                    continue;
                }
                loginAcc.setMoney(loginAcc.getMoney() - money);
                acc.setMoney(acc.getMoney() + money);
                System.out.println("转账成功");
                return;
            }
        }
    }

    private void drawMoney() {
        System.out.println("===取款===");
        while (true) {
            if (loginAcc.getMoney() == 0) {
                //没钱
                System.out.println("请先存款，再取款");
                return;
            }
            while (true) {
                System.out.println("请输入取款款项: ");
                double money = sc.nextDouble();
                if (money > loginAcc.getLimit()) {
                    System.out.println("超出限额，请重新操作");
                } else {
                    loginAcc.setMoney(loginAcc.getMoney() - money);
                    System.out.println("取款成功");
                    return;
                }
            }
        }
    }

    private void depositMoney() {
        System.out.println("===存款===");
        System.out.println("请输入款项: ");
        double money = sc.nextDouble();
        loginAcc.setMoney(loginAcc.getMoney() + money);
        System.out.println("存款成功");
    }

    private void showLoginAccount() {
        System.out.println("===查询用户信息===");
        System.out.println("卡号: " + loginAcc.getCardId());
        System.out.println("用户名: " + loginAcc.getUserName());
        System.out.println("性别: " + loginAcc.getSex());
        System.out.println("余额: " + loginAcc.getMoney());
        System.out.println("取款限额: " + loginAcc.getLimit());
    }

    private Account getAccountByCardId(String cardId) {
        for (int i = 0; i < accounts.size(); i++) {
            Account acc = accounts.get(i);
            if (acc.getCardId().equals(cardId)) {
                return acc;
            }
        }
        return null;
    }
}

第三次编写——改进顺利

用例说明

系统启动界面

  1. 用户登录

    1. 用户输入卡号ID和密码，系统进行接收

    2. 系统判断后，反馈用户相应信息

      1. 若卡号在系统数据库中无法找到，则无需验证密码，提示用户账号有误或不存在

      2. 若卡号能在数据库中找到，则验证密码

        1. 密码正确，进入系统功能界面

        2. 密码错误，提示用户卡号或密码错误，需要重新输入

  1. 注册用户

    1. 用户输入相应信息和设置密码，系统自动生成，并返还给用户一个独一无二的卡号（数据库中唯一）

    2. 返回到系统启动界面进行登录操作

系统功能界面

  1. 查询用户信息

    1. 用户选择查询功能，系统显示用户的信息

  1. 存款

    1. 用户输入存款金额，系统修改用户余额

  1. 取款

    1. 用户选择取款功能并输入金额， 系统先判断金额是否超过限额， 后判断金额是否超过用户余额

      1. 只超过限额，系统提示用户超额取款信息

      2. 只超过用户余额，系统提示用户余额不足信息

      3. 都未超过，系统修改用户余额

  1. 转账

    1. 用户输入对方卡号，系统判断对方卡号是否存在

      1. 转账用户不存在，系统提示用户转账用户不存在

      2. 转账用户存在，系统提示输入转账金额

        1. 用户输入转账金额，系统判断是否超过用户余额

          1. 超过，提示用户余额不足

          2. 不超过，系统修改双方用户的余额

  1. 修改密码

    1. 用户输入原密码，系统验证是否是原密码

      1. 否，验证失败，方法结束

      2. 是，验证成功，系统提示输入新密码和确认密码

        1. 用户两次输入密码，系统判断两次密码是否一致

          1. 不一致，系统提示重新输入

          2. 一致，系统修改用户密码，方法结束

  1. 退出系统

    1. 函数方法结束返回到启动界面

  1. 注销账户

    1. 系统询问是否注销账户，用户输入选择

      1. 否，方法结束返回功能界面

      2. 是

        1. 无余额，方法结束返回系统启动界面

        2. 有余额，方法结束返回系统功能界面

ATM 类（9.87KB）

package com.qszl;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;


/**
 * @author Bourbon
 * @version 3.0
 */
public class ATM {
    private ArrayList<Account> accounts = new ArrayList<>();
    private Scanner sc = new Scanner(System.in);
    private static double limit = 1000;
    private Account loginAcc = new Account();

    public void start() {
        while (true) {
            System.out.println();
            System.out.println("====欢迎使用 ATM 系统====");
            System.out.println("1. 用户登录");
            System.out.println("2. 注册用户");
            System.out.println("请选择: ");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    login();
                    break;
                case 2:
                    createAccount();
                    break;
                default:
                    System.out.println("操作有误，请重新操作");
                    break;
            }
        }
    }

    private void createAccount() {
        Account acc = new Account();

        System.out.println("请输入用户名: ");
        String userName = sc.next();
        acc.setUserName(userName);

        while (true) {
            System.out.println("请输入性别: ");
            char sex = sc.next().charAt(0);
            if (sex == '男' || sex == '女') {
                acc.setSex(sex);
                break;
            }
            System.out.println("输入有误，请重新操作");
        }

        System.out.println("请设置密码: ");
        String passWord = sc.next();
        acc.setPassWord(passWord);

        acc.setLimit(limit);

        System.out.println("生成卡号: ");
        while (true) {
            String cardId = createCardId();
            if (getAccountByCardId(cardId) == null) {
                System.out.println(cardId);
                acc.setCardId(cardId);

                System.out.println("请进行用户登录");
                break;
            }
        }

        accounts.add(acc);
        /*失误 1：
          未将对象放入集合中，影响到后面的登录操作*/
    }

    private Account getAccountByCardId(String cardId) {
        for (int i = 0; i < accounts.size(); i++) {
            Account acc = accounts.get(i);
            if (cardId.equals(acc.getCardId())) {
                return acc;
            }
        }
        return null;
    }

    private String createCardId() {
        Random r = new Random();
        String cardId = "";
        for (int i = 0; i < 8; i++) {
            int data = r.nextInt(10);
            cardId += data;
        }
        return cardId;
    }

    private void login() {
        /*失误 2：
          未事先判断集合中是否有对象元素，
          如果事先判断了，就一定会知道问题所在
        */
        if (accounts.size() == 0) {
            System.out.println("系统中没有任何用户记录，请注册用户");
            return;
        }

        while (true) {
            System.out.println("请输入用户卡号: ");
            String cardId = sc.next();
            System.out.println("请输入密码: ");
            String passWord = sc.next();
            Account acc = getAccountByCardId(cardId);
            if (acc == null || !passWord.equals(acc.getPassWord())) {
                System.out.println("用户卡号或密码错误，请重新操作");
                continue;
            }
            loginAcc = acc;
            showUserCommand();
            return;
        }
    }

    private void showUserCommand() {
        while (true) {
            System.out.println();
            System.out.println("====欢迎进入系统功能界面====");
            System.out.println("1. 查询账户信息");
            System.out.println("2. 存款");
            System.out.println("3. 取款");
            System.out.println("4. 转账");
            System.out.println("5. 修改密码");
            System.out.println("6. 退出系统");
            System.out.println("7. 注销账户");
            System.out.println("请选择功能: ");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    showLoginAccount();
                    break;
                case 2:
                    depositMoney();
                    break;
                case 3:
                    drawMoney();
                    break;
                case 4:
                    transferMoney();
                    break;
                case 5:
                    updatePassWord();
                    return;
                case 6:
                    System.out.println("恭喜你，成功退出系统");
                    return;
                case 7:
                    if (deleteAccount()) {
                        accounts.remove(loginAcc);
                        System.out.println("注销账户成功");
                        return;
                    }

                    break;
                default:
                    System.out.println("输入有误，请重新操作");
                    break;
            }
        }
    }

    private boolean deleteAccount() {
        while (true) {
            System.out.println();
            System.out.println("====注销账户====");
            System.out.println("请问是否确定注销账户？ y/n");
            char command = sc.next().charAt(0);
            switch (command) {
                case 'y':
                    if (loginAcc.getMoney() != 0) {
                        System.out.println("账户存在余额，无法注销");
                        return false;
                    }
                    return true;
                case 'n':
                    System.out.println("保留账户");
                    /*
                     * 如果一定要保留账户后显示功能界面，而非启动界面，该怎么做？
                     * （已解决）
                     * */
                    return false;
                default:
                    System.out.println("输入有误，请重新操作");
                    break;
            }
        }
    }

    private void updatePassWord() {
        while (true) {
            System.out.println();
            System.out.println("====修改密码====");
            System.out.println("请输入原密码: ");
            String passWord = sc.next();

            if (!passWord.equals(loginAcc.getPassWord())) {
                System.out.println("验证失败，请重新操作");
                continue;
            }

            System.out.println("账户密码验证成功");
            System.out.println();
            while (true) {
                System.out.println("请输入新密码: ");
                String newPassWord = sc.next();
                System.out.println("请确认新密码: ");
                String okPassWord = sc.next();

                if (!okPassWord.equals(newPassWord)) {
                    System.out.println("两次输入密码不一致，请重新操作");
                    continue;
                }
                loginAcc.setPassWord(okPassWord);
                System.out.println("恭喜你，账户密码修改成功");
                return;
            }
        }
    }

    private void transferMoney() {
        while (true) {
            System.out.println();
            System.out.println("====转账====");
            System.out.println("请输入款项接收方卡号: ");
            String cardId = sc.next();
            Account acc = getAccountByCardId(cardId);
            if (acc == null) {
                System.out.println("接收方账户不存在，请重新操作");
                continue;
            }
            while (true) {
                System.out.println("请输入转账金额: ");
                double money = sc.nextDouble();
                if (money > loginAcc.getMoney()) {
                    System.out.println("用户余额不足");
                    continue;
                }
                loginAcc.setMoney(loginAcc.getMoney() - money);
                acc.setMoney(acc.getMoney() + money);
                System.out.println("恭喜你，转账成功");
                return;
            }
        }
    }

    private void drawMoney() {
        while (true) {
            System.out.println();
            System.out.println("====取款====");
            System.out.println("请输入取款金额: ");
            Double money = sc.nextDouble();
            if (money > limit) {
                System.out.println("取款超出限额，请重新操作");
                continue;
            }
            if (money > loginAcc.getMoney()) {
                System.out.println("账户余额不足，请重新操作");
                continue;
            }
            loginAcc.setMoney(loginAcc.getMoney() - money);
            System.out.println("恭喜你，取款成功");
            return;
        }
    }

    private void depositMoney() {
        System.out.println();
        System.out.println("====存款====");
        System.out.println("请输入存款金额: ");
        Double money = sc.nextDouble();
        loginAcc.setMoney(loginAcc.getMoney() + money);
        System.out.println("恭喜你，存款成功");
    }

    private void showLoginAccount() {
        System.out.println();
        System.out.println("====账户信息====");
        System.out.println("用户名: " + loginAcc.getUserName());
        System.out.println("性别: " + loginAcc.getSex());
        System.out.println("卡号: " + loginAcc.getCardId());
        System.out.println("余额: " + loginAcc.getMoney());
    }
}
  1. 主要还是在于编写的逻辑要更贴近系统文件的扫描顺序、思维方式，改进写法，除去多于的else等语句，形成自己的编写习惯

  2. createAccount() 失误 1：未将对象放入集合中，影响到后面的登录操作

  3. login() 失误 2：未事先判断集合中是否有对象元素，如果事先判断了，就一定会知道问题所在

  4. deleteAccount() 如果一定要保留账户后显示功能界面，而非启动界面，该怎么做？ （已解决，将方法返回类型变为布尔型

  5. limit改为静态变量，而不依靠注册输入

qszl
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值