• 银行ATM系统

    银行ATM系统

    银行ATM系统技术分析

    1.面向对象编程
    每个用户账户都是一个对象：所以需要设计账户类Account用于创建账户对象封装庄户信息。
    2.集合容器
    系统需要提供一个容器用于存储这些账户对象的信息，我们选ArrayList集合。
    3.程序流程控制
    需要结合分支、循环、跳转关键字等相关操作控制程序的业务逻辑。
    4.常见API。
    登录信息的内容比较，业务数据的分析，处理等都需要用到String等使用API来解决。

    系统准备以及首页设计

    在这里插入图片描述

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

    实现步骤：
    1.定义账户类，用于后期创建账户对象封装用户信息。
    2.账户类中的信息至少需要包含（卡号、姓名、密码、余额、取现额度）。
    3.需要准备一个ArrayList的集合，用于存储系统用户的账户对象。
    4.需要展示欢迎页包含2个功能：开户功能、登录账户。
    基本框架：ATMSystem.java类

    package atmxitong;
import java.util.ArrayList;
import java.util.Scanner;

/**
  ATM系统入口类。
 */
public class ATMSystem {
    public static void main(String[] args) {
        // 定义账户类
        // 定义一个集合容器，负责以后存储全部的账户对象，进行相关的业务操作。
        ArrayList<Account> accounts = new ArrayList <>();
        // 展示系统的首页
        while (true) {
            System.out.println("=================ATM系统===================");
            System.out.println("1.账户登录");
            System.out.println("2.账户开户");
            Scanner sc = new Scanner(System.in);
            System.out.println("请您选择操作（选1/2）：");
            int command = sc.nextInt();
            switch (command){
                case 1:
                    // 用户登陆操作
                    break;
                case 2:
                    // 用户账户开户
                    break;
                default:
                    System.out.println("您输入的操作命令不存在~~");
            }
        }
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    Account类：

    package atmxitong;

public class Account {
    /**
     成员变量、私有
     */
    private String carId;        // 卡号
    private String userName;     // 用户名
    private String passWord;     // 密码
    private double money;        // 账户余额
    private double quotaMoney;   // 每次取现额度


    public String getCarId() {
        return carId;
    }

    public void setCarId(String carId) {
        this.carId = carId;
    }

    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    用户开户功能实现

    在这里插入图片描述

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

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

/**
  ATM系统入口类。
 */
public class ATMSystem {
    public static void main(String[] args) {
        // 定义账户类
        // 定义一个集合容器，负责以后存储全部的账户对象，进行相关的业务操作。
        ArrayList<Account> accounts = new ArrayList <>();
        Scanner sc = new Scanner(System.in);
        // 展示系统的首页
        while (true) {
            System.out.println("=================ATM系统===================");
            System.out.println("1.账户登录");
            System.out.println("2.账户开户");
            System.out.println("请您选择操作（选1/2）：");
            int command = sc.nextInt();
            switch (command){
                case 1:
                    // 用户登陆操作
                    break;
                case 2:
                    // 用户账户开户
                    register(accounts,sc);
                    break;
                default:
                    System.out.println("您输入的操作命令不存在~~");
            }
        }
    }

    /**
     * 用户开户功能
     * @param accounts 接收的账户集合
     */
    private static void register(ArrayList<Account> accounts,Scanner sc) {
        System.out.println("=================系统开户操作===================");
        // 创建一个账户对象，用于后期封装账户信息。
        Account account = new Account();
        // 录入账户信息，注入到账户对象去
        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) && passWord!=null && okpassWord!=null){
                // 密码认证通过，可以注入给账户对象
                account.setPassWord(okpassWord);
                break;
            }else {
                System.out.println("对不起，您输入的两次密码不一致，请重新确认。");
            }
        }
        System.out.println("请您输入账户当次限额：");
        double quotaMoney = sc.nextDouble();
        account.setQuotaMoney(quotaMoney);
        // 为账户随机一个8位且与其他账户的卡号的不能重复的号码。（独立功能，独立成方法）。
        String cardid = getRandomCardid(accounts);
        account.setCarId(cardid);
        // 把账户对象添加到账户集合中去。
        accounts.add(account);
        System.out.println("恭喜您，"+userName+"先生/女士，您开户成功，您的卡号是："+cardid+"，请您妥善保管卡号！");
    }

    /**
     * 账户生成8位，与其他号码不同
     * @return
     */
    private static String getRandomCardid(ArrayList<Account> accounts) {
        Random r = new Random();
        while (true) {
            // 生成8位数字
            String cardid = "";
            for (int i = 0; i < 8; i++) {
                cardid += r.nextInt(10);
            }
            // 判断8位卡号是否与其他账户的卡号重复了。根据这个卡号去查询账户的对象
            Account acc = getAccountByCardid(cardid, accounts);
            if (acc == null){
                // 说明cardid此时没有重复，这个卡号是一个新卡号了，可以使用这个卡号作为新注册账户的卡号了
                return cardid;
            }
        }
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109

    用户登录功能实现

    在这里插入图片描述

    分析：
    1.登录功能应该定义成一个方法，并传入账户集合。
    2.让用户输入卡号，根据卡号去账户集合中查询账户对象。
    3.如果没有找到账户对象，说明登录卡号不存在，提示继续输入卡号。
    4.如果找到了账户对象，说明卡号存在，继续输入密码。
    5.如果密码不正确，提示继续输入密码。
    6.如果密码也正确，登陆成功！

    /**
     * 登录功能
     * @param accounts 全部账户对象的集合
     * @param sc 扫描器
     */
    private static void longin(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("=================用户登录操作===================");
        // 判断账户集合中是否存在账户，如果不存在账户，登录功能不能进行。
        if(accounts.size() == 0){
            System.out.println("对不起，当前系统中，无任何账户，请先开户，再来登录~~");
            return; // 卫语言风格，解决方法的执行。
        }
        // 正式进入登录操作
        while (true) {
            System.out.println("请您输入登录卡号：");
            String carid = sc.next();
            // 判断卡号是否存在，根据卡号去账号集合中查询账户对象。
            Account acc = getAccountByCardid(carid, accounts);
            if(acc != null){
                // 卡号存在的，让用户输入密码
                while (true) {
                    System.out.println("请您输入登录密码：");
                    String passWord = sc.next();
                    // 判断当前账户对象的密码是否与用户输入的密码一致
                    if(acc.getPassWord().equals(passWord)){
                        // 登录成功
                        System.out.println("恭喜您，"+acc.getUserName()+"先生/女士进入系统，您的卡号是："+acc.getCarId());
                        // 查询 转账 取款
                    }else {
                        System.out.println("对不起，您输入的密码有误~~");
                    }
                }
            }else {
                System.out.println("对不起，系统中不存在该账户的卡号~~");
            }
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    用户登录后：操作页、查询账户、退出账户功能实现

    在这里插入图片描述

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

    private static void showUserCommand(Scanner sc,Account acc) {
        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:
                    // 查询账户（展示当前登录的用户信息）
                    showcount(acc);
                    break;
                case 2:
                    // 存款
                    break;
                case 3:
                    // 取款
                    break;
                case 4:
                    // 转账
                    break;
                case 5:
                    // 修改密码
                    break;
                case 6:
                    // 退出
                    System.out.println("退出成功，欢迎下次光临");
                    return; // 当前方法停止执行
                case 7:
                    // 注销账户
                    break;
                default:
                    System.out.println("您输入的操作命令不正确~~~~~");
            }
        }
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    用户登录后：存款功能实现

    在这里插入图片描述
    分析：
    1.存款就是拿到当前账户对象。
    2.然后让用户输入存款的金额。
    3.调用账户对象的setMoney方法账户余额修改成存钱后的余额。
    4.存钱后需要查询一下账户信息，确认是否存钱成功了！

    /**
     * 存钱
     * @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("恭喜您，存钱成功,当前账户信息如下：");
        showcount(acc);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    用户登录后：取款功能实现

    在这里插入图片描述
    分析：
    1.取款需要先判断账户是否有钱。
    2.有钱则拿到自己账户对象。
    3.然后让用户输入取款金额。
    4.判断取款金额是否超过了当次限额，以及金额是否足够。
    5.满足要求则调用账户对象的setMoney方法完成金额的修改。

     /**
     * 取款模块
     * @param acc 当前账户对象
     * @param sc  扫描器
     */
    private static void dranMoney(Account acc, Scanner sc) {
        System.out.println("=================用户取钱操作===================");
        // 判断是否足够100元
        if(acc.getMoney() < 100){
            System.out.println("对不起，当前账户中不够100元，不能取钱~~~");
            return;
        }
        // 提示用户输入取款金额
        System.out.println("请您输入取款金额：");
        double money = sc.nextDouble();
        // 判断这个金额是否满足要求。
        if(money > acc.getQuotaMoney()){
            System.out.println("对不起，您当前取款金额超过每次限额，每次最多可取："+acc.getQuotaMoney());
        }else {
            // 没有超过限额，判断是否超过账户的总金额
            if(money > acc.getMoney()){
                System.out.println("金额不足，您账户目前总余额是："+acc.getMoney());
            }else {
                // 可以取钱了
                System.out.println("恭喜您，取钱"+money+"元，成功！");
                // 更新金额
                acc.setMoney(acc.getMoney() - money);
                // 取钱结束了,展示余额
                showcount(acc);
                return; // 干掉取钱方法
            }
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    用户登录后：转账功能实现

    在这里插入图片描述
    分析：
    1.转账功能需要判断系统中是否有2个账户对象及以上。
    2.同时还要判断自己账户是否有钱。
    3.接下来需要输入对方的卡号，判断对方账户是否存在。
    4.对方账户存在还需要认证对方户主的姓氏。
    5.满足要求则可以把自己账户对象的金额修改到对方账户对象中去。

    /**
     * 转账功能
     * @param sc 扫描器
     * @param acc 当前自己的账户
     * @param accounts 全部账户的集合
     */
    private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) {
        System.out.println("=================用户转账操作===================");
        // 判断是否足够两个账户
        if(accounts.size() < 2){
            System.out.println("当前系统中，不足2个账户，不能进行转账，请去开户吧~~");
            return; // 结束当前方法
        }
        // 判断自己账户是否有钱
        if(acc.getMoney() == 0){
            System.out.println("对不起，您自己都没有钱，就别转了吧~~~");
            return; // 结束当前方法
        }
        while (true) {
            // 真正开始转账
            System.out.println("请您输入对方账户的卡号：");
            String cardid  = sc.next();
            // 这个卡号不能是自己的卡号
            if(cardid.equals(acc.getCarId())){
                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);
                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()){
                            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("对不起，您输入的信息有误~~");
                }
            }
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    密码修改、销户功能实现

    在这里插入图片描述
    分析：
    1.修改密码就是把当前对象的密码属性使用set方法进行更新。
    2.销户是从集合对象中删除当前对象、并回到首页。

     /**
     * 销户功能
     * @param acc 当前用户对象
     * @param accounts 用户集合
     * @param sc 扫描器
     */
    private static boolean deleteAccount(Account acc, ArrayList<Account> accounts, Scanner sc) {
        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("您的账户销户完成~~~");
                    return true;
                }
                break;
            default:
                System.out.println("好的，当前账户继续保留！");
        }
        return false;
    }

    /**
     * 修改密码
     * @param sc 扫描器
     * @param acc 当前登录账户对象
     */
    private static void updatePassWord(Scanner sc, Account acc) {
        System.out.println("=================用户修改密码操作===================");
        while (true) {
            System.out.println("请您输入当前密码：");
            String password = sc.next();
            // 判断这个密码是否正确
            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)){
                        acc.setPassWord(newPassWord);
                        System.out.println("恭喜您，更改密码成功！");
                        return;
                    }else {
                        System.out.println("您输入的密码不一致！");
                    }
                }
            }else {
                System.out.println("您输入的密码不正确~~");
            }
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    本系统的完整代码：ATMSystem.java类

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

/**
  ATM系统入口类。
 */
public class ATMSystem {
    public static void main(String[] args) {
        // 定义账户类
        // 定义一个集合容器，负责以后存储全部的账户对象，进行相关的业务操作。
        ArrayList<Account> accounts = new ArrayList <>();
        Scanner sc = new Scanner(System.in);
        // 展示系统的首页
        while (true) {
            System.out.println("=================ATM系统===================");
            System.out.println("1.账户登录");
            System.out.println("2.账户开户");
            System.out.println("请您选择操作（选1/2）：");
            int command = sc.nextInt();
            switch (command){
                case 1:
                    // 用户登陆操作
                    longin(accounts,sc);
                    break;
                case 2:
                    // 用户账户开户
                    register(accounts,sc);
                    break;
                default:
                    System.out.println("您输入的操作命令不存在~~");
            }
        }
    }

    /**
     * 登录功能
     * @param accounts 全部账户对象的集合
     * @param sc 扫描器
     */
    private static void longin(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("=================系统登录操作===================");
        // 判断账户集合中是否存在账户，如果不存在账户，登录功能不能进行。
        if(accounts.size() == 0){
            System.out.println("对不起，当前系统中，无任何账户，请先开户，再来登录~~");
            return; // 卫语言风格，解决方法的执行。
        }
        // 正式进入登录操作
        while (true) {
            System.out.println("请您输入登录卡号：");
            String carid = sc.next();
            // 判断卡号是否存在，根据卡号去账号集合中查询账户对象。
            Account acc = getAccountByCardid(carid, accounts);
            if(acc != null){
                // 卡号存在的，让用户输入密码
                while (true) {
                    System.out.println("请您输入登录密码：");
                    String passWord = sc.next();
                    // 判断当前账户对象的密码是否与用户输入的密码一致
                    if(acc.getPassWord().equals(passWord)){
                        // 登录成功
                        System.out.println("恭喜您，"+acc.getUserName()+"先生/女士进入系统，您的卡号是："+acc.getCarId());
                        // 查询 转账 取款.... 展示登录后的操作页。
                        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:
                    // 查询账户（展示当前登录的用户信息）
                    showcount(acc);
                    break;
                case 2:
                    // 存款
                    depositMoney(acc,sc);
                    break;
                case 3:
                    // 取款
                    dranMoney(acc,sc);
                    break;
                case 4:
                    // 转账
                    transferMoney(sc,acc,accounts);
                    break;
                case 5:
                    // 修改密码
                    updatePassWord(sc,acc);
                    break;
                case 6:
                    // 退出
                    System.out.println("退出成功，欢迎下次光临");
                    return; // 当前方法停止执行
                case 7:
                    if(deleteAccount(acc,accounts,sc)){
                        return; // 退出本方法
                    }else {
                        break;
                    }
                default:
                    System.out.println("您输入的操作命令不正确~~~~~");
            }
        }
    }

    /**
     * 销户功能
     * @param acc 当前用户对象
     * @param accounts 用户集合
     * @param sc 扫描器
     */
    private static boolean deleteAccount(Account acc, ArrayList<Account> accounts, Scanner sc) {
        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("您的账户销户完成~~~");
                    return true;
                }
                break;
            default:
                System.out.println("好的，当前账户继续保留！");
        }
        return false;
    }

    /**
     * 修改密码
     * @param sc 扫描器
     * @param acc 当前登录账户对象
     */
    private static void updatePassWord(Scanner sc, Account acc) {
        System.out.println("=================用户修改密码操作===================");
        while (true) {
            System.out.println("请您输入当前密码：");
            String password = sc.next();
            // 判断这个密码是否正确
            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)){
                        acc.setPassWord(newPassWord);
                        System.out.println("恭喜您，更改密码成功！");
                        return;
                    }else {
                        System.out.println("您输入的密码不一致！");
                    }
                }
            }else {
                System.out.println("您输入的密码不正确~~");
            }
        }
    }

    /**
     * 转账功能
     * @param sc 扫描器
     * @param acc 当前自己的账户
     * @param accounts 全部账户的集合
     */
    private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) {
        System.out.println("=================用户转账操作===================");
        // 判断是否足够两个账户
        if(accounts.size() < 2){
            System.out.println("当前系统中，不足2个账户，不能进行转账，请去开户吧~~");
            return; // 结束当前方法
        }
        // 判断自己账户是否有钱
        if(acc.getMoney() == 0){
            System.out.println("对不起，您自己都没有钱，就别转了吧~~~");
            return; // 结束当前方法
        }
        while (true) {
            // 真正开始转账
            System.out.println("请您输入对方账户的卡号：");
            String cardid  = sc.next();
            // 这个卡号不能是自己的卡号
            if(cardid.equals(acc.getCarId())){
                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);
                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()){
                            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 dranMoney(Account acc, Scanner sc) {
        System.out.println("=================用户取钱操作===================");
        // 判断是否足够100元
        if(acc.getMoney() < 100){
            System.out.println("对不起，当前账户中不够100元，不能取钱~~~");
            return;
        }
        // 提示用户输入取款金额
        System.out.println("请您输入取款金额：");
        double money = sc.nextDouble();
        // 判断这个金额是否满足要求。
        if(money > acc.getQuotaMoney()){
            System.out.println("对不起，您当前取款金额超过每次限额，每次最多可取："+acc.getQuotaMoney());
        }else {
            // 没有超过限额，判断是否超过账户的总金额
            if(money > acc.getMoney()){
                System.out.println("金额不足，您账户目前总余额是："+acc.getMoney());
            }else {
                // 可以取钱了
                System.out.println("恭喜您，取钱"+money+"元，成功！");
                // 更新金额
                acc.setMoney(acc.getMoney() - money);
                // 取钱结束了,展示余额
                showcount(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("恭喜您，存钱成功,当前账户信息如下：");
        showcount(acc);
    }

    /**
     * 展示当前账户信息
     * @param acc 当前账户对象
     */
    private static void showcount(Account acc) {
        System.out.println("=================当前账户信息如下：===================");
        System.out.println("卡号："+acc.getCarId());
        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("=================系统开户操作===================");
        // 创建一个账户对象，用于后期封装账户信息。
        Account account = new Account();
        // 录入账户信息，注入到账户对象去
        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) && passWord!=null && okpassWord!=null){
                // 密码认证通过，可以注入给账户对象
                account.setPassWord(okpassWord);
                break;
            }else {
                System.out.println("对不起，您输入的两次密码不一致，请重新确认。");
            }
        }
        System.out.println("请您输入账户当次限额：");
        double quotaMoney = sc.nextDouble();
        account.setQuotaMoney(quotaMoney);
        // 为账户随机一个8位且与其他账户的卡号的不能重复的号码。（独立功能，独立成方法）。
        String cardid = getRandomCardid(accounts);
        account.setCarId(cardid);
        // 把账户对象添加到账户集合中去。
        accounts.add(account);
        System.out.println("恭喜您，"+userName+"先生/女士，您开户成功，您的卡号是："+cardid+"，请您妥善保管卡号！");
    }

    /**
     * 账户生成8位，与其他号码不同
     * @return
     */
    private static String getRandomCardid(ArrayList<Account> accounts) {
        Random r = new Random();
        while (true) {
            // 生成8位数字
            String cardid = "";
            for (int i = 0; i < 8; i++) {
                cardid += r.nextInt(10);
            }
            // 判断8位卡号是否与其他账户的卡号重复了。根据这个卡号去查询账户的对象
            Account acc = getAccountByCardid(cardid, accounts);
            if (acc == null){
                // 说明cardid此时没有重复，这个卡号是一个新卡号了，可以使用这个卡号作为新注册账户的卡号了
                return cardid;
            }
        }
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385

    Account.java类

    package atmxitong;

public class Account {
    /**
     成员变量、私有
     */
    private String carId;        // 卡号
    private String userName;     // 用户名
    private String passWord;     // 密码
    private double money;        // 账户余额
    private double quotaMoney;   // 每次取现额度


    public String getCarId() {
        return carId;
    }

    public void setCarId(String carId) {
        this.carId = carId;
    }

    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;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
  • 相关阅读:
    总结 HTTP 协议的基本格式和 fiddler 的用法
    【日拱一卒行而不辍20220921】自制操作系统
    css 雷达扫描图
    Python处理复杂的CSV文件
    从资源隔离、资源配额、存储、网络四个方面认识Docker
    单连通图的判断
    统计无向图中无法互相到达点对数[经典建邻接表+DFS统计 -＞ 并查集优化][并查集手册/写的详细]
    PMP明天就考试了！
    移动安全规范 — 3 -个人密码（PIN）传输规范
    Redis中的Lua脚本(一)
  • 原文地址：https://blog.csdn.net/asnowdream/article/details/127551131