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<> ();

사용자 계좌 개설 기능 구현

• Analytics

계좌 개설 기능은 실제로 새로운 계좌 객체의 정보를 시스템의 수집 컨테이너에 저장하는 것입니다

• 계좌 개설 기능 구현 steps

계좌 개설을 완료하는 정의 방법:

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

• 키보드 입력 이름, 비밀번호, 비밀번호 확인(두 비밀번호는 일치해야 함)

• 계좌 카드 번호를 생성합니다. 카드 번호는 다음과 같아야 합니다. 8자리로 시스템에서 자동 생성됩니다(카드 번호는 고유해야 함)

• 계정 정보(이름, 비밀번호, 카드 번호)를 캡슐화하는 Account 개체를 만듭니다.

• Account 개체를 수집 계정에 저장합니다.

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.????사용자 로그인, 운영 페이지 표시, 계정 조회, 계정 종료

사용자 로그인 기능 구현

analytic

• 정의 방법:

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.????사용자 예금 및 출금

사용자 예금

예금 분석

• 입금이 획득되었습니다. 현재 계정 개체

• 를 허용합니다. 사용자가 입금액을 입력합니다

• account 객체의 setMoney 메소드를 호출하여 Zhanhu 잔액을 입금 후 잔액으로 수정합니다

• 입금 후 계좌 정보를 확인하여 입금 성공 여부를 확인해야 합니다. !

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;
        //查无此账户，说明卡号没有重复了！
    }
}

위 내용은 Java로 ATM 시스템을 구현하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!