ATM系统开发

系统准备&首页设计

1. 分析：
   • 每个用户的账户信息都是一个对象，需要提供账户类
   • 需要准备一个容器，用于存储系统全部账户信息
   • 首页只需要包含：登录和注册两个功能
2. 实现：
   • 定义账户类，用于后期创建账户对象封装用户的账户信息
   • 账户类中的信息至少需要包含（卡号，姓名，密码，余额，取现额度）
   • 需要准备一个ArrayList集合，用于存储系统用户和账户对象
   • 需要展示欢迎页包含两个功能：开户功能，登录账户

用户开户功能实现

1. 分析：
   • 开户功能其实就是往系统的集合容器中存入一个新的账户对象的信息
2. 实现：
   • 定义方法完成开户
   • 键盘录入姓名，密码，确认密码（且保证两次密码一致）
   • 生成账户卡号，卡号必须由系统自动生成8位数字（必须保证卡号的唯一）
   • 创建Account账户类对象用于封装账户信息
   • 把Account账户类对象存入到集合accounts中去

用户登录功能实现

1. 分析：
   • 定义登录方法接收账户容器（需要在账户容器里面寻找目标账户）
   • 让用户键盘录入卡号，根据卡号查询账户对象
   • 如果没有找到账户对象，说明卡号不存在，提示重新输入卡号
   • 如果找到了账户对象，说明卡号存在，提示输入密码
   • 如果密码正确，提示登录成功
   • 如果密码不正确，显示剩余可输入次数，达到上限便冻结该账户并结束程序

用户操作页设计，查询账户，退出账户功能实现

1. 分析：
   • 用户登录成功后，需要进入用户操作页
   • 查询就是直接展示当前登陆成功的账户对象的信息
   • 退出账户是需要回到首页的

用户存款功能实现

1. 分析:
   • 存款就是拿到当前账户对象
   • 然后让用户输入存款的金额
   • 调用账户对象的setMoney方法将账户余额修改成存钱后的余额
   • 存钱后需要查询一下账户信息，确认是否存钱成功

用户取款功能实现

1. 分析：
   • 取款需要先判断账户是否有钱
   • 有钱则拿到自己账户对象
   • 用户输入取款金额
   • 判断取款金额是否超过当前限额，以及余额是否足够
   • 满足要求则调用账户对象的setMoney方法完成金额的修改

用户转账功能实现

1. 分析：
   • 转账功能需要判断系统中是否具有2个以上的账户对象
   • 同时判断自己账户是否有足够的额度
   • 输入对方卡号，判断对方卡号是否存在
   • 对方账户存在时验证对方信息
   • 满足所有要求时将自己账户对象的金额转给对方的账户对象上，同时完成双方的账户余额更新

用户密码修改，销户功能实现

1. 分析：
   • 修改密码就是把当前对象的密码属性使用set方法进行更新
   • 销户是从集合对象中删除当前对象，并回到首页

ATM系统后台逻辑实现简易代码

package com.java.cases;

/**
 * 账户类
 */
public class Account {
    private String cardId;       // 卡号
    private String userName;     // 户名
    private String passWord;     // 密码
    private double money;        // 余额
    private double quotaMoney;   // 限额


    public Account() {
    }

    public Account(String cardId, String userName, String passWord, double quotaMoney) {
        this.cardId = cardId;
        this.userName = userName;
        this.passWord = passWord;
        this.quotaMoney = quotaMoney;
    }

    public String getCardId() {
        return cardId;
    }

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

    public String getUserName() {
        return userName;
    }

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

    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 getQuotaMoney() {
        return quotaMoney;
    }

    public void setQuotaMoney(double quotaMoney) {
        this.quotaMoney = quotaMoney;
    }
}

package com.java.cases;

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

public class ATMSystem {
    public static void main(String[] args) {
        // 1.准备系统需要的容器对象accounts，用于存储账户对象
        ArrayList<Account> accounts = new ArrayList();
        // 2.准备系统的首页，登录，开户
        Scanner sc = new Scanner(System.in);
        firstPage(accounts, sc);

    }

    /**
     * 首页设计
     */
    public static void firstPage(ArrayList<Account> accounts, Scanner sc) {
        while (true) {
            System.out.println("====================欢迎登录ATM系统====================");
            System.out.println("指令菜单：");
            System.out.println("1.登录");
            System.out.println("2.开户");
            System.out.println("请您输入操作指令：");
            int cmd = sc.nextInt();
            switch (cmd) {
                case 1:
                    // 登录
                    login(accounts, sc);
                    break;
                case 2:
                    // 开户
                    register(accounts, sc);
                    break;
                default:
                    System.out.println("指令错误");
            }
        }
    }

    /**
     * 完成用户登录
     */
    public static void login(ArrayList<Account> accounts, Scanner sc) {
        // 必须系统中存在账户才可以登录
        if (accounts.size() == 0) {
            System.out.println("当前系统没有任何账户，请先创建账户！");
            return; // 使用return直接结束用户的非法登录操作
        }
        System.out.println("=======================登录功能=======================");
        // 用户键盘录入卡号
        while (true) {
            System.out.println("请您输入登录的卡号：");
            String cardId = sc.next();
            // 根据卡号查询账户对象
            Account ac = getAccountByCardId(cardId, accounts);
            // 判断账户对象是否存在
            if (ac != null) {
                int count = 0;
                while (true) {
                    // 用户输入密码
                    if (count == 0) {
                        System.out.println("请您输入登录密码：");
                    } else {
                        System.out.println("密码错误，请重新输入：");
                    }
                    String password = sc.next();
                    // 判断密码是否正确
                    if (ac.getPassWord().equals(password)) {
                        operatePage(sc, ac, accounts);  // 此处的accounts是为了满足转账涉及多个对象时的需要
                        return; // 继续结束本方法
                    }
                    count++;
                }

            } else {
                System.out.println("卡号不存在！");
            }
        }

    }

    /**
     * 用户操作界面
     */
    public static void operatePage(Scanner sc, Account ac, ArrayList<Account> accounts) {
        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 cmd = sc.nextInt();
            switch (cmd) {
                case 1:
                    // 查询账户
                    showAccount(ac);
                    break;
                case 2:
                    // 存款
                    depositMoney(ac, sc);
                    break;
                case 3:
                    // 取款
                    drawMoney(ac, sc);
                    break;
                case 4:
                    // 转账
                    transfer(ac, sc, accounts);   //转账设计多个对象，因此需要传入所有的账户
                    break;
                case 5:
                    // 修改密码
                    updatePassword(sc, ac);
                    return; // 因为更新了密码，所以需要用户重新登录，使用return而不是break结束方法返回主页重新登陆
                case 6:
                    // 退出
                    System.out.println("感谢您使用本系统！");
                    return; //因为需要退出，所以使用return而不是break，用来结束本方法返回首页
                case 7:
                    // 注销账户
                    // 从当前集合中删除集合对象即可
                    accounts.remove(ac);
                    System.out.println("销户成功！感谢您的使用！");
                    return; //账户被删除，直接退出系统前往首页
                default:
                    System.out.println("指令错误，请重新输入：");
            }
        }

    }

    /**
     * 修改密码功能
     *
     * @param sc
     * @param ac
     */
    private static void updatePassword(Scanner sc, Account ac) {
        while (true) {
            System.out.println("=======================修改密码=======================");
            System.out.println("请您输入正确的密码：");
            String oldPassWord = sc.next();
            // 判断旧密码是否正确
            if (ac.getPassWord().equals(oldPassWord)) {
                while (true) {
                    System.out.println("请您输入新密码：");
                    String newPassWord1 = sc.next();
                    System.out.println("请再次输入新密码确认：");
                    String newPassWord2 = sc.next();
                    if (newPassWord1.equals(newPassWord2)) {
                        ac.setPassWord(newPassWord2);
                        System.out.println("密码修改成功！");
                        return; //密码修改完成，直接结束本方法
                    } else {
                        System.out.println("两次输入的密码不一致！");
                    }
                }
            } else {
                System.out.println("两次输入的密码不一致！");
            }
        }
    }

    /**
     * 转账功能
     */
    public static void transfer(Account ac, Scanner sc, ArrayList<Account> accounts) {
        // 判断系统中是否有多个系统
        if (accounts.size() < 2) {
            System.out.println("当前ATM系统中总用户数不足以支持转账操作！");
            return;
        } else {
            // 判断自己的余额是否支持操作
            if (ac.getMoney() == 0.0) {
                System.out.println("您当前的可用余额不足以完成本次转账！");
                return;
            } else {
                while (true) {
                    // 转账开始
                    System.out.println("=======================转账功能=======================");
                    System.out.println("请输入对方账户的卡号：");
                    String cardId = sc.next();
                    // 判断卡号是否存在
                    Account account = getAccountByCardId(cardId, accounts);
                    if (account != null) {
                        // 防止极端非法操作：自我转账
                        if (account.getCardId().equals(ac.getCardId())) {
                            System.out.println("您正在给自己账户转账，操作非法，请禁止！");
                        } else {// 确认信息
                            while (true) {
                                String name = "*" + account.getUserName().substring(1); //截取，只显示名，隐藏姓氏
                                System.out.println("您正在给【" + name + "】转账，请输入确认该用户的姓氏：");
                                String lastName = sc.next();
                                if (account.getUserName().startsWith(lastName)) {
                                    while (true) {
                                        // 转账
                                        System.out.println("请输入转账的金额：");
                                        double money = sc.nextDouble();
                                        if (money > ac.getMoney()) {
                                            System.out.println("余额不足，请重新输入转账金额");
                                        } else {
                                            if (money > ac.getQuotaMoney()) {
                                                System.out.println("转账金额超过交易限额，请重新输入转账金额！");
                                                System.out.println("您的账户限额：" + ac.getQuotaMoney() + "元");
                                            } else {
                                                // 所有前置条件都成立
                                                ac.setMoney(ac.getMoney() - money);
                                                account.setMoney(account.getMoney() - money);
                                                ac.setQuotaMoney(ac.getQuotaMoney() - money);
                                                System.out.println("转账成功");
                                                System.out.println("您本次已为" + account.getCardId() + "转账" + money + "元");
                                                showAccount(ac);
                                                return;
                                            }
                                        }
                                    }
                                } else {
                                    System.out.println("对不起，请重新确认目标用户信息！");
                                }
                            }
                        }
                    } else {
                        System.out.println("该卡号不存在！请重新输入！");
                    }
                }
            }
        }
    }

    /**
     * 取款功能
     */
    public static void drawMoney(Account ac, Scanner sc) {
        System.out.println("=======================取款功能=======================");
        if (ac.getMoney() >= 100) {
            while (true) {
                System.out.println("请您输入取款的金额：");
                double money = sc.nextDouble();
                // 判断取款金额是否超过账户限额
                if (money > ac.getQuotaMoney()) {
                    System.out.println("取款金额超过账户限额，取款失败！");
                    System.out.println("您的账户限额为：" + ac.getQuotaMoney());
                } else {
                    // 判断余额是否支持取款额度
                    if (ac.getMoney() >= money) {
                        ac.setMoney(ac.getMoney() - money);
                        System.out.println("取款成功,您已取款" + money + "元");
                        System.out.println("账户余额：" + ac.getMoney());
                        System.out.println("当日限额：" + (ac.getQuotaMoney() - money));
                        return; // 取款成功，方法结束
                    } else {
                        System.out.println("余额不足，取款失败！");
                    }
                }
            }
        } else {
            System.out.println("余额不足100，取款失败！");
        }
    }

    /**
     * 存款功能
     */
    public static void depositMoney(Account ac, Scanner sc) {
        System.out.println("=======================存款功能=======================");
        System.out.println("请输入存款金额：");
        double money = sc.nextDouble();

        //直接把金额修改到账户对象的money属性中去
        ac.setMoney(ac.getMoney() + money); // 将账户的余额使用get得出加上本次的存款，最后set设置
        System.out.println("存款成功！");
        showAccount(ac);
    }

    /**
     * 查询账户
     */
    public static void showAccount(Account ac) {
        System.out.println("=======================账户详情=======================");
        System.out.println("卡号：" + ac.getCardId());
        System.out.println("姓名：" + ac.getUserName());
        System.out.println("余额：" + ac.getMoney());
        System.out.println("限额：" + ac.getQuotaMoney());
    }

    /**
     * 用户开户功能
     *
     * @param accounts 账户的集合对象
     */
    public static void register(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("=======================开户功能=======================");
        System.out.println("1.请您输入开户名称：");
        String name = sc.next();
        String password = "";
        while (true) {
            System.out.println("2.请您输入开户密码：");
            password = sc.next();
            System.out.println("3.请您输入确认密码：");
            String confirmPassword = sc.next();

            // 判断两次密码是否在一直
            if (password.equals(confirmPassword)) {
                break;
            } else {
                System.out.println("两次密码不一致，请检查重新输入：");
            }
        }

        System.out.println("4.请您输入单次交易现额：");
        double quotaMoney = sc.nextDouble();

        // 3.生成账户卡号，卡号是8位，且要求不能重复
        String cardId = createCardId(accounts);

        // 4.创建一个账户对象封装账户的信息
        Account account = new Account(cardId, name, password, quotaMoney);

        // 5.把账户对象添加到集合中去
        accounts.add(account);
        System.out.println("恭喜您已开户成功，您的卡号是：" + account.getCardId());

    }

    /**
     * 生成卡号并判断
     */
    public static String createCardId(ArrayList<Account> accounts) {
        while (true) {
            // 生成卡号
            Random r = new Random();
            String cardId = "";
            for (int i = 0; i < 8; i++) {
                cardId += r.nextInt(10);
            }

            // 判断卡号
            Account ac = getAccountByCardId(cardId, accounts);
            if (ac == null) {
                // 说明卡号没有重复
                return cardId;
            }
        }
    }

    /**
     * 根据卡号查询卡号对象
     */
    public static Account getAccountByCardId(String cardId, ArrayList<Account> accounts) {
        for (int i = 0; i < accounts.size(); i++) {
            Account ac = accounts.get(i);
            if (ac.getCardId().equals(cardId)) {
                return ac;
            }
        }
        return null;    //查无此账号，卡号不重复
    }

}