Gemeinschaft Lernen Tools-Bibliothek Freizeit
suchen
Deutsch
Heim > Java > javaLernprogramm > So implementieren Sie ein Geldautomatensystem in Java

So implementieren Sie ein Geldautomatensystem in Java

PHPz
Freigeben： 2023-06-02 21:42:52
nach vorne
1308 Leute haben es durchsucht

1. Systemvorbereitung, Homepage, Benutzerkonto-Eröffnungsfunktion

Systemvorbereitung, Homepage-Design

Systemvorbereitungsinhaltsanalyse:

  • Die Kontoinformationen jedes Benutzers sind ein Objekt und die Kontoklasse muss bereitgestellt werden

  • Es muss ein Container vorbereitet werden, der zum Speichern und Systemieren aller Kontoobjektinformationen verwendet wird.

  • Die Startseite muss nur Folgendes enthalten: Anmeldung und Registrierung 2 Funktionen.

Implementierungsschritte:

  • Definieren Sie die Kontoklasse für die spätere Erstellung Kontoobjekte, um Benutzer zu kapseln. Die Kontoinformationen

  • Die Informationen in der Kontoklasse müssen mindestens Folgendes enthalten (Kartennummer, Name, Passwort, Guthaben, Bargeldabhebungslimit)

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("您当前输入的操作命令不被支持！");
            }
        }
    }
}
Nach dem Login kopieren

So implementieren Sie ein Geldautomatensystem in Java

Zusammenfassung

  • Wie Stellt das System die Kontoinformationen des Benutzers dar?

Definieren Sie die Kontoklasse „Konto“ und definieren Sie die Attributinformationen, die das System berücksichtigt.

  • Was verwendet das System zum Speichern aller Benutzerkontoobjektinformationen? 

ArrayList<Account> accounts = new ArrayList<> ();
Nach dem Login kopieren

Implementierung der Benutzerkonto-Eröffnungsfunktion

  • Analyse

Die Kontoeröffnungsfunktion besteht eigentlich darin, die Informationen eines neuen Kontoobjekts im Sammelbehälter des Systems zu speichern

  • Implementierung der Kontoeröffnungsfunktion Schritte

Definitionsmethode zum Abschließen der Kontoeröffnung: 

public static void register(ArrayList<Account>  accounts){...}
Nach dem Login kopieren

  • Name, Geheimnis, Passwort bestätigen über die Tastatur (die beiden Passwörter müssen konsistent sein)

  • Generieren Sie die Kontokartennummer, die Kartennummer muss sein automatisch vom System mit 8 Ziffern generiert (die Kartennummer muss eindeutig sein)

  • Erstellen Sie ein Kontoobjekt, um Kontoinformationen (Name, Passwort, Kartennummer) zu kapseln.

  • Speichern Sie das Kontoobjekt in den Sammelkonten. 

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

So implementieren Sie ein Geldautomatensystem in Java

Zusammenfassung

Welche Schritte sind erforderlich, um die Kontoeröffnungsfunktion zu realisieren, und welche Punkte müssen beachtet werden?

  • Die Kontoeröffnungsfunktion sollte unabhängig als Methode definiert werden und das aktuelle Sammlungsobjekt sollte an die Methode übergeben werden.

  • Geben Sie die Kontoeröffnungsinformationen ein (Name, Passwort).

  • Die Kartennummer muss automatisch generiert und eindeutig sein.

  • Kapseln Sie die Kontoeröffnungsinformationen in ein Kontoobjekt und speichern Sie sie in der Sammlung.

2? Geben Sie die Kartennummer über die Tastatur ein und fragen Sie das Kontoobjekt anhand der Kartennummer ab.

Wenn das Kontoobjekt nicht gefunden wird, bedeutet dies, dass die Kartennummer nicht vorhanden ist. Geben Sie die Kartennummer weiter ein.

  • Wenn das Kontoobjekt gefunden wird, bedeutet dies, dass die Kartennummer vorhanden ist. Geben Sie weiterhin die Kartennummer ein das Passwort

    Wenn das Passwort falsch ist, geben Sie das Passwort weiter ein

  • public static void login(ArrayList<Account>accounts){...}
    Nach dem Login kopieren

  • Zusammenfassung
  • Wie wird die Login-Funktion implementiert?

  • Fragen Sie das entsprechende Kontoobjekt in der Sammlung anhand der Kartennummer ab

Wenn das Kontoobjekt gefunden wird, bedeutet dies, dass die Kartennummer vorhanden ist. Geben Sie weiterhin das Passwort ein

So implementieren Sie ein Geldautomatensystem in Java

Wenn das Passwort korrekt ist, Die Anmeldung ist erfolgreich

    Design der Benutzerbedienungsseite, Konto abfragen, Kontofunktion abmelden

  • Benutzerbedienungsseite, Konto abfragen, Konto abmelden Funktionsanalyse

  • Nachdem sich der Benutzer erfolgreich angemeldet hat, muss er die eingeben Benutzeroperationsseite,

  • Die Abfrage zeigt direkt die Kontoobjektinformationen an, die sich aktuell erfolgreich angemeldet haben

Um sich vom Konto abzumelden, müssen Sie zur Startseite zurückkehren

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

  • Zusammenfassung
  • Design der Benutzerbedienungsseite, Kontoabfrage, Vorsichtsmaßnahmen für die Kontoabmeldefunktion

  • Wir sollten darauf achten, was nach dem Zugriff auf die Anmeldeschnittstelle zu tun ist. Achten Sie darauf, welche Benutzerbedienungsseiten vorhanden sind

Nach dem Einrichten des Vorgangs Schnittstelle, Sie müssen auf die Exit-Schnittstelle zugreifen Benutzer muss den Einzahlungsbetrag eingeben

So implementieren Sie ein Geldautomatensystem in Java

Rufen Sie die setMoney-Methode des Kontoobjekts auf, um den Zhanhu-Saldo in den Saldo nach der Einzahlung zu ändern

    Nach der Einzahlung müssen Sie die Kontoinformationen überprüfen, um zu bestätigen, ob das Sparen erfolgreich war! 

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

  • Zusammenfassung
Einzahlungsanalyse

Einzahlung besteht darin, das aktuelle Kontoobjekt zu erhalten

  • und dann den Benutzer den Einzahlungsbetrag eingeben zu lassen

  • Rufen Sie die. setMoney an Methode des Kontoobjekts um den Kontostand auf den Kontostand nach der Geldeinzahlung zu ändern

  • Nach der Geldeinzahlung müssen Sie die Kontoinformationen überprüfen, um zu bestätigen, ob die Einzahlung erfolgreich war!

  • Entzugsanalyse

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

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

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

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

    • 满足要求则调用账户对象的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;
        //查无此账户，说明卡号没有重复了！
    }
}
    Nach dem Login kopieren

    So implementieren Sie ein Geldautomatensystem in Java

    总结温习

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

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

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

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

    • 满足要求则调用账户对象的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;
        //查无此账户，说明卡号没有重复了！
    }
}
    Nach dem Login kopieren

    So implementieren Sie ein Geldautomatensystem in Java

    总结温习

    • 转账功能需要判断系统中是否有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;
        //查无此账户，说明卡号没有重复了！
    }
}
    Nach dem Login kopieren

    So implementieren Sie ein Geldautomatensystem in Java

    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;
    }
}
    Nach dem Login kopieren

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

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

    So implementieren Sie ein Geldautomatensystem in Java

    Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein Geldautomatensystem in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten：
java atm
Quelle：yisu.com
Vorheriger Artikel：So generieren Sie ein JAR-Paket in Java und realisieren einen Einzelprozessbetrieb Nächster Artikel：Mit welchen Methoden kann SpringBoot Yml-Konfigurationsdateien lesen?
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Aktuelle Ausgaben
Wie konvertiere ich eine Zeichenfolge in JavaScript in eine 19-stellige Zahl ohne automatische Rundung? Wir haben die Zeichenfolgeneingabe „6145390195186705543“, wenn wir diese Eingabe in eine Z...
Aus 2024-03-30 14:42:35
0
1
367
verwandte Themen
Mehr>
Beliebte Empfehlungen
Beliebte Tutorials
Mehr>
Verwandte Tutorials
Beliebte Empfehlungen
Aktuelle Kurse
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage