【Java从入门到大牛】模拟ATM系统

缺乏、安全感 2024-04-26 02:43 6阅读 0赞

> 🔥 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> 💖 系列专栏：[Java从入门到大牛][Java]  
> 🌠 首发时间：2023年7月14日  
> 🦋 欢迎关注🖱点赞👍收藏🌟留言🐾  
> 🌟 一以贯之的努力 不得懈怠的人生

#### 目录 ####

*  系统架构搭建
 *  欢迎页设计
 *  开户功能实现
 *  登录功能实现
 *  操作页展示、查询账户、退出账户
 *  存款、取款功能实现
 *  转账功能实现
 *  销户功能实现
 *  用户密码修改
 *  源码分享

## 系统架构搭建 ##

1.  定义一个账户类 Account，至少需要包含卡号、姓名、性别、密码、余额、每次取现额度
2.  定义一个 ATM 类，用来代表 ATM 系统，负责提供所有的业务需求，比如：展示 ATM 的系统欢迎页、开通账户、转账…
3.  定义一个测试类 Test，负责对我们开发的 ATM 系统进行测试

## 欢迎页设计 ##

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

## 开户功能实现 ##

**用户开户功能**

就是新增一个账户，也就是往系统的账户集合中添加一个账户对象

**账户的要求**

*  用户信息包含：姓名、性别、密码、每次取现额度、卡号
 *  注意：卡号由系统生成，要求是由 8 位的数字组成且卡号不能重复

**开户功能实现分析**

*  定义一个开户方法：createAccount
 *  在方法里创建一个 Account 账户对象，负责封装用户的账户信息
 *  卡号需要系统自动生成
 *  把账户对象存入到账户集合中去
 *  提示开户成功

**如何实现系统自动生成新卡号**

*  定义一个方法：createCardId()，用来返回一个不重复的新卡号
 *  方法里，使用循环生成了 8 个随机的数字连起来作为卡号
 *  接着判断该卡号是否与其他账户的卡号重复
 *  根据该卡号去账户集合中查询账户对象，如果没有查询到该账户对象，则说明该卡号不重复，即可返回
 *  如果查询到了账户对象，则重新生成

## 登录功能实现 ##

**用户登录功能**

*  如果系统没有任何账户对象，则不允许登录
 *  让用户输入登录的卡号，先判断卡号是否正确，如果不正确要给出提示
 *  如果卡号正确，再让用户输入账户密码，如果密码不正确要给处提示，如果密码也正确，则给出登录成功提示

**登录功能实现分析**

*  设计一个登录方法：login，负责完成用户的登录
 *  方法里：如果系统无任何对象，直接结束登录操作
 *  有账户对象，则让用户输入卡号，根据卡号去账户集合中查询账户对象
 *  如果没有找到账户对象，说明登录卡号不存在，提示继续输入卡号
 *  如果找到了账户对象，说明卡号存在，继续输入密码
 *  如果密码不正确，提示继续输入密码
 *  如果密码正确，则登录成功，并给出相应的提示

## 操作页展示、查询账户、退出账户 ##

1.  用户登录成功后，需要进入用户操作页
2.  查询就是直接展示当前登录成功的用户的账户信息
3.  退出账户就是回到欢迎页面

## 存款、取款功能实现 ##

**用户存款功能**

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

**用户取款功能**

就是从自己的账户中取钱，取钱的要求：

1.  需要先判断账户的余额是否大于等于 100 元，如果够，让用户输入取款金额
2.  需要判断取款金额是否超过了单次限额，以及余额是否足够

## 转账功能实现 ##

**用户转账功能**

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

1.  自己账户是否有钱，系统中是否有其他账户
2.  接下来让用户输入对方卡号，判断对方账户是否存在，账户如果存在，还需要认证对方账户的户主姓氏

## 销户功能实现 ##

**销户操作的基本需求**

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

1.  首先要询问用户是否确定要销户，如果不确定，则回到操作界面
2.  如果确定，要判断用户的账户中是否有钱，有则不允许销户，并回到操作界面
3.  如果没钱，则完成销户，并回到欢迎页

## 用户密码修改 ##

**密码修改**

就是更改账户的密码，修改密码的要求：

1.  需要先认证用户当前的密码
2.  认证通过后，需要让用户输入 2 次新密码
3.  两次密码一样，则更新账户密码，并回到欢迎界面

## 源码分享 ##

**账户类 Account**

// 账户类
    public class Account {
        
        private String cardId;      // 账号
        private String userName;    // 账户名
        private char sex;           // 性别
        private String passWord;    // 密码
        private double money;       // 余额
        private double 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系统类**

import java.util.ArrayList;
    import java.util.Random;
    import java.util.Scanner;
    
    // ATM系统类
    public class ATM {
        
        private ArrayList<Account> accounts = new ArrayList<>();    // 系统内所有账户
        private Scanner sc = new Scanner(System.in);
        private Account loginAcc; // 记住登录后的用户账户
    
        /** 启动ATM系统 展示欢迎界面 */
        public void start(){
        
            while (true) {
        
                System.out.println("===欢迎您进入到了ATM系统===");
                System.out.println("1、用户登录");
                System.out.println("2、用户开户");
                System.out.print("请选择：");
                int command = sc.nextInt();
    
                switch (command){
        
                    case 1:
                        // 用户登录
                        login();
                        break;
                    case 2:
                        // 用户开户
                        createAccount();
                        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.print("请您输入您的登录卡号：");
                String cardId = sc.next();
    
                // 3、判断这个卡号是否存在
                Account acc = getAccountByCardId(cardId);
                if(acc == null){
        
                    // 说明这个卡号不存在
                    System.out.println("您输入的登录卡号不存在，请确认~~");
                }else {
        
                    while (true) {
        
                        // 卡号存在了，接着让用户输入密码
                        System.out.print("请您输入登录密码：");
                        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.print("请选择：");
                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("==账户密码修改操作==");
            while (true) {
        
                // 1、提醒用户认证当前密码
                System.out.print("请您输入当前账户的密码：");
                String passWord = sc.next();
    
                // 2、认证当前密码是否正确啊
                if(loginAcc.getPassWord().equals(passWord)){
        
                    // 认证通过
                    while (true) {
        
                        // 3、真正开始修改密码了
                        System.out.print("请您输入新密码：");
                        String newPassWord = sc.next();
    
                        System.out.print("请您再次输入密码：");
                        String okPassWord = sc.next();
    
                        // 4、判断2次 密码是否一致
                        if(okPassWord.equals(newPassWord)){
        
                            // 可以真正开始修改密码了
                            loginAcc.setPassWord(okPassWord);
                            System.out.println("恭喜您，您的密码修改成功~~~");
                            return;
                        }else {
        
                            System.out.println("您输入的2次密码不一致~~");
                        }
                    }
                }else {
        
                    System.out.println("您当前输入的密码不正确~~");
                }
            }
        }
    
        /** 销户操作 */
        private boolean deleteAccount() {
        
            System.out.println("==进行销户操作==");
            // 1、问问用户是否确定要销户啊
            System.out.print("请问您确认销户吗？y/n");
            String command = sc.next();
            switch (command) {
        
                case "y":
                    // 2、判断用户的账户中是否有钱：loginAcc
                    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.print("请您输入对方的卡号：");
                String cardId = sc.next();
    
                // 4、判断这个卡号是否正确
                Account acc = getAccountByCardId(cardId);
                if(acc == null){
        
                    System.out.println("您输入的对方的卡号不存在~~");
                }else {
        
                    // 对方的账户存在，继续让用户认证姓氏
                    String name = "*" + acc.getUserName().substring(1);     // 隐藏姓氏
                    System.out.print("请您输入【" + name + "】的姓氏：");
                    String preName = sc.next();
    
                    // 5、判断这个姓氏是否正确啊
                    if(acc.getUserName().startsWith(preName)) {
        
                        while (true) {
        
                            // 认证通过
                            System.out.print("请您输入转账给对方的金额：");
                            double money = sc.nextDouble();
    
                            // 6、判断这个金额是否超过自己的余额
                            if(loginAcc.getMoney() >= money){
        
                                // 更新自己的账户余额
                                loginAcc.setMoney(loginAcc.getMoney() - money);
                                // 更新对方的账户余额
                                acc.setMoney(acc.getMoney() + money);
                                System.out.println("您转账成功了~~~");
                                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.print("请您输入取款金额：");
                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.print("请您输入存款金额：");
            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 createAccount(){
        
            System.out.println("==系统开户操作==");
            // 1、创建一个账户对象，用于封装用户的开户信息
            Account acc = new Account();
    
            // 2、需要用户输入自己的开户信息，赋值给账户对象
            System.out.print("请输入您的账户名称：");
            String name = sc.next();
            acc.setUserName(name);
    
            while (true) {
        
                System.out.print("请输入您的性别：");
                char sex = sc.next().charAt(0);
                if(sex == '男' || sex == '女'){
        
                    acc.setSex(sex);
                    break;
                }else {
        
                    System.out.println("您输入的性别有误~只能是男或者女~");
                }
            }
    
            while (true) {
        
                System.out.print("请输入您的账户密码：");
                String passWord  = sc.next();
                System.out.print("请确定您的账户密码：");
                String okPassWord  = sc.next();
                // 判断2次密码是否一样。
                if(okPassWord.equals(passWord)){
        
                    acc.setPassWord(okPassWord);
                    break;
                }else {
        
                    System.out.println("您输入的2次密码不一致，请您确认~~");
                }
            }
    
            System.out.print("请输入您的取现额度：");
            double limit = sc.nextDouble();
            acc.setLimit(limit);
    
            // 重点：我们需要为这个账户生成一个卡号（由系统自动生成。8位数字表示，不能与其他账户的卡号重复：会在下节课详细讲解）
            String newCardId = createCardId();
            acc.setCardId(newCardId);
    
            // 3、把这个账户对象，存入到账户集合中去
            accounts.add(acc);
            System.out.println("恭喜您，" + acc.getUserName() + "开户成功，您的卡号是：" + acc.getCardId());
        }
    
        /** 返回一个8位 数字的卡号，而且这个卡号不能与其他账户的卡号重复 */
        private String createCardId(){
        
            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); // 0 - 9
                    cardId += data;
                }
                // 3、判断cardId中记住的卡号，是否与其他账户的卡号重复了，没有重复，才可以做为一个新卡号返回。
                Account acc = getAccountByCardId(cardId);
                if(acc == null){
        
                    // 说明cardId没有找到账户对象，因此cardId没有与其他账户的卡号重复，可以返回它做为一个新卡号
                    return cardId;
                }
            }
        }
    
        /** 根据卡号查询账户对象返回 */
        private Account getAccountByCardId(String cardId){
        
            // 遍历全部的账户对象
            for (int i = 0; i < accounts.size(); i++) {
        
                Account acc = accounts.get(i);
    
                // 判断这个账户对象acc中的卡号是否是我们要找的卡号
                if(acc.getCardId().equals(cardId)){
        
                    return acc;
                }
            }
            return null; // 查无此账户，这个卡号不存在的
        }
    }

**测试类 Test**

// 测试类
    public class Test {
        
        public static void main(String[] args) {
        
            // 1、创建一个ATM对象，代表ATM系统
            ATM atm =  new ATM();
    
            // 2、调用ATM对象的start方法，启动系统
            atm.start();
        }
    }

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Java]: https://blog.csdn.net/weixin_62511863/category_12365679.html?spm=1001.2014.3001.5482