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){...}

• キーボードで名前、シークレット、パスワードの確認を入力します (2 つのパスワードは一致している必要があります)

• アカウント カード番号を生成しますカード番号はシステムによって 8 桁で自動的に生成される必要があります (必須 カード番号の一意性を保証します)

• Account オブジェクトを作成し、アカウント情報 (名前、パスワード、カード番号)

• Account オブジェクト Deposit をコレクション口座に配置します。

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.???ユーザーの入出金
• ユーザーの入金
  入金分析

入金とは当座預金を取得することですobject

そして、ユーザーに入金額の入力を求めます

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

• 概要

入金分析

入金とは、現在の口座を取得することですオブジェクト

次に、ユーザーに入金額を入力させます。

• account オブジェクトの 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 中国語 Web サイトの他の関連記事を参照してください。