Java如何实现ATM系统
作者：OpenWorld
时间：2023-04-26
浏览：2
1.系统准备，首页，用户开户功能系统准备，首页设计系统准备内容分析：每个用户的账户信息都是一个对象，需要提供账户类需要准备一个容器，用于存储和系统全部账户对象信息首页只需要包含：登入和注册2个功能实现步骤：定义账户类，用于后期创建账户对象封装用户的账户信息账户类中的信息至少需要包含（卡号，姓名，密码，余额，取现额度）packagecom.wangxinhua;importjava.util.ArrayList;importjava.util.Scanner;publicclassATMSystem{pub
1.系统准备，首页，用户开户功能
系统准备，首页设计
系统准备内容分析：
每个用户的账户信息都是一个对象，需要提供账户类
需要准备一个容器，用于存储和系统全部账户对象信息
首页只需要包含：登入和注册2个功能
实现步骤：
定义账户类，用于后期创建账户对象封装用户的账户信息
账户类中的信息至少需要包含（卡号，姓名，密码，余额，取现额度）
package com.wangxinhua;
import java.util.ArrayList;
import java.util.Scanner;
public class ATMSystem
{
public static void main(String[] args)
{
// 1.准备系统需要的容器对象，用户存储账户对象
ArrayList accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList 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，定义系统关心的属性信息
系统采用什么来储存全部用户的账户对象信息？
ArrayListaccounts = new ArrayList<> ();
用户开户功能实现
分析
开户功能其实就是往系统的集合容器中存入一个新的账户对象的信息
开户功能实现步骤
定义方法完成开户：
public static void register(ArrayListaccounts){...}
键盘录入姓名，秘密，确认密码（需保证两次密码一致）
生成账户卡号，卡号必须由系统自动生成8位数字（必须保证卡号的唯一）
创建Account账户类对象用户封装账户信息（姓名，密码，卡号）
把Account账户类对象存入到集合accounts中去。
package com.wangxinhua;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class ATMSystem
{
public static void main(String[] args)
{
// 1.准备系统需要的容器对象，用户存储账户对象
ArrayList accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList 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 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 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 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(ArrayListaccounts){...}
让用户键盘录入卡号，根据卡号查询账户对象。
如果没有找到了账户对象，说明卡号不存在，继续输入卡号
如果找到了账户对象，说明卡号存在，继续输入密码
如果密码不正确，提示继续输入密码
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 accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList 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 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 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 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 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 accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList accounts)
//showMain 开户首页的意思
// ArrayList 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 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 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 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 accounts)
{
// 根据卡号查询对象
for (int i = 0; i < accounts.size(); i++) {
Account acc = accounts.get(i);
if (acc.getCardId().equals(cardId))
{
return acc;
}
}
return null;//查无此账户，说明卡号没有重复了！
}
} 
总结
用户操作页设计，查询账户，退出账户功能注意事项
我们应该注意接入登录界面后应该注意用户操作页面有哪些
设置好操作界面后需要接入退出接口
3.????用户存款与取款
用户存款
存款分析
存款就是拿到当前账户对象
然后让用户输入存款金额
调用账户对象的setMoney方法将战虎余额修改成存钱后的余额
存钱后需要查新一下账户信息，确认是否存钱成功了！
package com.wangxinhua;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class ATMSystem {
public static void main(String[] args)
{
// 1.准备系统需要的容器对象，用户存储账户对象
ArrayList accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList accounts)
//showMain 开户首页的意思
// ArrayList 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 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 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 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 accounts)
{
// 根据卡号查询对象
for (int i = 0; i < accounts.size(); i++) {
Account acc = accounts.get(i);
if (acc.getCardId().equals(cardId))
{
return acc;
}
}
return null;
//查无此账户，说明卡号没有重复了！
}
} 
总结
存款分析
存款就是拿到当前账户对象
然后让用户输入存款的金额
调用账户对象的setMoney方法将账户余额修改成存钱后的余额
存钱后需要查询一下账户信息，确认是否存钱成功了！
取款分析
取款需要先判断账户是否有钱
有钱则拿到自己账户对象
然后让用户输入取款金额
判断取款金额是否超过了当次限额，以及金额是否足够
满足要求则调用账户对象的setMoney方法完成金额的修改
package com.wangxinhua;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class ATMSystem {
public static void main(String[] args)
{
// 1.准备系统需要的容器对象，用户存储账户对象
ArrayList accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList accounts)
//showMain 开户首页的意思
// ArrayList 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 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 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 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 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 accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList accounts)
//showMain 开户首页的意思
// ArrayList 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 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 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 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 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 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 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 accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList accounts)
//showMain 开户首页的意思
// ArrayList 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 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 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 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 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 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 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 accounts = new ArrayList();
// 2.准备系统的首页，登入，开户
showMain(accounts);
}
public static void showMain(ArrayList accounts)
//showMain 开户首页的意思
// ArrayList 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 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 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 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 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 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 accounts)
{
// 根据卡号查询对象
for (int i = 0; i < accounts.size(); i++) {
Account acc = accounts.get(i);
if (acc.getCardId().equals(cardId))
{
return acc;
}
}
return null;
//查无此账户，说明卡号没有重复了！
}
} 
作者最新文章
WPS 表格怎么套用内置表格样式
2026-10-08 14:05
photoshop工具有哪些 photoshop工具详细介绍
2026-09-29 11:05
三星 Galaxy A08 渲染图曝光：Helio G99 芯片与 6000mAh 电池配置解析
2026-09-08 17:14
OPPO Find X10 Pro Max 影像规格详解：三颗2亿像素镜头与全焦段8K视频能力
2026-09-08 16:41
PDF转HTML在线转换器怎么选？转换后网页排版怎么查？
2026-09-04 11:02
上一篇：
Java如何访问成员变量？
相关文章
更多
热门文章
更多
精品专题
更多
Mac软件
更多
WPS Office macOS版
WPS Office是一款面向macOS用户的综合办公套件，将文字处理、电子表格、演示文稿、PDF工具、模板与云协作整合在同一应用中。它兼容常见Microsoft Office格式，支持Intel及Apple芯片Mac，基础功能可免费使用，
Shapr3D macOS版
Shapr3D是一款面向工业设计、机械工程、建筑概念和三维打印工作流的CAD软件。Mac版采用Parasolid建模内核，支持草图约束、实体建模、工程图、可视化渲染及常见CAD格式交换，并可通过账户在多台设备之间同步项目。
REAPER macOS版
REAPER是Cockos开发的数字音频工作站，提供多轨音频与MIDI录制、剪辑、处理、混音和母带制作工具。Mac版兼容Intel与Apple芯片，支持AU、VST、VST3、CLAP等插件格式，并提供高度可定制的工作流程。
Ableton Live macOS版
Ableton Live 是面向音乐制作人与现场表演者的数字音频工作站，提供编曲视图、独具特色的现场视图、音频录制、MIDI创作、实时变速、乐器及效果器。Mac版原生支持Apple芯片，并可连接音频接口、MIDI控制器和第三方插件。
Adobe After Effects macOS版
Adobe After Effects 是面向动态图形、影视特效与视频合成的专业创作软件。它提供关键帧动画、遮罩抠像、运动跟踪、三维空间、文字动画和表达式等工具，并可与 Premiere Pro、Photoshop、Illustrator
Adobe Audition macOS版
Adobe Audition 是面向播客、影视后期、音乐制作及内容创作者的专业音频工作站，提供波形精修、多轨录制与混音、频谱编辑、降噪修复、响度匹配和效果处理工具，并可与 Adobe Premiere 协同完成视频声音制作。
Adobe Bridge macOS版
Adobe Bridge 是面向摄影师、设计师及内容团队的免费数字资产管理工具，可集中预览照片、视频和 Adobe 项目文件，并利用评级、标签、关键词、元数据、筛选与收藏集完成分类检索。它还支持批量重命名、格式导出、相机导入及 Camera
Adobe Illustrator macOS版
Adobe Illustrator 是 Adobe 推出的专业矢量图形设计软件，适合在 Mac 上制作标志、图标、插画、包装、信息图及印刷版面。它以路径和锚点构建可无损缩放的图形，并提供钢笔、形状、文字、图像描摹、渐变、画板及生成式功能。
Adobe InDesign macOS版
Adobe InDesign 是面向印刷品与数字出版物的专业版面设计软件，可在 Mac 上制作书籍、杂志、宣传册、海报、报告及交互式文档。它提供精细的文字样式、网格、母版、长文档管理和印前输出能力。
Adobe Lightroom Classic macOS版
Adobe Lightroom Classic 是面向桌面摄影工作流的照片管理与后期处理软件，可将原始照片保存在本地硬盘，通过目录、关键词、评分和收藏夹高效整理图库，并提供 RAW 冲印、蒙版、镜头校正、批量同步及多格式导出等功能。
Adobe Media Encoder macOS版
Adobe Media Encoder 是 Adobe 推出的专业音视频编码与转码工具，可通过队列、预设和监视文件夹批量完成格式转换、代理文件创建及多平台成片输出，并与 Premiere Pro、After Effects 等软件紧密协作。
Adobe Photoshop macOS版
Adobe Photoshop 是面向摄影师、设计师和内容创作者的专业图像处理软件，提供图层、蒙版、选区、修复、调色、文字排版、智能对象及生成式编辑等能力。Mac 版支持 Intel 与 Apple Silicon 处理器。
WINDOWS
更多
Adobe Photoshop Windows版
Adobe Photoshop 是面向摄影师、设计师和内容创作者的专业图像处理工具，可在 Windows 上完成照片修饰、选区抠图、图层合成、文字排版、绘画及生成式编辑。软件采用订阅授权，由 Creative Cloud 管理安装、更新与许
Adobe InDesign Windows版
Adobe InDesign 是面向印刷与数字出版的专业页面排版工具，可制作书籍、杂志、宣传册、海报、交互式 PDF 和电子书。它提供精细的文字样式、多页面管理、印前检查及多格式输出能力，并能与 Photoshop、Illustrator
Adobe Illustrator Windows版
Adobe Illustrator 是用于绘制矢量图形、插画、图标、徽标和版式的专业设计工具。它以路径和锚点为核心，作品放大后仍能保持清晰，并提供画板、文字、渐变、图像描摹及精确变换等功能，适合品牌视觉、印刷物料、数字界面和商业插画创作。
Adobe Bridge Windows版
Adobe Bridge 是 Adobe 推出的创意资产管理工具，可集中预览、分类和查找照片、视频、PDF及多种设计文件，并支持元数据、关键词、评级、批量重命名和格式导出。它可与 Photoshop、Illustrator 等应用衔接，
Affinity Photo Windows版
Affinity Photo 是一款面向摄影师、修图师和视觉设计人员的桌面图像编辑工具，提供 RAW 显影、多图层合成、蒙版、实时滤镜、批处理和色彩管理等功能。原独立产品已停止销售，其照片编辑能力已延续至免费的新 Affinity 应用；
Adobe Lightroom Classic Windows版
Adobe Lightroom Classic 是面向 Windows 桌面摄影工作流的照片管理与无损编辑工具，可通过目录集中整理大型图库，并完成 RAW 显影、局部蒙版、批量调整、打印和多格式导出。它强调本地文件管理与精细控制，
Figma Windows版
Figma 是面向产品设计与开发团队的云端协作平台，可在 Windows 桌面客户端中完成界面绘制、组件管理、交互原型、评论评审和开发交付。文件保存在云端，多名成员能够同步编辑并共享设计系统；官方同时提供免费 Starter 方案及按席位计
Affinity Designer Windows版
Affinity Designer 是面向矢量图形、数字插画和界面设计的专业创作工具，可在矢量、像素与导出工作区之间快速切换。它提供曲线编辑、形状构建、画板、排版、图层和专业色彩管理，并支持常见设计文件的导入及多种印刷、网页格式输出。
Capture One Pro Windows版
Capture One Pro 是面向摄影师和影像团队的专业桌面照片处理工具，提供相机定制色彩配置、RAW转换、图层与蒙版、联机拍摄、目录及会话管理等功能。它适合棚拍、人像、商业产品、婚礼和风光摄影，
Adobe Acrobat Pro Windows版
Adobe Acrobat Pro 是面向专业 PDF 工作的综合解决方案，可在 Windows 中创建、编辑、转换、比较、整理和保护文档，并支持表单、电子签名、扫描件文字识别及敏感信息永久遮盖。订阅还包含网页、移动服务和云端协作能力，
Adobe After Effects Windows版
Adobe After Effects 是面向动态图形、动画与影视视觉特效制作的专业工具，可完成关键帧动画、图层合成、遮罩跟踪、抠像、文字动画和二维三维元素整合。Windows 版通过 Adobe Creative Cloud 安装及更新，
DaVinci Resolve Windows版
DaVinci Resolve是Blackmagic Design推出的一体化影视后期工具，将素材管理、非线性剪辑、专业调色、Fusion视觉特效、Fairlight音频处理和成片交付整合在统一工程中。免费版已覆盖多数个人创作需求，