模拟银行ATM机系统

• 01 面向对象编程：

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

• 02 使用集合容器：

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

• 03 程序流程控制

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

• 04 使用常见API

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

01 收货一：面向对象编程能力

02 收货二：清晰、缜密的业务分析能力、数据处理能力

03 收获三：熟练使用流程语句来控制计算机完成自己的想法

04 收获四：良好的编码习惯，一定的编码经验，让基础知识形成体系，为后续Java高级技术的学习做有力的支撑

一、系统架构搭建、欢迎页设计：

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

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

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

系统欢迎页面设计

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

===欢迎进入某某银行ATM系统===

1、用户登录

2、用户开户

请选择您要操作的命令：

总结：

1、咱们的ATM系统架构是怎么样的？

定义了一个账户类Account，定义系统账户类信息

定义了一个ATM类，代表ATM类，负责处理账户相关的业务需求

定义了一个Test类，负责测试系统：创建ATM对象代表ATM系统并启动。

2、ATM类中使用什么来存储系统全部用户的账户信息的？

使用ArrayList<>集合

ArrayList accounts = new ArrayList<>();

二、开户功能实现

用户开户功能

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

账户要求

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

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

1、开户功能的实现需要哪几个步骤？

定义一个开户方法：createAccount。

在方法里创建一个Account账户对象，负责封装用户的账户信息（姓名、性别、卡号、密码等等）

卡号需要由系统自动生成（卡号要求是8位数字组成的，且不能重复，下节课详细讲解这个）

把账户对象存入到账户集合中去。

提示开户成功！

package com.itheimaATM;
/*
系统准备内容分析：
1、每个用户的账户信息都是一个对象，创建一个账户类
2、需要准备一个容器，用于存储系统全部账户的对象信息
3、首页只需要包含账户登录和账户注册2个功能。

实现步骤：
1、定义账户类，用于后期创建账户对象，封装用户的账户信息
2、账户类信息至少包括（卡号，姓名，密码，余额，取现额度）


* 账户类：
* */
public class Account {
    /*
    * 成员变量，私有
    * */
    private String cardId;
    private String userName; //用户名
    private String passWord; //密码
    private double money; //账户余额
    private double 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.itheimaATM;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.security.spec.RSAOtherPrimeInfo;
import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/*
 * ATM系统吐口类
 * */
public class ATMSystem extends Throwable {
    public static void main(String[] args) {
        //1.定义账户类
        //2.定义一个集合容器，用来存储全部的账户对象，进行相关的业务操作
        ArrayList<Account> accounts = new ArrayList<Account>();
        Scanner sc = new Scanner(System.in);
        //3.展示系统首页
        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(accounts, sc);
                    break;
                case 2:
                    //用户注册操作(ALT + ENTER)
                    register(accounts, sc);
                    break;
                default:
                    System.out.println("您输入的指令不存在~~");
            }
        }

    }

    /**
     * 登录功能
     *
     * @param accounts 接收的账户集合
     * @param sc       扫描器
     */
    private static void login(ArrayList<Account> accounts, Scanner sc) {
        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, accounts);
            if (acc != null) {
                //卡号存在的
                //4.让用户输入密码，认证密码
                while (true) {
                    System.out.println("请您输入登录密码：");
                    String passWord = sc.next();
                    //判断当前账户对象的密码与用户输入的密码一致

                    if (acc.getPassWord().equals(passWord)) {
                        //登录成功了
                        System.out.println("恭喜您：" + acc.getUserName() + "先生/女士进入系统，您的卡号是" + acc.getCardId());
                        //...查询 转账 取款...
                        //展示登录后的操作页。
                        showUserCommand(sc, acc, accounts);
                        return;//干掉登录方法

                    } else {
                        System.out.println("您输入的密码有误！");
                    }
                }
            } else {
                System.out.println("系统中不存在该账户卡号!");
            }
        }

    }

    /**
     * 展示登录后的操作页
     */
    private static void showUserCommand(Scanner sc, Account acc, 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 command = sc.nextInt();
            switch (command) {
                case 1:
                    //查询账户(展示当前登录的账户)
                    showAccount(acc);
                    break;
                case 2:
                    //存款
                    depositMoney(acc, sc);
                    break;
                case 3:
                    //取款
                    drawMoney(acc, sc);
                    break;
                case 4:
                    //转账
                    transferMoney(sc, acc, accounts);
                    break;
                case 5:
                    //修改密码
                    updatePassWord(sc, acc);
                    return;// 让当前方法停止执行，跳出去
                case 6:
                    //退出
                    System.out.println("退出成功，欢迎下次登录");
                    return;// 让当前方法停止执行，跳出去
                case 7:
                    //注销账户
                    deleteAccount(acc, sc, accounts);
                    return; //让当前方法停止执行，跳出去
                default:
                    System.out.println("您输入的操作命令不正确");
            }
        }
    }

    /**
     * 销户功能
     *
     * @param acc      当前账户
     * @param sc       扫描器
     * @param accounts 账户集合
     */
    private static void deleteAccount(Account acc, Scanner sc, ArrayList<Account> accounts) {
        System.out.println("==================用户销户====================");
        System.out.println("您真的要销户？y/n");
        String rs = sc.next();
        switch (rs) {
            case "y":
                //真的销户
                //从当前账户集合中，删除当前账户对象，销户就完成了。
                if (acc.getMoney() > 0) {
                    System.out.println("您账户中还有钱没有取完，不允许销户");
                } else {
                    accounts.remove(acc);
                    System.out.println("您的账户销户完成！");
                }
                break;
            default:
                System.out.println("好的，当前账户保留");
        }
    }

    /**
     * 修改密码
     *
     * @param sc  扫描器
     * @param acc 当前登录成功的账户对象
     */
    private static void updatePassWord(Scanner sc, Account acc) {
        System.out.println("==================用户密码修改====================");
        while (true) {
            System.out.println("请您输入当前密码：");
            String passWord = sc.next();
            //1.判断当前密码是否正确
            if (acc.getPassWord().equals(passWord)) {
                while (true) {
                    //密码正确
                    //输入新密码
                    System.out.println("请您输入新密码");
                    String newPassWord = sc.next();

                    System.out.println("请您确认新密码");
                    String okPassWord = sc.next();

                    if (newPassWord.equals(okPassWord)) {
                        //2次密码一致，可以修改了
                        acc.setPassWord(newPassWord);
                        System.out.println("恭喜您，密码修改成功！");
                        return;
                    } else {
                        //2次密码不一致，重新输入密码
                        System.out.println("2次输入密码不一致，重新输入密码");
                    }
                }

            } else {
                System.out.println("您输入的密码不正确");
            }
        }
    }

    /**
     * 转账功能
     *
     * @param sc       扫描器
     * @param acc      自己的账户对象
     * @param accounts 全部账户对象集合
     */
    private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) {
        System.out.println("==================用户转账操作====================");
        //1.判断是否有2个账户，
        if (accounts.size() < 2) {
            System.out.println("当前系统中，不足2个账户，不能进行转账，请去开户");
            return; //结束当前方法
        }

        //卫语句风格，层层拦截
        //2.判断自己账户是否有钱，
        if (acc.getMoney() == 0) {
            System.out.println("对不起，您自己都没钱，就别转了");
            return; //结束当前方法
        }

        //3.真正开始转账
        while (true) {
            System.out.println("请您输入对方账户的卡号:");
            String cardId = sc.next();

            //这个卡号不能是自己的卡号
            if (cardId.equals(acc.getCardId())) {
                System.out.println("对不起，您不可以给自己转账");
                continue; //结束当次执行，进入下一次执行
            }

            //判断卡号是否存在，根据卡号查询账户对象
            Account account = getAccountByCardId(cardId, accounts);
            if (account == null) {
                System.out.println("对不起，输入的账户不存在~");
            } else {
                //这个账户对象存在了，继续认证他的姓氏
                String userName = account.getUserName();//黑马周芷若
                String tip = "*" + userName.substring(1); //改成2会怎么样？
                System.out.println("请您输入[" + tip + "]的姓氏");
                String preName = sc.next();

                //认证姓氏是否输入正确，
                if (userName.startsWith(preName)) {
                    //认证通过，真正开始转账了
                    while (true) {
                        System.out.println("请您输入转账金额");
                        double money = sc.nextDouble();
                        //判断金额是否足够(或者超出转账金额)
                        if (money > acc.getMoney() || money > acc.getQuotaMoney()) {
                            System.out.println("余额不足或超出转账限额，最多转账" + acc.getQuotaMoney());
                            System.out.println("您的余额为：" + acc.getMoney());
                        } else {
                            //余额充足可以转了
                            acc.setMoney(acc.getMoney() - money);
                            account.setMoney(account.getMoney() + money);
                            System.out.println("转账成功：您的账户还剩余：" + acc.getMoney());
                            return; //直接干掉转账方法
                        }
                    }
                } else {
                    System.out.println("对不起，数输入的信息有误");
                }
            }
        }

    }

    /**
     * 取钱功能
     *
     * @param acc 当前登录账户对象
     * @param sc  扫描器
     */
    private static void drawMoney(Account acc, Scanner sc) {
        System.out.println("==================用户取钱功能====================");
        //1.判断是否满足100元
        if (acc.getMoney() < 100) {
            System.out.println("对不起，当前账户余额中不足100元，不能取钱~");
            return;
        }

        while (true) {
            //2.提示用户输入取款金额
            System.out.println("请输入取款金额：");
            double money = sc.nextDouble();

            //3.判断金额是否满足要求。
            if (money > acc.getQuotaMoney()) {
                System.out.println("对不起，您当前取款金额超过每次限额，每次最多可取" + acc.getMoney());
            } else {
                //没有超过当次限额
                //4.判断是否超过了账户的总余额
                if (money > acc.getMoney()) {
                    System.out.println("余额不足,您账户总余额是：" + acc.getMoney());
                } else {
                    //可以取钱了
                    System.out.println("恭喜你，取钱" + money + "成功！");
                    //更新金额
                    acc.setMoney(acc.getMoney() - money);
                    //取钱结束了
                    showAccount(acc);
                    return; //结束取钱方法
                }
            }
        }
    }

    /**
     * 存钱
     *
     * @param acc 当前账户对象
     * @param sc  扫描器
     */
    private static void depositMoney(Account acc, Scanner sc) {
        System.out.println("==================用户存钱操作====================");
        System.out.println("请输入存款金额");
        double money = sc.nextDouble();

        //更新账户余额: 原来的钱 + 新存入的钱
        acc.setMoney(acc.getMoney() + money);
        System.out.println("恭喜您，存钱成功，当前账户信息如下：");
        showAccount(acc);
    }

    /**
     * 展示账户信息
     *
     * @param acc
     */
    private static void showAccount(Account acc) {
        System.out.println("================当前账户信息如下==================");
        System.out.println("卡号" + acc.getCardId());
        System.out.println("户主" + acc.getUserName());
        System.out.println("余额" + acc.getMoney());
        System.out.println("限额" + acc.getQuotaMoney());
    }

    /**
     * 用户开户功能的实现
     *
     * @param accounts 接收的账户集合。
     */
    private static void register(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("================系统开户操作==================");
        //1.创建一个账户对象，用于后期封装账户信息。
        Account account = new Account();

        //2.录入当前账户信息，注入到账户对象中去。

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

        while (true) {
            System.out.println("请您输入账户密码:");
            String passWord = sc.next();
            System.out.println("请您输入确认密码");
            String okPassWord = sc.next();
            if (okPassWord.equals(passWord)) {
                //密码认证通过，可以注入账户对象
                account.setPassWord(okPassWord);
                break; //密码已经录入成功了，死循环没有必要继续了
            } else {
                System.out.println("对不起，您输入的2次密码不一致，请重新确认！");
            }
        }

        System.out.println("请您当次限额:");
        double quotaMoney = sc.nextDouble();
        account.setQuotaMoney(quotaMoney);


        //为账户生成一个8位与其他账户卡号不重复的号码(独立功能，独立成方法)
        String cardId = getRandomCardId(accounts);
        account.setCardId(cardId);

        //3.把账户对象添加到账户集合中去。
        accounts.add(account);
        System.out.println("恭喜您，" + userName + "先生/女士，您开户成功：" + "您的卡号是：" + cardId + ",请您妥善保管卡号");
    }

    /**
     * 为账户生成8位与其他账户卡号不同的号码。
     *
     * @return
     */
    private static String getRandomCardId(ArrayList<Account> accounts) {
        Random r = new Random();
        while (true) {
            //1.先生成8位数字
            String cardId = ""; //卡号容易重复
            for (int i = 0; i < 8; i++) {
                cardId += r.nextInt(10);
            }

            //2.判断这个8位卡号是否与其他账户的卡号重复了。
            //根据这个卡号去查询账户对象
            Account acc = getAccountByCardId(cardId, accounts);
            if (acc == null) {
                //说明cardId 此时没有重复，这个卡号是一个新卡号了，可以使用这个卡号作为新注册账户的卡号了。
                return cardId;

            }
        }

    }

    /**
     * 根据卡号查询出一个账户对象出来
     *
     * @param carId    卡号
     * @param accounts 全部账户的集合
     * @return 账户对象 ！ null
     */
    private static Account getAccountByCardId(String carId, ArrayList<Account> accounts) {
        for (int i = 0; i < accounts.size(); i++) {
            Account acc = accounts.get(i);
            if (acc.getCardId().equals(carId)) {
                return acc;
            }
        }
        return null; //查无此账号
    }
}