手机客户端
首页　>　文章列表　>　Java如何实现ATM系统

Java如何实现ATM系统

java atm
141 2023-05-02

Java如何实现ATM系统

1.系统准备，首页，用户开户功能

系统准备，首页设计

系统准备内容分析：

  • 每个用户的账户信息都是一个对象，需要提供账户类

  • 需要准备一个容器，用于存储和系统全部账户对象信息

  • 首页只需要包含：登入和注册2个功能

实现步骤：

  • 定义账户类，用于后期创建账户对象封装用户的账户信息

  • 账户类中的信息至少需要包含（卡号，姓名，密码，余额，取现额度）

package com.wangxinhua;



import java.util.ArrayList;

import java.util.Scanner;



public class ATMSystem

{

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts);

    }

    public static void showMain(ArrayList<Account> accounts)

    {

        System.out.println("========欢迎进入首页=====");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            System.out.println("1.登录");

            System.out.println("2.开户");

            System.out.println("您可以输入命令了：");

            int command = sc.nextInt();

            switch(command)

            {

                case 1:

                    //登入

                    break;

                case 2:

                    //开户

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }

}

总结

  • 用户的账户信息，系统如何表示的？

定义账户类Account，定义系统关心的属性信息

  • 系统采用什么来储存全部用户的账户对象信息？

ArrayList<Account> accounts = new ArrayList<> ();

用户开户功能实现

  • 分析

开户功能其实就是往系统的集合容器中存入一个新的账户对象的信息

  • 开户功能实现步骤

定义方法完成开户：

public static void register(ArrayList<Account>  accounts){...}

  • 键盘录入姓名，秘密，确认密码（需保证两次密码一致）

  • 生成账户卡号，卡号必须由系统自动生成8位数字（必须保证卡号的唯一）

  • 创建Account账户类对象用户封装账户信息（姓名，密码，卡号）

  • 把Account账户类对象存入到集合accounts中去。

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem

{

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            System.out.println("1.登录");

            System.out.println("2.开户");

            System.out.println("您可以输入命令了：");

            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("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;//查无此账户，说明卡号没有重复了！

    }

}

总结

开户功能的实现需要哪几步操作，需要注意什么问题？

  • 开户功能应该独立定义成方法，并传入当前集合对象给该方法。

  • 录入开户信息（姓名，密码）

  • 卡号要自动生成且唯一

  • 把开户的信息封装成Account对象，存入到集合中去。

2.????用户登入，操作页展示，查询账户，退出账户

用户登入功能实现

分析

  • 定义方法：

public static void login(ArrayList<Account>accounts){...}

  • 让用户键盘录入卡号，根据卡号查询账户对象。

  • 如果没有找到了账户对象，说明卡号不存在，继续输入卡号

  • 如果找到了账户对象，说明卡号存在，继续输入密码

  • 如果密码不正确，提示继续输入密码

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem

{

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true) {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + acc.getCardId());

//

                    }

                    else

                    {

                        System.out.println("您的密码有误，请确认！");



                    }

                }

            }

            else

            {

                System.out.println("对不起，不存在该卡号的账户！");

            }

        }

    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;//查无此账户，说明卡号没有重复了！

    }

}

总结

登录功能如何实现的？

  • 根据卡号去集合中查询对应的账户对象

  • 如果找到了账户对象，说明卡号存在，继续输入密码

  • 如果密码正确，则登录成功

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

用户操作页，查询账户，退出账户功能分析

  • 用户登录成功后，需要进入用户操作页、

  • 查询就是直接展示当前登录成功的账户对象的信息

  • 退出账户是需要回到首页的

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem {

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

            //showMain 开户首页的意思

//            ArrayList<Account> accounts   使用方法定义功能传入容器中  accounts是传参

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true) {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + acc.getCardId());

                        //展示操作页面

                        showUserCommand(sc,acc);

                        return;//继续结束登录方法

                    }

                    else

                    {

                        System.out.println("您的密码有误，请确认！");



                    }

                }

            }

            else

            {

                System.out.println("对不起，不存在该卡号的账户！");

            }

        }

    }



    private static void showUserCommand(Scanner sc,Account acc) {

        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.注销账户");

        while (true)

        {

            System.out.println("请您输入操作命令：");

            int command = sc.nextInt();

            switch (command)

            {

                case 1:

                    //查询账户

                    showAccount(acc);

                    break;

                case 2:

                    //存款

                    break;

                case 3:

                    //取款

                    break;

                case 4:

                    //转账

                    break;

                case 5:

                    //修改密码

                    break;

                case 6:

                    //退出

                    System.out.println("欢迎下次光临！！");

                    return; //结束当前showUserCommand(Scanner sc,Account acc)的方法

                case 7:

                    //注销账户

                    break;

                default:

                    System.out.println("您输入有误！");

            }

        }

    }



    private static void showAccount(Account acc)

    {

        System.out.println("===========当前账户详情=========");

        System.out.println("卡号" + acc.getCardId());

        System.out.println("姓名" + acc.getUserWord());

        System.out.println("余额" + acc.getMoney());

        System.out.println("当次限额：" + acc.getQuotaMoney());



    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;//查无此账户，说明卡号没有重复了！

    }

}

总结

用户操作页设计，查询账户，退出账户功能注意事项

  • 我们应该注意接入登录界面后应该注意用户操作页面有哪些

  • 设置好操作界面后需要接入退出接口

3.????用户存款与取款

用户存款

存款分析

  • 存款就是拿到当前账户对象

  • 然后让用户输入存款金额

  • 调用账户对象的setMoney方法将战虎余额修改成存钱后的余额

  • 存钱后需要查新一下账户信息，确认是否存钱成功了！

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem {

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

            //showMain 开户首页的意思

//            ArrayList<Account> accounts   使用方法定义功能传入容器中  accounts是传参

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true) {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + acc.getCardId());

                        //展示操作页面

                        showUserCommand(sc,acc);

                        return;//继续结束登录方法

                    }

                    else

                    {

                        System.out.println("您的密码有误，请确认！");



                    }

                }

            }

            else

            {

                System.out.println("对不起，不存在该卡号的账户！");

            }

        }

    }



    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:

                    //查询账户

                    showAccount(acc);

                    break;

                case 2:

                    //存款

                    depositMoney(acc,sc);

                    break;

                case 3:

                    //取款

                    break;

                case 4:

                    //转账

                    break;

                case 5:

                    //修改密码

                    break;

                case 6:

                    //退出

                    System.out.println("欢迎下次光临！！");

                    return; //结束当前showUserCommand(Scanner sc,Account acc)的方法

                case 7:

                    //注销账户

                    break;

                default:

                    System.out.println("您输入有误！");

            }

        }

    }



    /**

     * 专门存钱的

     * @param acc

     */

    private static void depositMoney(Account acc,Scanner sc) {

        System.out.println("===========存钱操作=========");

        System.out.println("请您输入存款的金额：");

        double money = sc.nextDouble();



        //直接把金额修改到账户对象的money属性中去

        acc.setMoney(acc.getMoney() + money);

        System.out.println("存款完成！");

        showAccount(acc);



    }



    private static void showAccount(Account acc)

    {

        System.out.println("===========当前账户详情=========");

        System.out.println("卡号" + acc.getCardId());

        System.out.println("姓名" + acc.getUserWord());

        System.out.println("余额" + acc.getMoney());

        System.out.println("当次限额：" + acc.getQuotaMoney());



    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;

        //查无此账户，说明卡号没有重复了！

    }

}

总结

存款分析

  • 存款就是拿到当前账户对象

  • 然后让用户输入存款的金额

  • 调用账户对象的setMoney方法将账户余额修改成存钱后的余额

  • 存钱后需要查询一下账户信息，确认是否存钱成功了！

取款分析

  • 取款需要先判断账户是否有钱

  • 有钱则拿到自己账户对象

  • 然后让用户输入取款金额

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

  • 满足要求则调用账户对象的setMoney方法完成金额的修改

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem {

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

            //showMain 开户首页的意思

//            ArrayList<Account> accounts   使用方法定义功能传入容器中  accounts是传参

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true) {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + acc.getCardId());

                        //展示操作页面

                        showUserCommand(sc,acc);

                        return;//继续结束登录方法

                    }

                    else

                    {

                        System.out.println("您的密码有误，请确认！");



                    }

                }

            }

            else

            {

                System.out.println("对不起，不存在该卡号的账户！");

            }

        }

    }



    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:

                    //查询账户

                    showAccount(acc);

                    break;

                case 2:

                    //存款

                    depositMoney(acc,sc);

                    break;

                case 3:

                    //取款

                    drawMoney(acc,sc);

                    break;

                case 4:

                    //转账

                    break;

                case 5:

                    //修改密码

                    break;

                case 6:

                    //退出

                    System.out.println("欢迎下次光临！！");

                    return; //结束当前showUserCommand(Scanner sc,Account acc)的方法

                case 7:

                    //注销账户

                    break;

                default:

                    System.out.println("您输入有误！");

            }

        }

    }



    /**

     * 取款操作

     * @param acc

     * @param sc

     */

    private static void drawMoney(Account acc, Scanner sc) {

        System.out.println("==========取款操作=========");

        //1.判断它的账户是否足够100元

        if (acc.getMoney() >= 100)

        {

            while (true) {

                System.out.println("请您输入取款的金额：");

                double money = sc.nextDouble();

                //2.判断整个金额有没有超过当次限额

                if (money > acc.getQuotaMoney())

                {

                    System.out.println("您当次取款金额超过每次限额，不要取那么多，每次最多可以取：" + acc.getQuotaMoney());

                }

                else

                {

                    //3.判断当前余额是否足够你取钱

                    if (acc.getMoney() >= money)

                    {

                        //够了，可以取钱了

                        acc.setMoney(acc.getMoney() - money);

                        System.out.println("恭喜您，取钱" + money + "成功了！当前账户还剩余：" + acc.getMoney());

                        return;//取钱后干掉了取钱方法

                    }

                    else

                    {

                        System.out.println("余额不足啊！！");

                    }

                }

            }

        }

        else

        {

            System.out.println("您自己的金额没有超过100元，该努力工作了~~~");

        }



    }



    /**

     * 专门存钱的

     * @param acc

     */

    private static void depositMoney(Account acc,Scanner sc) {

        System.out.println("===========存钱操作=========");

        System.out.println("请您输入存款的金额：");

        double money = sc.nextDouble();



        //直接把金额修改到账户对象的money属性中去

        acc.setMoney(acc.getMoney() + money);

        System.out.println("存款完成！");

        showAccount(acc);



    }



    private static void showAccount(Account acc)

    {

        System.out.println("===========当前账户详情=========");

        System.out.println("卡号" + acc.getCardId());

        System.out.println("姓名" + acc.getUserWord());

        System.out.println("余额" + acc.getMoney());

        System.out.println("当次限额：" + acc.getQuotaMoney());



    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;

        //查无此账户，说明卡号没有重复了！

    }

}

总结温习

  • 取款需要先判断账户是否有钱

  • 有钱则拿到自己账户对象

  • 然后让用户输入取款金额

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

  • 满足要求则调用账户对象的setMoney方法完成金额的修改

4.????用户转账，修改密码，销户

用户转账功能

分析

  • 转账功能需要判断系统中是否有2个账户对象及以上

  • 同时还要判断总结账户是否有钱

  • 接下来需要输入对方卡号，判断对方账户是否存在

  • 对方账户存在还需要认证对方户主的姓氏

  • 满足要求则可以把自己账户对象的金额修改到对方账户对象中去

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem {

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

            //showMain 开户首页的意思

//            ArrayList<Account> accounts   使用方法定义功能传入容器中  accounts是传参

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true) {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + 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(accounts,acc ,sc);

                    break;

                case 5:

                    //修改密码

                    break;

                case 6:

                    //退出

                    System.out.println("欢迎下次光临！！");

                    return; //结束当前showUserCommand(Scanner sc,Account acc)的方法

                case 7:

                    //注销账户

                    break;

                default:

                    System.out.println("您输入有误！");

            }

        }

    }



    /**

     * 转账功能

     * @param accounts

     * @param acc

     * @param sc

     */

    private static void transferMoney(ArrayList<Account> accounts, Account acc, Scanner sc)

    {

        //1.判断系统中是否有2个账户及以上

        if (accounts.size() < 2)

        {

            System.out.println("对不起，系统中无其他账户，您不可以转账！！");

            return;

        }



        //2.判断自己的账户对象中是否有钱

        if (acc.getMoney() == 0)

        {

            System.out.println("对不起，您自己都快吃土了，就别装逼了！！");

            return;

        }



        //3.开始转账逻辑

        while (true)

        {

            System.out.println("请您输入对方账户的卡号：");

            String cardId = sc.next();

            Account account = getAccountBycardId(cardId,accounts);

            //判断整个账户对象是否存在，存在说明对方卡号输入正确

            if (account != null)

            {

                //判断这个账户对象是否是当前自己登录的账户

                if (account.getCardId().equals(acc.getCardId()))

                {

                    //也就是这里企图想给自己转账

                    System.out.println("您不能给自己转账！");

                }

                else

                {

                    //确认对方的姓氏

                    String name = "*" + account.getUserWord().substring(1);

                    System.out.println("请您确认【" + name + "】的姓氏：");

                    String preName = sc.next();

                    //判断

                    if (account.getUserWord().startsWith(preName))

                    {

                        //真正的转账才刚刚开始

                        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("恭喜您，转账成功了，已经为" + account.getUserWord() + "转账了：" + money);

                            showAccount(acc);

                            return;



                        }

                    }

                    else

                    {

                        System.out.println("对不起，您认证的信息有误~~~");

                    }

                }



            }

            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)

        {

            while (true) {

                System.out.println("请您输入取款的金额：");

                double money = sc.nextDouble();

                //2.判断整个金额有没有超过当次限额

                if (money > acc.getQuotaMoney())

                {

                    System.out.println("您当次取款金额超过每次限额，不要取那么多，每次最多可以取：" + acc.getQuotaMoney());

                }

                else

                {

                    //3.判断当前余额是否足够你取钱

                    if (acc.getMoney() >= money)

                    {

                        //够了，可以取钱了

                        acc.setMoney(acc.getMoney() - money);

                        System.out.println("恭喜您，取钱" + money + "成功了！当前账户还剩余：" + acc.getMoney());

                        return;//取钱后干掉了取钱方法

                    }

                    else

                    {

                        System.out.println("余额不足啊！！");

                    }

                }

            }

        }

        else

        {

            System.out.println("您自己的金额没有超过100元，该努力工作了~~~");

        }



    }



    /**

     * 专门存钱的

     * @param acc

     */

    private static void depositMoney(Account acc,Scanner sc) {

        System.out.println("===========存钱操作=========");

        System.out.println("请您输入存款的金额：");

        double money = sc.nextDouble();



        //直接把金额修改到账户对象的money属性中去

        acc.setMoney(acc.getMoney() + money);

        System.out.println("存款完成！");

        showAccount(acc);



    }



    private static void showAccount(Account acc)

    {

        System.out.println("===========当前账户详情=========");

        System.out.println("卡号" + acc.getCardId());

        System.out.println("姓名" + acc.getUserWord());

        System.out.println("余额" + acc.getMoney());

        System.out.println("当次限额：" + acc.getQuotaMoney());



    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;

        //查无此账户，说明卡号没有重复了！

    }

}

总结温习

  • 转账功能需要判断系统中是否有2个账户对象及以上

  • 同时还要判断总结账户是否有钱

  • 接下来需要输入对方卡号，判断对方账户是否存在

  • 对方账户存在还需要认证对方户主的姓氏

  • 满足要求则可以把自己账户对象的金额修改到对方账户对象中去

  • 修改密码与销户

分析

  • 修改密码就是把当前对现象的密码属性使用set方法进行更新

  • 销户是从集合对象中删除当前对象，并回到首页

这里为止所有的ATM系统的操作代码就已经完成

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem {

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

            //showMain 开户首页的意思

//            ArrayList<Account> accounts   使用方法定义功能传入容器中  accounts是传参

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true) 

        {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + 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(accounts,acc ,sc);

                    break;

                case 5:

                    //修改密码

                    updataPassWord(acc,sc);

                    return;//结束当前…………

                case 6:

                    //退出

                    System.out.println("欢迎下次光临！！");

                    return; //结束当前showUserCommand(Scanner sc,Account acc)的方法

                case 7:

                    //注销账户

                    //从当前集合中抹掉当前账户对象即可

                    accounts.remove(acc);

                    System.out.println("销户成功了！！");

                    return;

                default:

                    System.out.println("您输入有误！");

            }

        }

    }



    /**

     * 修改密码

     * @param acc

     */

    private static void updataPassWord(Account acc,Scanner sc)

    {

        System.out.println("===========修改密码=========");

        while (true)

        {

            System.out.println("请您输入正确的密码：");

            String okPassWord = sc.next();

            //判断密码是否正确

            if (acc.getPassWord().equals(okPassWord))

            {

                //可以输入新密码

                System.out.println("请您输入新的密码：");

                String newPassWord = sc.next();



                System.out.println("请您输入确认密码：");

                String okNewPassWord = sc.next();



                if (newPassWord.equals(okNewPassWord))

                {

                    //修改账户对象的密码为新密码

                    acc.setPassWord(newPassWord);

                    return;//直接结束方法！

                }

                else

                {

                    System.out.println("您两次输入的密码不一致~~");

                }

            }

            else

            {

                System.out.println("当前输入的密码不正确~~~");

            }

        }



    }



    /**

     * 转账功能

     * @param accounts

     * @param acc

     * @param sc

     */

    private static void transferMoney(ArrayList<Account> accounts, Account acc, Scanner sc)

    {

        //1.判断系统中是否有2个账户及以上

        if (accounts.size() < 2)

        {

            System.out.println("对不起，系统中无其他账户，您不可以转账！！");

            return;

        }



        //2.判断自己的账户对象中是否有钱

        if (acc.getMoney() == 0)

        {

            System.out.println("对不起，您自己都快吃土了，就别装逼了！！");

            return;

        }



        //3.开始转账逻辑

        while (true)

        {

            System.out.println("请您输入对方账户的卡号：");

            String cardId = sc.next();

            Account account = getAccountBycardId(cardId,accounts);

            //判断整个账户对象是否存在，存在说明对方卡号输入正确

            if (account != null)

            {

                //判断这个账户对象是否是当前自己登录的账户

                if (account.getCardId().equals(acc.getCardId()))

                {

                    //也就是这里企图想给自己转账

                    System.out.println("您不能给自己转账！");

                }

                else

                {

                    //确认对方的姓氏

                    String name = "*" + account.getUserWord().substring(1);

                    System.out.println("请您确认【" + name + "】的姓氏：");

                    String preName = sc.next();

                    //判断

                    if (account.getUserWord().startsWith(preName))

                    {

                        //真正的转账才刚刚开始

                        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("恭喜您，转账成功了，已经为" + account.getUserWord() + "转账了：" + money);

                            showAccount(acc);

                            return;



                        }

                    }

                    else

                    {

                        System.out.println("对不起，您认证的信息有误~~~");

                    }

                }



            }

            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)

        {

            while (true) {

                System.out.println("请您输入取款的金额：");

                double money = sc.nextDouble();

                //2.判断整个金额有没有超过当次限额

                if (money > acc.getQuotaMoney())

                {

                    System.out.println("您当次取款金额超过每次限额，不要取那么多，每次最多可以取：" + acc.getQuotaMoney());

                }

                else

                {

                    //3.判断当前余额是否足够你取钱

                    if (acc.getMoney() >= money)

                    {

                        //够了，可以取钱了

                        acc.setMoney(acc.getMoney() - money);

                        System.out.println("恭喜您，取钱" + money + "成功了！当前账户还剩余：" + acc.getMoney());

                        return;//取钱后干掉了取钱方法

                    }

                    else

                    {

                        System.out.println("余额不足啊！！");

                    }

                }

            }

        }

        else

        {

            System.out.println("您自己的金额没有超过100元，该努力工作了~~~");

        }



    }



    /**

     * 专门存钱的

     * @param acc

     */

    private static void depositMoney(Account acc,Scanner sc) 

    {

        System.out.println("===========存钱操作=========");

        System.out.println("请您输入存款的金额：");

        double money = sc.nextDouble();



        //直接把金额修改到账户对象的money属性中去

        acc.setMoney(acc.getMoney() + money);

        System.out.println("存款完成！");

        showAccount(acc);



    }



    private static void showAccount(Account acc)

    {

        System.out.println("===========当前账户详情=========");

        System.out.println("卡号" + acc.getCardId());

        System.out.println("姓名" + acc.getUserWord());

        System.out.println("余额" + acc.getMoney());

        System.out.println("当次限额：" + acc.getQuotaMoney());



    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;

        //查无此账户，说明卡号没有重复了！

    }

}

5. ????源代码在这里这里拿

package com.wangxinhua;





/**

    账户类

 */

public class Account {

    private String CardId;//卡号

    private String UserWord;//客户名称

    private String PassWord;//密码

    private double Money;//余额

    private double QuotaMoney;//当次取现限额



//无参函数

    public Account() {

    }



//    构造好了有参函数，那么就会有无参函数

//    有参函数

    public Account(String cardId, String userWord, String passWord, double quotaMoney) {

        CardId = cardId;

        UserWord = userWord;

        PassWord = passWord;

        QuotaMoney = quotaMoney;

    }



    public String getCardId() {

        return CardId;

    }



    public void setCardId(String cardId) {

        CardId = cardId;

    }



    public String getUserWord() {

        return UserWord;

    }



    public void setUserWord(String userWord) {

        UserWord = userWord;

    }



    public String getPassWord() {

        return PassWord;

    }



    public void setPassWord(String passWord) {

        PassWord = passWord;

    }



    public double getMoney() {

        return Money;

    }



    public void setMoney(double money) {

        Money = money;

    }



    public double getQuotaMoney() {

        return QuotaMoney;

    }



    public void setQuotaMoney(double quotaMoney) {

        QuotaMoney = quotaMoney;

    }

}

这里是第一个类用于构造函数 下面这个是第二个类

package com.wangxinhua;



import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Random;

import java.util.Scanner;



public class ATMSystem {

    public static void main(String[] args)

    {

//        1.准备系统需要的容器对象，用户存储账户对象

        ArrayList<Account> accounts = new ArrayList();



//        2.准备系统的首页，登入，开户

        showMain(accounts); 

    }

    public static void showMain(ArrayList<Account> accounts)

            //showMain 开户首页的意思

//            ArrayList<Account> accounts   使用方法定义功能传入容器中  accounts是传参

    {

        System.out.println("=============欢迎进入首页===========");

        Scanner sc = new Scanner(System.in);

        while(true)

        {

            System.out.println("请您输入您想做的操作：");

            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:

                    //开户

                    register(accounts,sc);

                    break;

                default:

                    System.out.println("您当前输入的操作命令不被支持！");

            }

        }

    }





    /**

     * 完成用户登录

     * @param accounts

     */

    private static void login(ArrayList<Account> accounts,Scanner sc)

    {

        //必须系统中存在账户才可以登录

        if (accounts.size() == 0)

        {

            //没有任何账户

            System.out.println("当前系统中无任何账户，您需要先注册！");

            return;//直接结束方法的执行！

        }

        //2.让用户键盘录入卡号，根据卡号查询账户对象

        while (true)

        {

            System.out.println("请您输入登录的卡号：");

            String cardId = sc.next();

            //根据卡号查询账户对象

            Account acc = getAccountBycardId(cardId,accounts);

//        3.判断账户对象是否存在，存在说明卡号没问题

            if (acc != null)

            {

                while (true)

                {

//                    4.让用户继续输入密码

                    System.out.println("请您输入登录的密码：");

                    String password = sc.next();

//              5.判断密码是否正确

                    if (acc.getPassWord().equals(password))

                    {

                        //密码正确，登入成功

                        //展示系统登录后的操作界面

                        System.out.println("恭喜您，" + acc.getUserWord() +",成功登入系统,您的卡号是：" + 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(accounts,acc ,sc);

                    break;

                case 5:

                    //修改密码

                    updataPassWord(acc,sc);

                    return;//结束当前…………

                case 6:

                    //退出

                    System.out.println("欢迎下次光临！！");

                    return; //结束当前showUserCommand(Scanner sc,Account acc)的方法

                case 7:

                    //注销账户

                    //从当前集合中抹掉当前账户对象即可

                    accounts.remove(acc);

                    System.out.println("销户成功了！！");

                    return;

                default:

                    System.out.println("您输入有误！");

            }

        }

    }



    /**

     * 修改密码

     * @param acc

     */

    private static void updataPassWord(Account acc,Scanner sc)

    {

        System.out.println("===========修改密码=========");

        while (true)

        {

            System.out.println("请您输入正确的密码：");

            String okPassWord = sc.next();

            //判断密码是否正确

            if (acc.getPassWord().equals(okPassWord))

            {

                //可以输入新密码

                System.out.println("请您输入新的密码：");

                String newPassWord = sc.next();



                System.out.println("请您输入确认密码：");

                String okNewPassWord = sc.next();



                if (newPassWord.equals(okNewPassWord))

                {

                    //修改账户对象的密码为新密码

                    acc.setPassWord(newPassWord);

                    return;//直接结束方法！

                }

                else

                {

                    System.out.println("您两次输入的密码不一致~~");

                }

            }

            else

            {

                System.out.println("当前输入的密码不正确~~~");

            }

        }



    }



    /**

     * 转账功能

     * @param accounts

     * @param acc

     * @param sc

     */

    private static void transferMoney(ArrayList<Account> accounts, Account acc, Scanner sc)

    {

        //1.判断系统中是否有2个账户及以上

        if (accounts.size() < 2)

        {

            System.out.println("对不起，系统中无其他账户，您不可以转账！！");

            return;

        }



        //2.判断自己的账户对象中是否有钱

        if (acc.getMoney() == 0)

        {

            System.out.println("对不起，您自己都快吃土了，就别装逼了！！");

            return;

        }



        //3.开始转账逻辑

        while (true)

        {

            System.out.println("请您输入对方账户的卡号：");

            String cardId = sc.next();

            Account account = getAccountBycardId(cardId,accounts);

            //判断整个账户对象是否存在，存在说明对方卡号输入正确

            if (account != null)

            {

                //判断这个账户对象是否是当前自己登录的账户

                if (account.getCardId().equals(acc.getCardId()))

                {

                    //也就是这里企图想给自己转账

                    System.out.println("您不能给自己转账！");

                }

                else

                {

                    //确认对方的姓氏

                    String name = "*" + account.getUserWord().substring(1);

                    System.out.println("请您确认【" + name + "】的姓氏：");

                    String preName = sc.next();

                    //判断

                    if (account.getUserWord().startsWith(preName))

                    {

                        //真正的转账才刚刚开始

                        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("恭喜您，转账成功了，已经为" + account.getUserWord() + "转账了：" + money);

                            showAccount(acc);

                            return;



                        }

                    }

                    else

                    {

                        System.out.println("对不起，您认证的信息有误~~~");

                    }

                }



            }

            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)

        {

            while (true) {

                System.out.println("请您输入取款的金额：");

                double money = sc.nextDouble();

                //2.判断整个金额有没有超过当次限额

                if (money > acc.getQuotaMoney())

                {

                    System.out.println("您当次取款金额超过每次限额，不要取那么多，每次最多可以取：" + acc.getQuotaMoney());

                }

                else

                {

                    //3.判断当前余额是否足够你取钱

                    if (acc.getMoney() >= money)

                    {

                        //够了，可以取钱了

                        acc.setMoney(acc.getMoney() - money);

                        System.out.println("恭喜您，取钱" + money + "成功了！当前账户还剩余：" + acc.getMoney());

                        return;//取钱后干掉了取钱方法

                    }

                    else

                    {

                        System.out.println("余额不足啊！！");

                    }

                }

            }

        }

        else

        {

            System.out.println("您自己的金额没有超过100元，该努力工作了~~~");

        }



    }



    /**

     * 专门存钱的

     * @param acc

     */

    private static void depositMoney(Account acc,Scanner sc)

    {

        System.out.println("===========存钱操作=========");

        System.out.println("请您输入存款的金额：");

        double money = sc.nextDouble();



        //直接把金额修改到账户对象的money属性中去

        acc.setMoney(acc.getMoney() + money);

        System.out.println("存款完成！");

        showAccount(acc);



    }



    private static void showAccount(Account acc)

    {

        System.out.println("===========当前账户详情=========");

        System.out.println("卡号" + acc.getCardId());

        System.out.println("姓名" + acc.getUserWord());

        System.out.println("余额" + acc.getMoney());

        System.out.println("当次限额：" + acc.getQuotaMoney());



    }





    /**

     * 用户开户功能

     * @param accounts 账户的集合对象

      */

    private static void register(ArrayList<Account> accounts, Scanner sc)

    {





        System.out.println("=========用户开户功能==========");

        //键盘录入 姓名 密码 确认密码

        System.out.println("请您输入开户名称：");

        String name = sc.next();





        String password = "";

        while (true)

        {

            System.out.println("请您输入开户密码：");

            password = sc.next();

            System.out.println("请您输入确认密码：");

            String okPassword = sc.next();



//        判断两次输入的密码是否一致

            if (okPassword.equals(password))

                            //字符串比较用equals

            {

                break;

            }

            else

            {

                System.out.println("两次密码必须一致~~~");

            }

        }





        System.out.println("请您输入当次限额：");

        double quotaMoney = sc.nextDouble();



//        3.生成账户的卡号，卡号是8位，而且不能与其他账户卡号重复。

        String cardId = creatCardId(accounts);





//        4.创建一个账户对象封装账户的信息

//        public Account(String cardId, String userWord, String passWord, double money, double quotaMoney)

        Account account = new Account(cardId,name,password,quotaMoney);



//        5.把账户对象添加到集合中去

        accounts.add(account);

        System.out.println("恭喜您，您开户成功，您的卡号是：" + account.getCardId() + ",请您妥善保管");





    }



    public static String creatCardId(ArrayList<Account> accouts)

    {

        while (true) {

//        生成8位随机的数字代表卡号

            String cardId = "";

            Random r = new Random();

            for (int i = 0; i < 8; i++)

            {

                cardId += r.nextInt(10);

            }



//        判断卡号是否重复了

            Account acc = getAccountBycardId(cardId,accouts);

            if (acc == null)

            {

    //            说明当前卡号没有重复

                return cardId;

            }

        }

    }



    public static Account getAccountBycardId(String cardId, ArrayList<Account> accounts)

    {

//        根据卡号查询对象

        for (int i = 0; i < accounts.size(); i++) {

            Account acc = accounts.get(i);

            if (acc.getCardId().equals(cardId))

            {

                return acc;

            }

        }

        return null;

        //查无此账户，说明卡号没有重复了！

    }

}

上一篇　PHP与Java实现DES加密解密的示例对比 下一篇　使用 Python 日期库 pendulum 管理日期时间

本类最新

查看更多

热门推荐

查看更多

热门教程

查看更多