1：项目分析：

实现首页，实现登录，实现不同角色登录之后的展示页面

名称：soso移动营业厅

项目功能分析：

难点：使用面向对象的思想，使用集合和对象

个人：注册，登录，查看个人信息，修改个人信息（修改密码），充值，查看我的业务，查看业务大厅（已发布），办理业务，终止业务

管理员：查看所有人信息，查看现有业务（所有），查看可以办理的业务，未发布项目，添加业务（添加完成之后，在未发布中），发布新业务（未发布的业务发布出去），

删除业务（不做删除，业务的上架和下架，改为未发布），修改业务价格

原有用户有2个，管理员1个：

管理员：用户名：admin, 密码：admin , 这个用户名不允许用户注册

用户一：用户名：zhang，密码：123;

用户二：用户名：lili , 密码：111;

数据库：

使用集合模拟数据库的功能，用于数据的存储（个人，业务），个人密码进行加密操作（MD5）

用户对象分析：主键 - 维护这条数据的唯一性，提高效率，方便，和身份证是一样的东西

用户编号，用户名，密码，姓名，手机号，身份证号码，arrayList<我的业务>，余额

1        lili      123    丽丽  11     1231313   

业务类

业务编号，业务标题，      业务描述（详情），           业务价格， 业务状态（1，正常办理，上架业务，0 业务下架 - 看不到的）

1        1元1G流量      短期流量包1天1元1个G     1         可以办理

1.   1元100分钟通话  有效期一个月，100分         1        可以办理

Zhangsan   abcabc123

Zhangsan 123 - abcabc123

2：功能的具体实现：

1：主页

项目启动后进入主页，显示用户的选择项，可以注册、登录、退出

2：注册：

用户选择注册功能进入注册页面，输入用户名和密码，和验证码

当集合中存在用户输入的用户名时，表示注册失败，注册失败，长度需要在4-10之间

密码输入时。如果两次输入的密码不一致，注册失败，4-16之间

输入验证码，验证码不同，注册失败；

当注册成功时，将用户名和密码封装到集合中，-存到数据库（容器）

注意：注册时，用户无法操作自己的用户编号，用户编号应该自动生成,  密码需要使用md5加密 ， 输入的密码（明文）--》加密---》一串看不懂（密文）

并显示用户需要进行的操作，可1：登录和0：退出

3：登录：

只有当用户名和密码都正确的时候，才显示登录成功，使用成员变量保存用户信息

输入用户名和密码判断是否正确，正确则显示登录成功，失败显示登录失败。

登录成功之后判断登录的是普通用户还是管理员（admin）

普通用户成功后显示用户主页（用户可以进行的操作）

如果是管理员的话显示管理员页面

失败后提示，1：注册，2：登录，0：退出 - 返回首页

4：管理员功能

登录成功之后，显示管理员的功能，并显示欢迎管理员：admin

1：显示所有用户信息

遍历存储用户信息的容器，

完成之后管理员可以选择返回管理员主页的操作，或者退出

2：展示现有业务

遍历用于存储业务的集合，

展示现有可以办理业务的具体信息

查看完成之后，管理员可以返回主页的选项

3：添加新业务

按照业务实体的属性，新增业务对象，设置对应的价格，标题，描述等信息

注意，

1：业务的编号不应该手动完成，需要自动完成编号的自增。

2：添加新业务不应该对现有其他业务有影响。

3：新业务添加完成之后，在未发布的业务中（其实就是将业务的状态设置为0）

4：删除业务

在删除业务之前，应该展示一下现有的所有业务，然后根据业务编号进行删除。

输入的编号必须在现有的列表中存在，否则重新输入。

删除前，需要询问管理员是否确认删除，以免后悔。

要求根据业务编号删除业务，删除业务后，查询业务时，不应该再显示，

删除业务时不应该对其他业务有影响

删除业务不是真实的删除，仅仅是一个下架操作

5：修改业务价格

在修改业务之前，应该展示一下现有的所有业务，然后根据业务编号进行修改。

输入的编号必须在现有的列表中存在，否则提示错误，退出。

根据编号进行价格的修改，对输入的价格进行校验等操作1-100区间

修改完成之后可以返回和退出。

查询时，应该显示最新的业务信息。

6：发布业务

管理员可以发布新业务，点击发布新业务的时候，需要将所有的未发布的业务展示出来

选择可以发布的业务编号（需要校验合理性）进行发布，输入不合理的话则发布失败

发布之后，可以在现有业务中进行查看

5：用户功能

用户登录成功之后，显示用户的功能，并显示XXX欢迎你

1：查看个人信息

根据保存在成员变量中的用户名，到用户列表中查询，

将查询到的用户信息展示给到用户查看，

并且提供返回的功能

2：修改个人信息-以修改密码为例

只有在输入原密码正确的情况下，才能进行密码的修改，

密码修改需要输入2次，如果2次输入的密码不一致，则修改失败

对输入的密码进行加密操作

修改成功后，查询的个人信息应该显示最新的个人信息。

提供返回的功能

3：充值

可以让用户自定义输入需要充值的金额，但必须是一个合理的整数

对充值的金额进行校验只能输入1-200，不合理的金额不能进行充值，

4：查看我的业务

查看当前登录用户已经办理了的业务，遍历展示即可

提供返回的功能

5：查看业务大厅

将现在所有的可以办理的移动业务从集合中查询出结果之后展示给到用户

6：业务办理

先将所有的业务展示给到用户查看

用户可以使用业务编号选择进行业务的办理。对用户输入的编号进行判断是否在合理的范围中

选择编号时，需要获取该业务的价格，判断用户的余额，如果余额不足提示充值，业务办理失败；

如果余额充足，首先使用余额减去业务的费用

然后将该业务添加到我的业务集合中，并且扣除相应的余额、业务办理成功

需要判断的内容：

1. 业务编号是否合理
2. 判断余额是否充足， 不够提供充值的入口
3. 将当前业务添加到我的业务中
4. 更新余额，更新我的业务

做好异常处理。

7：业务终止

和业务的下架类似

NullPointerException - 空指针异常

Null 调用了属性或者方法

业务的实体类

package publishsoso.pojo;
/*
业务类
业务编号，业务标题，
业务描述（详情），
业务价格， 业务状态（1，正常办理，上架业务，0 业务下架 - 看不到的）
Zhangsan
abcabc123
Zhangsan 123 - abcabc123
*/
public class Business {
private int businessId;//业务编号
private String businessTitle;//业务标题
private String businessInfo;//业务描述
private double businessPrice;//业务价格
private int businessCondition;//业务状态
//假如需要业务类的引用,这个方法可以用上
public Business() {}
public Business(int businessId, String businessTitle, String businessInfo, double businessPrice, int businessCondition) {
this.businessId = businessId;
this.businessTitle = businessTitle;
this.businessInfo = businessInfo;
this.businessPrice = businessPrice;
this.businessCondition = businessCondition;
}
public int getBusinessId() {
return businessId;
}
//业务ID是自动增加的,不允许修改
//
public void setBusinessId(int businessId) {
//
this.businessId = businessId;
//
}
//管理员添加业务使用的是构造方法,假如需要添加修改业务信息的功能,这些方法可以用上
public String getBusinessTitle() {
return businessTitle;
}
public void setBusinessTitle(String businessTitle) {
this.businessTitle = businessTitle;
}
public String getBusinessInfo() {
return businessInfo;
}
public void setBusinessInfo(String businessInfo) {
this.businessInfo = businessInfo;
}
public double getBusinessPrice() {
return businessPrice;
}
public void setBusinessPrice(double businessPrice) {
this.businessPrice = businessPrice;
}
public int getBusinessCondition() {
return businessCondition;
}
public void setBusinessCondition(int businessCondition) {
this.businessCondition = businessCondition;
}
@Override
public String toString() {
return "Business{" +
"businessId=" + businessId +
", businessTitle='" + businessTitle + ''' +
", businessInfo='" + businessInfo + ''' +
", businessPrice=" + businessPrice +
", businessCondition=" + businessCondition +
'}'+"n";
}
public String printUserBusiness() {
return Initialization.logier.getUsername()+"的业务{" +
"业务编号:" + businessId +
", 业务名:'" + businessTitle + ''' +
", 业务内容:'" + businessInfo + ''' +
", 业务价格:" + businessPrice +
'}'+"n";
}
}

用户的实体类

package publishsoso.pojo;
import java.util.ArrayList;
/*
管理员：查看所有人信息，查看现有业务（所有），查看可以办理的业务，未发布项目，添加业务
（添加完成之后，在未发布中），发布新业务（未发布的业务发布出去），
删除业务（不做删除，业务的上架和下架，改为未发布），修改业务价格
原有用户有2个，管理员1个：
管理员：用户名：admin, 密码：admin , 这个用户名不允许用户注册
用户一：用户名：zhang，密码：123;
用户二：用户名：lili , 密码：111;
*/
/*
用户编号，用户名，密码，姓名，手机号，身份证号码，arrayList<我的业务>，余额
*/
public class User {
//static Scanner sc = new Scanner(System.in);
private int uid;
private String username;
private String pwd;
private String name;
private String phone;
private String cardid;
private ArrayList<Business> myBusiness;
private double money;
private int points;
public User() {
}
public User(int uid, String username, String pwd, String name, String phone, String cardid,
double money, int points) {
this.uid = uid;
this.username = username;
this.pwd = pwd;
this.name = name;
this.phone = phone;
this.cardid = cardid;
this.myBusiness = new ArrayList<>();
this.money = money;
this.points = points;
}
@Override
public String toString() {
return "用户信息{" +
"uid=" + uid +
", 用户名='" + username + ''' +
", 密码密文='" + pwd + ''' +
", 姓名='" + name + ''' +
", 联系方式='" + phone + ''' +
", 身份证号码='" + cardid + ''' +"n"+
", 已办理的业务信息=" + myBusiness +
", 余额=" + money +
", 积分=" + points+
'}'+"n";
}
public int getPoints() {
return points;
}
public void setPoints(int points) {
this.points = points;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getCardid() {
return cardid;
}
public void setCardid(String cardid) {
this.cardid = cardid;
}
public ArrayList<Business> getMyBusiness() {
return myBusiness;
}
public void setMyBusiness(ArrayList<Business> myBusiness) {
this.myBusiness = myBusiness;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}

数据操作类

package publishsoso.pojo;
import publishsoso.utils.MD5Util;
import java.util.ArrayList;
/*
* 有关业务的方法
*/
public class DataOperator {
/*
显示所有用户信息
*/
public void showAllUser() {
for (User u :
Initialization.users) {
if (!u.getUsername().equals("admin"))
System.out.println(u);
}
}
//展示个人信息
public void showUserByName(String name) {
for (User user :
Initialization.users) {
if (name.equals(user.getUsername())) {
System.out.println(user);
}
}
}
/*
获取即将存入的用户UID BID
*/
public int getUid() {
//获取用户集合最后一位的UID,自增后返回
return Initialization.users.get(Initialization.users.size() - 1).getUid() + 1;
}
public int getBid() {
//获取业务集合最后一位的BID,自增后返回
return Initialization.businessList.get(Initialization.businessList.size() - 1).getBusinessId() + 1;
}
//添加用户
public boolean addUser(User user) {
/*
调用自动获取uid的方法,存入用户对象
*/
user.setUid(getUid());
Initialization.users.add(user);
System.out.println("添加成功");
return true;
}
//删除用户
public boolean removeUser(User user) {
//判断用户集合是否存在要删除的元素
int flag = 0;
for (User u :
Initialization.users) {
if (user.getUid() == u.getUid()) {
flag = 1;
break;
}
}
if (flag == 1) {
//执行删除操作
Initialization.users.remove(user);
System.out.println("删除成功");
return true;
} else {
System.out.println("不存在要删除的用户");
return false;
}
}
//添加新业务
public void addNewBusiness() {
System.out.println("请输入业务标题:");
String title = Initialization.sc.next();
System.out.println("请输入业务描述:");
String describe = Initialization.sc.next();
System.out.println("请输入业务价格:");
try {
double price = Initialization.sc.nextDouble();
Business business = new Business(getBid(), title, describe, price, 0);
if (!Initialization.businessList.contains(business)) {
//假如list不存在该业务,则可以添加,返回真
Initialization.businessList.add(business);
System.out.println("添加业务成功");
} else {
//存在该业务,添加失败
System.out.println("已存在该业务,添加失败");
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("业务价格输入格式错误,请重新操作");
String price1 = Initialization.sc.next();
addNewBusiness();
}
}
//彻底删除业务
public boolean removeBusiness(Business business) {
if (Initialization.businessList.contains(business)) {
//假如list存在该业务,则可以删除,返回真
Initialization.businessList.remove(business);
return true;
}
//不存在该业务,删除失败
return false;
}
//查看所有
public void showBusiness() {
for (Business business :
Initialization.businessList) {
System.out.println(business);
}
}
//查看下架业务
public void showUnPublishedBusiness() {
for (Business business :
Initialization.businessList) {
if (business.getBusinessCondition() == 0) {
System.out.println(business);
}
}
}
//查看上架中业务
public void showPublishedBusiness() {
for (Business business :
Initialization.businessList) {
if (business.getBusinessCondition() == 1) {
System.out.println(business);
}
}
}
public void updatePrice() {
showBusiness();
System.out.println("选择要修改价格的业务编号");
try {
int cbid = Initialization.sc.nextInt();
System.out.println("请输入新价格:");
int newPrice = Initialization.sc.nextInt();
searchBusinessBybid(cbid).setBusinessPrice(newPrice);
System.out.println("修改价格成功");
} catch (Exception e) {
e.printStackTrace();
System.out.println("业务编号或者价格输入格式错误,请重新输入");
String cbid = Initialization.sc.next();
String newPrice = Initialization.sc.next();
updatePrice();
}
}
//通过业务编号获取业务对象
public Business searchBusinessBybid(int sbid) {
for (Business b :
Initialization.businessList) {
if (b.getBusinessId() == sbid) {
return b;
}
}
return null;
}
//上架业务
public void publishBusiness() {
showUnPublishedBusiness();
System.out.println("请选择即将发布的业务编号:");
try {
int pbid = Initialization.sc.nextInt();
Business pb = null;
for (Business b :
Initialization.businessList) {
if (b.getBusinessId() == pbid) {
//进来说明输入的业务编号存在
if (b.getBusinessCondition() == 0) {
//进来说明该业务未发布
pb = b;
break;
}
}
}
if (pb == null){
System.out.println("未发布的业务中不存在该编号,业务发布失败");
}else{
pb.setBusinessCondition(1);
System.out.println("业务发布成功");
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("业务编码格式错误,请重新输入");
String pbid = Initialization.sc.next();
publishBusiness();
}
}
//下架业务
public void removeBusiness() {
showPublishedBusiness();
System.out.println("选择即将下架业务的编号:");
try {
int ubid = Initialization.sc.nextInt();
Business ub = null;
for (Business b :
Initialization.businessList) {
if (b.getBusinessId() == ubid) {
//进来说明输入的业务编号存在
if (b.getBusinessCondition() == 1) {
//进来说明该业务已发布
ub = b;
break;
}
}
}
if (ub == null) {
System.out.println("已发布的业务中不存在该编号,业务下架失败");
} else {
System.out.println("业务下架成功");
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("业务编号格式错误,请重新输入");
String ubid = Initialization.sc.next();
removeBusiness();
}
}
public void showMyBusiness() {
//注意,没有办理过业务的用户的业务列表是null,需要分配内存
if (Initialization.logier.getMyBusiness() == null) {
Initialization.logier.setMyBusiness(new ArrayList<>());
}
for (Business b :
Initialization.logier.getMyBusiness()) {
System.out.println(b.printUserBusiness());
}
}
public void endBusiness() {
/*
终止业务:展示用户的业务列表,用户输入编号,判断是否编号是否合理,删除业务
*/
System.out.println(Initialization.logier.getMyBusiness());
System.out.println("请输入需要终止的业务编号:");
try {
int ebig = Initialization.sc.nextInt();
Business eb = null;
for (Business business :
Initialization.logier.getMyBusiness()) {
if (business.getBusinessId() == ebig) {
//进来则输入编号存在,删除
eb = business;
break;
}
}
if (eb != null) {
Initialization.logier.getMyBusiness().remove(eb);
System.out.println("终止业务成功");
} else {
System.out.println("编号不存在,终止业务失败");
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("业务编号格式错误,请重新输入");
String ebig = Initialization.sc.next();
endBusiness();
}
}
public void buyBusiness() {
/*展示可办理业务列表,用户输入业务编号
判断可办理的业务编号是否合理,若存在判断余额是否充足,充足则将该业务添加进我的业务列表,更新余额
*/
Initialization.dataOperator.showPublishedBusiness();
System.out.println("请输入需要办理的业务编号:");
try {
int bbig = Initialization.sc.nextInt();
//循环的同时取出该业务对象
Business bBus = null;
//全局变量使用类名调用
for (Business business :
Initialization.businessList) {
if (business.getBusinessId() == bbig && business.getBusinessCondition() == 1) {
bBus = business;
}
}
if (bBus == null) {
System.out.println("业务编号不合理,请重新操作");
Index.skip();
} else {
//判断余额是否充足
if ((Initialization.logier.getMoney() - bBus.getBusinessPrice()) > 0) {
//进来则余额充足
if (Initialization.logier.getMyBusiness() == null) {
//进来则用户没有办理过业务,业务列表是空的,需要开辟空间
Initialization.logier.setMyBusiness(new ArrayList<>());
}
//添加进个人业务列表并且扣除费用,添加积分
Initialization.logier.getMyBusiness().add(bBus);
Initialization.logier.setMoney(Initialization.logier.getMoney() - bBus.getBusinessPrice());
Initialization.logier.setPoints((int)bBus.getBusinessPrice()*10+Initialization.logier.getPoints());
System.out.println("添加购买业务成功");
Index.skip();
} else {
System.out.println("余额不足,购买失败");
Index.skip();
}
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("业务编号格式错误,请重新输入");
String bbig = Initialization.sc.next();
buyBusiness();
}
}
public void addMoney() {
System.out.println("请输入你要充值的金额:");
try {
double money = Initialization.sc.nextDouble();
double myMoney = Initialization.logier.getMoney();
Initialization.logier.setMoney(myMoney + money);
System.out.println("充值成功");
Index.userView();
} catch (Exception e) {
e.printStackTrace();
System.out.println("输入金额格式错误,请重新输入");
String money = Initialization.sc.next();
addMoney();
}
}
public void updatePwd() {
System.out.println("请输入新的密码:");
String pwd1 = Initialization.sc.next();
System.out.println("请再次输入新的密码:");
String pwd2 = Initialization.sc.next();
if (pwd1.length() < 6){
System.out.println("密码应该大于5位,修改失败");
Index.skip();
}else {
if (pwd1.equals(pwd2)) {
String newPwd = MD5Util.getMD5(pwd1);
Initialization.logier.setPwd(newPwd);
System.out.println("密码修改成功");
Index.skip();
} else {
System.out.println("密码修改失败");
Index.skip();
}
}
}
//展示个人信息
public void showMyInfo() {
Initialization.dataOperator.showUserByName(Initialization.logier.getUsername());
Index.userView();
}
//修改个人信息
public void updataMyInfo() {
System.out.println("请输入你的姓名:");
String myname = Initialization.sc.next();
System.out.println("请输入你的联系方式:");
String mypbone = Initialization.sc.next();
System.out.println("请输入你的身份证号:");
String mycardid = Initialization.sc.next();
Initialization.logier.setName(myname);
Initialization.logier.setPhone(mypbone);
Initialization.logier.setCardid(mycardid);
System.out.println("修改个人信息成功");
Index.userView();
}
/*
用户购买业务会获得积分,1块钱10分,积分可以参与抽奖(20分一次,奖品从已发布的业务中随机获取)
*/
public void pointsDraw(){
/*
判断用户积分是否满足抽奖要求,从已发布业务中随机抽取
*/
if(Initialization.logier.getPoints() >= 20){
Initialization.logier.setPoints(Initialization.logier.getPoints()-20);
//用变量去接受获取的抽奖信息
int drawNum = getDraw();
if (drawNum == 0){
//说明没中奖
System.out.println("谢谢你参与抽奖!下次一定会中的");
}else {
//中奖了,将全局变量的值存入个人业务列表
Initialization.logier.getMyBusiness().add(Initialization.db);
System.out.println("恭喜你获得:"+searchBusinessBybid(drawNum).getBusinessTitle());
}
}else{
System.out.println("很抱歉,您的积分不足,请消费后再试");
}
}
//生成101到110之间的随机数,假如该数字正好与发布中的业务编号相同,则返回该业务编号,否则返回0
public int getDraw(){
//产生101到110之间的随机数
int random = (int)(Math.random()*10)+101;
for (Business b :
Initialization.businessList) {
if (random == b.getBusinessId() && b.getBusinessCondition() == 1) {
//进来则说明随机数和一个已发布的业务的编号相同
Initialization.db = b;
return b.getBusinessId();
}
}
return 0;
}
}

静态初始化类

package publishsoso.pojo;
import java.util.ArrayList;
import java.util.Scanner;
public class Initialization {
static DataOperator dataOperator = new DataOperator();
static User logier = new User();
static Scanner sc = new Scanner(System.in);
//用户集合
static ArrayList<User> users = new ArrayList<>();
//业务集合(使用arrayList存储)
static ArrayList<Business> businessList = new ArrayList<>();//所有业务
//中奖记录
static Business db = null;
static {
/*
创建集合类对象,创建初识用户的个人业务集合,创建初识用户对象,创建初始业务对象,创建用户集合,创建业务集合,添加
*/
User u1 = new User(1000, "admin", "d033e22ae348aeb5660fc2140aec35850c4da997", "管理员", null, null, 0, 0);
User u2 = new User(1001, "ganyu", "40bd001563085fc35165329ea1ff5c5ecbdbbeef", "甘雨", "13396657815", "340881456713054578", 100,0);
User u3 = new User(1002, "hutao", "6216f8a75fd5bb3d5f22b6f9958cdede3fc086c2", "胡桃", "13396655912", "340881456713051265", 100,0);
Business b1 = new Business(101, "仙师降临,袱恶降魔", "送降魔大圣--魈", 1000, 1);
Business b2 = new Business(102, "循循守月,万家灯火", "月海亭秘书--甘雨", 1000, 1);
Business b3 = new Business(103, "蝶引来生,燃花作香", "往生堂主--胡桃", 1000, 1);
Business b4 = new Business(104, "新年大回馈", "新年活动送100纠缠之缘", 100, 0);
//注意,存储进AllDataStore里的集合,并且调用集合本身的添加方法
users.add(u1);
users.add(u2);
users.add(u3);
businessList.add(b1);
businessList.add(b2);
businessList.add(b3);
businessList.add(b4);
}
}

界面类

package publishsoso.pojo;
import publishsoso.utils.MD5Util;
public class Index {
public static void index() {
System.out.println("欢迎来到嗖嗖移动大厅");
System.out.println("请选择:");
System.out.println("1:注册");
System.out.println("2:登录");
System.out.println("0:退出程序");
System.out.print("请输入:");
String num = Initialization.sc.next();
switch (num) {
case "1":
register();
break;
case "2":
login();
break;
case "0":
System.out.println("欢迎下次再来");
System.exit(0);
default:
System.out.println("输入错误");
index();
break;
}
}
public static String yanzhengma() {
String random = Math.random() + "";
String str = random.substring(random.length() - 4);
System.out.println(str);
return str;
}
public static void register() {
System.out.println("请输入用户名:");
String myname = Initialization.sc.next();
System.out.println("请输入密码:");
String mypwd1 = Initialization.sc.next();
System.out.println("请再次输入密码:");
String mypwd2 = Initialization.sc.next();
System.out.println("请输入验证码:");
String str = yanzhengma();
String yanzhengma = Initialization.sc.next();
int flag = 0;
for (User u :
Initialization.users) {
//遍历users查找有没有和输入的用户名相同的对象
if (u.getUsername().equals(myname)) {
//进来则有相同用户
flag = 1;
System.out.println("用户名相同,注册失败");
break;
}
}
if (flag == 1) {
//用户名相同,重新注册
index();
} else {
if (myname.length() < 10 && myname.length() > 4 && mypwd1.length() > 5) {
//进来表示用户名符合规范
if (mypwd1.equals(mypwd2)) {
//进来表示两次密码输入一致
if (yanzhengma.equals(str)) {
//用户设置的密码先转成密文再存储
mypwd1 = MD5Util.getMD5(mypwd1);
//初始化一个新的用户对象存入用户集合
User user = new User();
user.setUid(Initialization.dataOperator.getUid());
user.setUsername(myname);
user.setPwd(mypwd1);
user.setMoney(0.0);
user.setPoints(0);
Initialization.users.add(user);
System.out.println("注册成功");
index();
} else {
System.out.println("验证码错误");
index();
}
} else {
System.out.println("密码输入不一致");
index();
}
} else {
System.out.println("用户名不合规范,4-10位,或者密码小于6位");
index();
}
}
}
public static void login() {
System.out.println("请输入用户名:");
String myname = Initialization.sc.next();
System.out.println("请输入密码:");
String mypwd = Initialization.sc.next();
String md5pwd = MD5Util.getMD5(mypwd);
System.out.println("请输入验证码:");
String str = yanzhengma();
String yanzhengma = Initialization.sc.next();
int flag = 0;
for (User u :
Initialization.users) {
//遍历users查找有没有和输入的用户名相同的对象
if (u.getUsername().equals(myname) && u.getPwd().equals(md5pwd)) {
//进来则用户名密码都正确
//将当前对象设置为登录对象,因为登录对象是全局对象,所以对用户操作方便很多
Initialization.logier = u;
flag = 1;
break;
}
}
if (flag == 1) {
//注意,用户输入的密码需要先转成密文再比较
if (str.equals(yanzhengma)) {
System.out.println("登录成功");
skip();
} else {
System.out.println("验证码错误");
index();
}
} else {
System.out.println("错误的用户名或密码");
index();
}
}
//判断是管理员还是普通用户,跳转不同界面
public static void skip() {
if (Initialization.logier.getUsername().equals("admin")) {
adminView();
} else {
userView();
}
}
public static void userView() {
System.out.println("欢迎你:" + Initialization.logier.getUsername());
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("8:修改个人信息");
System.out.println("9:积分抽奖");
System.out.println("10:返回主页");
String num = Initialization.sc.next();
DataOperator dataOperator = new DataOperator();
switch (num) {
case "1":
dataOperator.showMyInfo();
userView();
break;
case "2":
dataOperator.updatePwd();
userView();
break;
case "3":
dataOperator.addMoney();
userView();
break;
case "4":
dataOperator.showMyBusiness();
userView();
break;
case "5":
dataOperator.showPublishedBusiness();
userView();
break;
case "6":
dataOperator.buyBusiness();
userView();
break;
case "7":
dataOperator.endBusiness();
userView();
break;
case "8" :
dataOperator.updataMyInfo();
userView();
break;
case "9" :
dataOperator.pointsDraw();
userView();
break;
case "10":
index();
break;
default:
System.out.println("欢迎下次再来");
System.exit(0);
}
}
private static void adminView() {
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("8:返回主页");
System.out.println("请选择要办理的业务");
String num = Initialization.sc.next();
switch (num) {
case "1":
Initialization.dataOperator.showAllUser();
adminView();
break;
case "2":
Initialization.dataOperator.showPublishedBusiness();
adminView();
break;
case "3":
Initialization.dataOperator.addNewBusiness();
adminView();
break;
case "4":
Initialization.dataOperator.removeBusiness();
adminView();
break;
case "5":
Initialization.dataOperator.publishBusiness();
adminView();
break;
case "6":
Initialization.dataOperator.showUnPublishedBusiness();
adminView();
break;
case "7":
Initialization.dataOperator.updatePrice();
adminView();
break;
case "8":
index();
break;
default:
System.exit(0);
}
}
}

package publishsoso.pojo;
public class Demo {
public static void main(String[] args) {
Index index = new Index();
index.index();
}
}

最后

以上就是踏实山水为你收集整理的面相对象的总结项目(嗖嗖业务大厅)1：项目分析：2：功能的具体实现：的全部内容，希望文章能够帮你解决面相对象的总结项目(嗖嗖业务大厅)1：项目分析：2：功能的具体实现：所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。