概要：
本次升级较1.0版本有如下变化：
1.1版：如果之前用数组存放用户信息、商品信息和购物历史信息，升级到使用集合框架类ArrayList、LinkedList等（该要求已在1.0版本完成）；另外，该版本支持将用户信息、商品信息、购物历史信息存放到文本文件中。
PS：（a）不需要在管理员/用户在操作过程中，随时去读写文本文件，操作过程中，程序读写的是集合框架类的对象。只需要在程序退出时将用户信息、商品信息和购物历史等从ArrayList对象中读取出来写到文本文件中，然后在下一次程序启动时，将这些信息从文本文件中读取出来。即：退出时写一次文本文件（可能有多个文件），启动时读一次文本文件。（b）对用户密码的存放不能直接用明文形式存放。要用MD5加密处理后再进行存放，相应的密码验证功能也要升级。（这个功能暂时未实现）
实现：
导入依赖（jar包）
1.1版本，该版本在1.0版本的基础上多加入了一个文本文档读写的操作，针对1.0版本集合储存的数据在程序结束运行后数据也被清空，用户要重复注册问题，加入了文本文档的读写操作，将用户和商品信息的所有数据存储在文本文档中。
图1：1.1类图
该版本由13个类构成，其中每个类的组成及功能如下：
1. Admin类，该类继承User类，User类中包含5个主要的方法用于实现以下几个功能：管理员登录、修改自身密码、修改用户密码、客户管理、商品管理。
//author Xipei Liao
import java.util.Scanner;
public class Admin extends User {
//管理员登录:admin，密码为ynuinfo#777
String name1 = "admin";
String passWord1 = "ynuinfo#777";
public void singIn() {
System.out.println("请输入您的密码：");
Scanner psa = new Scanner(System.in);
String passWorda1 = psa.next();
if (passWorda1.equals(passWord1)) {
System.out.println("登陆成功！");
} else {
System.err.println("密码错误！请重新输入。");
main(null);
}
}
//修改自身密码
public String setSelfPassWord() {
System.out.println("请输入原密码:");
Scanner newPass = new Scanner(System.in);
String passW = newPass.next();
if (passW.equals(passWord1)) {
passWord1 = passW;
System.err.println("密码已经成功修改");
Scanner nss = new Scanner(System.in);
System.out.println("是否查看新密码：\n\t1--是\n\t0--否");
int choose = nss.nextInt();
switch (choose) {
case 1:
System.out.println(passWord1);
setSelfPassWord();//返回上一级
break;
case 0:
setSelfPassWord();//返回上一级
}
} else {
System.err.println("密码输入错误");
setSelfPassWord();//返回上一级
}
return passWord1;
}
//修改用户密码
public String changeCustomerPassword() {
PassWordmg passWordmg = new PassWordmg();
passWordmg.setNewPassword();//调用方法修改用户密码
changeCustomerPassword();//返回上一级
return changeCustomerPassword();
}
//客户管理
public void customerManagement() {
System.out.println("请选择你要执行的操作：");
System.out.println("\t1--罗列客户");
System.out.println("\t2--删除客户");
System.out.println("\t3--搜索客户");
CustomerMg manage = new CustomerMg();
Scanner opr = new Scanner(System.in);
int operate = opr.nextInt();
switch (operate) {
case 1:
//罗列客户
manage.showCustomer();
break;
case 2:
//删除客户
manage.deleteCustomer();
break;
case 3:
//搜索客户
manage.searchCustomer();
break;
}
}
//商品管理
public void goodsManage() {
CommodityMg commodity = new CommodityMg();
System.out.println("请选择你要执行的操作：");
System.out.println("\t1--添加商品信息");
System.out.println("\t2--修改商品信息");
System.out.println("\t3--删除商品信息");
System.out.println("\t4--罗列商品");
Goods good=new Goods();
Scanner choose = new Scanner(System.in);
int choose1 = choose.nextInt();
switch (choose1) {
//添加商品信息
case 1:
good.addGoods0();
commodity.addGoods();
break;
//修改商品信息
case 2:
good.addGoods0();
commodity.modifyGoodsInformation();
break;
//删除商品信息
case 3:
good.addGoods0();
commodity.deleteGoodsInformation();
break;
//罗列商品
case 4:
good.addGoods0();
commodity.showAllGoodsToAdmin();
break;
}
}
} 2. CommodityMg类，该类是Goods类的子类，包含4个方法；该类主要为管理员提供，这些方法主要实现以下功能：添加商品信息、修改商品信息、删除商品信息、罗列商品（这里区别于客户端的商品罗列，管理员部分可以看到商品进货价部分）。
import java.util.Scanner;
public class CommodityMg extends Goods {//商品管理
//添加商品//商品的信息包括：商品编号、商品名称、生产厂家、生产日期、型号、进货价、零售价格、数量
public void addGoods() {
TABtoCustomer chooseAS=new TABtoCustomer();
System.err.println("你现在正在以管理员身份进行商品操作");
System.out.println("请添加商品编号：");
Scanner goodsNum = new Scanner(System.in);
int goodsNum1 = goodsNum.nextInt();
goodsNumber.add(goodsNum1);
System.out.println("请添加商品名：");
Scanner goodsNam = new Scanner(System.in);
String goodsNam1 = goodsNam.next();
goodsName.add(goodsNam1);
System.out.println("请添加商品生产厂商：");
Scanner goodsMft = new Scanner(System.in);
String goodsMft1 = goodsMft.next();
goodsManufacturer.add(goodsMft1);
System.out.println("请添加商品生产日期：");
Scanner goodsDP = new Scanner(System.in);
String goodsDP1 = goodsDP.next();
goodsDateOfProduction.add(goodsDP1);
System.out.println("请添加商品型号：");
Scanner goodsTp = new Scanner(System.in);
String goodsTp1 = goodsTp.next();
goodsTypes.add(goodsTp1);
System.out.println("请添加商品进价：");
Scanner goodsIP = new Scanner(System.in);
Double goodsIP1 = goodsIP.nextDouble();
goodsImportPrice.add(goodsIP1);
System.out.println("请添加商品零售价：");
Scanner goodsEP = new Scanner(System.in);
Double goodsEP1 = goodsEP.nextDouble();
goodsExitPrice.add(goodsEP1);
System.out.println("请添加商品数量：");
Scanner goodsCt = new Scanner(System.in);
int goodsCt1 = goodsCt.nextInt();
goodsCount.add(goodsCt1);
System.out.println("该商品已经添加完毕，是否继续");
System.out.println("\t7--继续\n\t8--退出");
Scanner choose = new Scanner(System.in);
int select = choose.nextInt();
switch (select) {
case 7:
System.err.println("添加下一件商品：");
addGoods();
break;
case 8:
chooseAS.chooseAfterSignIn();
break;//后期需要找到合适的返回点
}
}
//修改商品信息
public void modifyGoodsInformation() {
System.out.println("你现在正在执行商品信息修改操作");
System.out.println("请输入商品名进行修改：");
Scanner gdsName = new Scanner(System.in);
String gdName = gdsName.next();
int adds = goodsName.indexOf(gdName);//定位商品地址
if (goodsName.contains(gdName)) {
System.out.println("请选择需要修改的商品信息：");
System.out.println("\t1--商品编号");
System.out.println("\t2--商品名称");
System.out.println("\t3--生产厂家");
System.out.println("\t4--生产日期");
System.out.println("\t5--产品型号");
System.out.println("\t6--进货价");
System.out.println("\t7--零售价");
System.out.println("\t8--商品数量");
Scanner sel = new Scanner(System.in);
int sel1 = sel.nextInt();
switch (sel1) {
case 1://修改商品编号
System.out.println("请输入修改后的商品编号：");
Scanner alt = new Scanner(System.in);
int alter = alt.nextInt();
goodsNumber.set(adds, alter);
break;
case 2://修改商品名称
System.out.println("请输入修改后的商品名称：");
Scanner alt1 = new Scanner(System.in);
String alter1 = alt1.next();
goodsName.set(adds, alter1);
break;
case 3://修改商品生产厂家
System.out.println("请输入新的商品厂家：");
Scanner alt2 = new Scanner(System.in);
String alter2 = alt2.next();
goodsManufacturer.set(adds, alter2);
break;
case 4://修改生产日期
System.out.println("请输入新的生产日期：");
Scanner alt3 = new Scanner(System.in);
String alter3 = alt3.next();
goodsDateOfProduction.set(adds, alter3);
break;
case 5://修改产品型号
System.out.println("请输入修改后的产品型号：");
Scanner alt4 = new Scanner(System.in);
String alter4 = alt4.next();
goodsTypes.set(adds, alter4);
break;
case 6://修改商品进价
System.out.println("请输入修改后的商品进价：");
Scanner alt5 = new Scanner(System.in);
double alter5 = alt5.nextDouble();
goodsImportPrice.set(adds, alter5);
break;
case 7://修改商品零售价
System.out.println("请输入修改后的商品零售价：");
Scanner alt6 = new Scanner(System.in);
double alter6 = alt6.nextDouble();
goodsImportPrice.set(adds, alter6);
break;
case 8://修改商品数量
System.out.println("请输入修改后的商品零售价：");
Scanner alt7 = new Scanner(System.in);
int alter7 = alt7.nextInt();
goodsCount.set(adds, alter7);
break;
}
//判断是否继续重复这个操作
System.out.println("是否继续修改？");
System.out.println("\t1--是\n\t2--否");
Scanner chic = new Scanner(System.in);
int choice = chic.nextInt();
switch (choice) {
case 1:
modifyGoodsInformation();
break;
case 2:
break;
}
} else {
System.err.println("商品名不正确或商品不存在，请重试。");
modifyGoodsInformation();
}
}
//删除商品
public void deleteGoodsInformation() {
System.out.println("你正在执行商品删除操作：");
System.out.println("请输入商品名进行删除：");
Scanner gdName = new Scanner(System.in);
String gdsName = gdName.next();
int address = goodsName.indexOf(gdsName);//定位商品在商品库中的位置
System.err.println("该操作执行后被删除的数据不可恢复，是否继续？");
System.out.println("\t1--继续\n\t2--退出");
Scanner choose = new Scanner(System.in);
int choose1 = choose.nextInt();
switch (choose1) {
case 1:
if (goodsName.contains(gdsName)) {
goodsNumber.remove(address);
goodsName.remove(address);
goodsManufacturer.remove(address);
goodsDateOfProduction.remove(address);
goodsTypes.remove(address);
goodsImportPrice.remove(address);
goodsExitPrice.remove(address);
goodsCount.remove(address);
System.out.println("商品已成功删除！");
System.out.println("是否继续删除操作？");
System.out.println("\t1--是\n\t2--否");
Scanner chic1 = new Scanner(System.in);
int choice1 = chic1.nextInt();
switch (choice1) {
case 1:
deleteGoodsInformation();
break;
case 2:
break;
}
} else {
System.err.println("商品名不正确或商品不存在，请重试。");
modifyGoodsInformation();
}
break;
case 2:
break;
}
}
//罗列商品
public void showAllGoodsToAdmin() {
Goods goods1 = new Goods();
goods1.showAllGoods();//调用goods类的方法罗列出所有商品信息
System.out.println(goodsExitPrice);//显示进价，此栏仅为管理员展示
}
}3. Customer类，该类是User类的子类，包含9个方法用于实现以下功能：初始化用户、登录、注册、密码管理、购物车管理、支付、购物历史、客户信息读入ArrayList、ArrayList数据写入文本文档。
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;
public class Customer extends User {
ArrayList<String> customerName = new ArrayList<>();//用户名
ArrayList<String> cusPassword = new ArrayList<>();//客户密码
ArrayList<String> customerSignInTime = new ArrayList<>();//用户注册时间
String name1;
//初始化一个客户
public void addCustomer0() {
customerName.add("yun1923");//初始化一个用户
cusPassword.add("Ynu123456");//第一位用户的密码
PersonalInformation person = new PersonalInformation();
}
//登录
public void cuSignIn() {
this.addCustomer0();
System.out.println("请输入您的用户名：");
Scanner nm = new Scanner(System.in);
name1 = nm.next();
if (customerName.contains(name1)) {
System.out.println("请输入您的密码：");//密码连续输入错误5次就锁定账户。
Scanner ps = new Scanner(System.in);
String passWord1 = ps.next();
if (cusPassword.contains(passWord1)) {
System.out.println("登陆成功！");
TABtoCustomer trend = new TABtoCustomer();
trend.chooseAfterSignIn();
} else {
System.err.println("密码错误！");
System.out.println("~~~~~~~~~~~~");
System.out.println("\t1--重新输入");
System.out.println("\t2---忘记密码");
Scanner ipt = new Scanner(System.in);
int input = ipt.nextInt();
switch (input) {
//重新输入 //连续输入错误5次就锁定账户
case 1:
int count = 1;
while (true) {
int times = 5 - count;
if (count < 5) {
System.out.println("第" + count + "次输入的密码不正确，您还有" + times + "次机会");
System.out.println("请输入您的密码：");
Scanner ps1 = new Scanner(System.in);
String passWord2 = ps1.next();
if (cusPassword.contains(passWord2)) {
System.out.println("登陆成功！");
TABtoCustomer trend = new TABtoCustomer();
trend.chooseAfterSignIn();
}
count++;
}
if (count == 5) {
System.err.println("您5次输入的密码都不正确，账号即将被锁定！");
System.exit(0);
}
}
//忘记密码
case 2:
this.setPassWord();
break;
}
}
} else {
System.err.println("用户名输入错误！请重新输入。");
cuSignIn();//返回上一级
}
}
//密码管理
public String setPassWord() {
PassWordmg passWordmg = new PassWordmg();
passWordmg.setNewPassword();
System.out.println("是否查看新密码：\n\t1--是\n\t0--否");
Scanner choose = new Scanner(System.in);
int choose1 = choose.nextInt();
switch (choose1) {
case 1:
System.out.println(cusPassword);
setPassWord();//返回上一级
break;
case 0:
this.cuSignIn();
}
return setPassWord();
}
//用户注册
public void customerRegister() {
this.addCustomer0();
System.out.println("请输入您的用户名：");//用户名长度不少于5个字符；
Scanner nm1 = new Scanner(System.in);
String customersName = nm1.next();
if (customerName.contains(customersName)) {
System.err.println("该名称已有小伙伴使用啦，请换一个吧。");
customerRegister();
} else {
//要控制后面注册用户名储存的不与之冲突
Date signInDate = new Date();
customerSignInTime.add("2021-07-20-10-10-10");//初始化用户的注册时间，用于测试与占据数组的0号地址
//Date转String
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd-hh-hh-hh");
String str = sdf.format(signInDate);
System.out.println(str);
customerSignInTime.add(str);//将用户注册时间转换为字符串存入数组
System.out.println("您于" + signInDate + "注册了账号");
customerName.add(customersName);
System.out.println("请设置您的登录密码：");//密码长度大于8个字符，必须是大小写字母、数字和标点符号的组合。
System.err.println("密码长度大于8个字符，必须是大小写字母、数字和标点符号的组合。");
Scanner cusp1 = new Scanner(System.in);
String cusPassword1 = cusp1.next();
//要控制后面注册用户的密码储存地址不冲突
cusPassword.add(cusPassword1);
//if()判断
//用户个人信息填写
PersonalInformation personalInformation = new PersonalInformation();
personalInformation.bindMobilePhoneNumber();
personalInformation.setCustomerID();
personalInformation.bindEmail();
this.cuSignIn();
}
}
//购物车管理
//可能会出现功能重复的现象
public void shoppingMg() {
ShoppingMg shoppingMg = new ShoppingMg();
System.out.println("请选择对购物车的操作！");
System.out.println("\t1---添加商品至购物车");
System.out.println("\t2---删除购物车中的商品");
System.out.println("\t3---自动清理");
Scanner chs = new Scanner(System.in);
int choose = chs.nextInt();
switch (choose) {
case 1:
shoppingMg.addGoodsToShopCar();
break;
case 2:
shoppingMg.deleteGoodsFromShopCar();
break;
case 3:
shoppingMg.modifyGoodsOfShopCar();
break;
}
}
//支付
public void pay() {
Pay paying = new Pay();
paying.payFor();
}
//购物历史
public void shoppingHs() {
ShoppingHs history = new ShoppingHs();
history.getShoppingHs();
}
//读取客户核心资料
//用户名，用户密码，用户注册时间
public void readCustomerKey() {
try {
BufferedReader inf = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户名"));
BufferedReader inf1 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户密码"));
BufferedReader inf2 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户注册时间"));
String str1;
while ((str1 = inf.readLine()) != null) {
customerName.add(str1);
}
while ((str1 = inf1.readLine()) != null) {
cusPassword.add(str1);
}
while ((str1 = inf2.readLine()) != null) {
customerSignInTime.add(str1);
}
inf.close();
inf1.close();
inf2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//把用户核心资料写到文本文件中
//包括用户名，用户密码，用户注册时间
public void writeCustomerKey() {
try {
//当前为重写模式
BufferedWriter name = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户名"));
BufferedWriter password = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户密码"));
BufferedWriter registerTime = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户注册时间" ));
for (String i : customerName) {
name.write(i);
name.newLine();
name.flush();
}
for (String i : cusPassword) {
password.write(i);
password.newLine();
password.flush();
}
for (String i : customerSignInTime) {
registerTime.write(i);
registerTime.newLine();
registerTime.flush();
}
name.close();
password.close();
registerTime.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}4. CustomerMg类，该类继承Customer类，包含3个方法，这些方法主要实现以下功能：罗列客户、删除客户、搜索客户。
import java.util.Scanner;
public class CustomerMg extends Customer {//客户管理
PersonalInformation customerPersonalInformation=new PersonalInformation();//访问PersonalInformation类
//罗列出所有客户信息
//客户信息包括：客户ID、用户名、用户级别（金牌客户、银牌客户、铜牌客户）、用户注册时间、客户累计消费总金额、用户手机号、用户邮箱；
public void showCustomer() {
super.addCustomer0();
customerPersonalInformation. customerPhoneNumber.add("18183923329");
customerPersonalInformation.setCustomerID();//客户ID
System.out.println("用户："+customerName);//用户名
customerPersonalInformation.grade();//用户级别
super.customerSignInTime.add("2021-07-20-10-10-10");
System.out.println("注册时间："+super.customerSignInTime);//用户注册时间
customerPersonalInformation.statisticalConsumptionAmount();//客户累计消费总金额
customerPersonalInformation.customerEmail.add("yun.1923");
System.out.println("邮箱："+customerPersonalInformation.customerEmail);//用户邮箱
System.out.println("手机号："+customerPersonalInformation.customerPhoneNumber);//用户手机号
}
//删除客户
public void deleteCustomer() {
System.out.println("请输入用户名进行删除操作：");
Scanner input=new Scanner(System.in);
String input1=input.next();
if(customerName.contains(input1)){
System.out.println("你现在正在执行客户删除操作，是否继续？");
System.out.println("\t1--是\n\t2--否");
Scanner choose=new Scanner(System.in);
int choose1=choose.nextInt();
switch(choose1){
case 1:
int address=customerName.indexOf(input1);//input1的索引位置
customerName.set(address,"null");//删除用户名
customerPersonalInformation.customerID.set(address,"null");//删除客户ID
customerPersonalInformation.customerGrade.set(address,"null");//删除客户级别
customerSignInTime.set(address,"null");//删除客户注册时间
customerPersonalInformation.costTotal.set(address,0.0);//删除客户花销
customerPersonalInformation.customerEmail.set(address,"null");//删除客户邮箱
customerPersonalInformation.customerPhoneNumber.set(address,"null");//删除客户手机号
break;
case 2:
main(null);//后期需要找到准确的还原点
break;
}
}else{
System.err.println("查询不到该用户的相关信息!");
}
}
//搜索客户
//可以根据客户ID或者客户的用户名进行查询，也可以一次查询所有客户的信息。
public void searchCustomer(){
System.out.println("请选择查询方式：");
System.out.println("\t1--通过客户ID进行查询\n\t2--通过客户的用户名进行查询");
Scanner input=new Scanner(System.in);
int input1=input.nextInt();
switch(input1){
case 1: //根据客户ID进行查询
System.out.println("请输入客户ID：");
Scanner inputs=new Scanner(System.in);
String inputs1=inputs.next();
if(customerPersonalInformation.customerID.contains(inputs1)) {
int address=customerPersonalInformation.customerID.indexOf(inputs1);//input1的索引位置
System.out.println("客户ID："+inputs1);//客户ID
System.out.println("用户名："+customerName.get(address));//用户名
System.out.println("用户级别："+customerPersonalInformation.customerGrade.get(address));//用户级别
System.out.println("用户注册时间："+customerPersonalInformation.registrationTime.get(address));//用户注册时间
System.out.println("用户消费总金额："+customerPersonalInformation.costTotal.get(address));//客户累计消费总金额
System.out.println("用户邮箱："+customerPersonalInformation.customerEmail.get(address));//用户邮箱
System.out.println("用户手机号："+customerPersonalInformation.customerPhoneNumber.get(address));//用户手机号
}else {
System.err.println("用户ID错误或用户不存在！");
searchCustomer();
}
break;
case 2://根据用户名进行查询
System.out.println("请输入客户的用户名：");
Scanner inputs3=new Scanner(System.in);
String inputs2=inputs3.next();
if(customerPersonalInformation.customerID.contains(inputs2)) {
int address1=customerPersonalInformation.customerID.indexOf(inputs2);//input1的索引位置
System.out.println("客户ID："+customerPersonalInformation.customerID.get(address1));//客户ID
System.out.println("用户名："+inputs2);//用户名
System.out.println("用户级别："+customerPersonalInformation.customerGrade.get(address1));//用户级别
System.out.println("用户注册时间："+customerPersonalInformation.registrationTime.get(address1));//用户注册时间
System.out.println("用户消费总金额："+customerPersonalInformation.costTotal.get(address1));//客户累计消费总金额
System.out.println("用户邮箱："+customerPersonalInformation.customerEmail.get(address1));//用户邮箱
System.out.println("用户手机号："+customerPersonalInformation.customerPhoneNumber.get(address1));//用户手机号
}else {
System.err.println("用户名输入错误或用户不存在！");
searchCustomer();
}
break;
}
}
}
5. Goods类，该类包含了3个方法，这些方法主要实现以下几个功能：添加用于初始化的商品、罗列出所有商品、查询商品。
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class Goods {
//商品的信息包括：商品编号、商品名称、生产厂家、生产日期、型号、进货价、零售价格、数量。所有信息都要相互关联//8要素
ArrayList<Integer> goodsNumber = new ArrayList<>();//：商品编号
ArrayList<String> goodsName = new ArrayList<>();//商品名称
ArrayList<String> goodsManufacturer = new ArrayList<>();//生产厂家
ArrayList<String> goodsDateOfProduction = new ArrayList<>();//生产日期
ArrayList<String> goodsTypes = new ArrayList<>();//型号
ArrayList<Double> goodsImportPrice = new ArrayList<>();//进货价
ArrayList<Double> goodsExitPrice = new ArrayList<>();//零售价格
ArrayList<Integer> goodsCount = new ArrayList<>();//数量
int num = 0;
//添加商品,现在添加的属于初始化内容主要用于测试使用；
public void addGoods0() {
goodsNumber.add(1);
goodsName.add("可口可乐");
goodsManufacturer.add("coke");
goodsDateOfProduction.add("2021.7.19.12:00:03");
goodsTypes.add("1886");
goodsImportPrice.add(2.5);
goodsExitPrice.add(3.0);
goodsCount.add(500);
goodsNumber.add(2);
goodsName.add("火腿肠");
goodsManufacturer.add("双汇");
goodsDateOfProduction.add("2021.8.19.15:02:13");
goodsTypes.add("2003");
goodsImportPrice.add(0.8);
goodsExitPrice.add(1.2);
goodsCount.add(500);
}
//列出所有商品（这里不列出商品的进货价，进价部分只有管理员可见）
public void showAllGoods() {
addGoods0();
System.out.println("商品编号：" + goodsNumber);
System.out.println("商品名：" + goodsName);
System.out.println("生产商：" + goodsManufacturer);
System.out.println("生产日期：" + goodsDateOfProduction);
System.out.println("产品型号：" + goodsTypes);
System.out.println("零售价：" + goodsExitPrice);
System.out.println("库存：" + goodsCount);
}
//查询商品
//可以根据商品名称、生产厂家、零售价格进行单独查询或者组合查询
public void searchGoods() {
addGoods0();
System.out.println("请选择您的查询方式：");
System.out.println("\t1--商品名或生产厂家查询\n\t2--零售价查询");
Scanner choose = new Scanner(System.in);
int choose6 = choose.nextInt();
switch (choose6) {
case 1:
System.out.println("\t1--输入的商品名或生产厂家查询");
System.out.println("\t2--输入的商品名和生产厂家查询");
Scanner choose_ = new Scanner(System.in);
int che = choose_.nextInt();
switch (che) {
case 1:
System.out.println("请输入您要搜索商品的商品名或生产厂家：");
Scanner sch = new Scanner(System.in);
String search = sch.next();
if (goodsName.contains(search)) {
int site = goodsName.indexOf(search);//定位商品地址
System.out.println("商品名：" + search);
System.out.println("商品编号：" + goodsNumber.get(site));
System.out.println("生产商：" + goodsManufacturer.get(site));
System.out.println("生产日期：" + goodsDateOfProduction.get(site));
System.out.println("产品型号：" + goodsTypes.get(site));
System.out.println("零售价：" + goodsExitPrice.get(site));
System.out.println("库存量：" + goodsCount.get(site));
} else if (goodsManufacturer.contains(search)) {
int site1 = goodsManufacturer.indexOf(search);//定位商品地址
System.out.println("商品名：" + goodsName.get(site1));
System.out.println("商品编号：" + goodsNumber.get(site1));
System.out.println("生产商：" + search);
System.out.println("生产日期：" + goodsDateOfProduction.get(site1));
System.out.println("产品型号：" + goodsTypes.get(site1));
System.out.println("零售价：" + goodsExitPrice.get(site1));
System.out.println("库存量：" + goodsCount.get(site1));
} else {
System.out.println("暂无此商品的任何信息！");
}
break;
case 2://有BUG不能查询出结果
System.out.println("请输入您要搜索商品的商品名和生产厂家：");
Scanner sch1 = new Scanner(System.in);
String search1 = sch1.next();
//正则表达分割输入的字符串
String[] str = new String[2];
str = search1.split("\\s+");
String str1 = str[0];
String str2 = str[1];
if (goodsName.contains(str1) && goodsManufacturer.contains(str2)) {
int location = goodsName.indexOf(str1);//定位商品地址
System.out.println("商品名：" + goodsName.get(location));
System.out.println("商品编号：" + goodsNumber.get(location));
System.out.println("生产商：" + goodsManufacturer.get(location));
System.out.println("生产日期：" + goodsDateOfProduction.get(location));
System.out.println("产品型号：" + goodsTypes.get(location));
System.out.println("零售价：" + goodsExitPrice.get(location));
System.out.println("库存量：" + goodsCount.get(location));
} else if (goodsName.contains(str2) && goodsManufacturer.contains(str1)) {
int place = goodsName.indexOf(str2);//定位商品地址
System.out.println("商品名：" + goodsName.get(place));
System.out.println("商品编号：" + goodsNumber.get(place));
System.out.println("生产商：" + goodsManufacturer.get(place));
System.out.println("生产日期：" + goodsDateOfProduction.get(place));
System.out.println("产品型号：" + goodsTypes.get(place));
System.out.println("零售价：" + goodsExitPrice.get(place));
System.out.println("库存量：" + goodsCount.get(place));
} else {
System.out.println("暂无此商品的任何信息！");
}
break;
}
break;
case 2:
System.out.println("请输入商品零售价进行查询：");
Scanner prc = new Scanner(System.in);
double price = prc.nextDouble();
if (goodsExitPrice.contains(price)) {
int address = goodsExitPrice.indexOf(price);//定位商品
System.out.println("商品名：" + goodsName.get(address));
System.out.println("商品编号：" + goodsNumber.get(address));
System.out.println("生产商：" + goodsManufacturer.get(address));
System.out.println("生产日期：" + goodsDateOfProduction.get(address));
System.out.println("产品型号：" + goodsTypes.get(address));
System.out.println("零售价：" + goodsExitPrice.get(address));
System.out.println("库存量：" + goodsCount.get(address));
} else {
System.out.println("暂无此商品的任何信息！");
}
}
}
//从文本文件中获取商品信息
//读取文本数据至集合并转换数据类型
//获取上一次程序运行时产生的数据
public void acquireGoodsInformation() {
try {
BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\商品编号"));
BufferedReader br1 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\商品名称"));
BufferedReader br2 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\生产厂家"));
BufferedReader br3 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\生产日期"));
BufferedReader br4 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\型号"));
BufferedReader br5 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\进货价"));
BufferedReader br6 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\零售价格"));
BufferedReader br7 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\数量"));
String sCurrentLine;
while ((sCurrentLine = br.readLine()) != null) {
goodsNumber.add(Integer.parseInt(sCurrentLine));
}
while ((sCurrentLine = br1.readLine()) != null) {
goodsName.add(sCurrentLine);
}
while ((sCurrentLine = br2.readLine()) != null) {
goodsManufacturer.add(sCurrentLine);
}
while ((sCurrentLine = br3.readLine()) != null) {
goodsDateOfProduction.add(sCurrentLine);
}
while ((sCurrentLine = br4.readLine()) != null) {
goodsTypes.add(sCurrentLine);
}
while ((sCurrentLine = br5.readLine()) != null) {
goodsImportPrice.add(Double.parseDouble(sCurrentLine));
}
while ((sCurrentLine = br6.readLine()) != null) {
goodsExitPrice.add(Double.parseDouble(sCurrentLine));
}
while ((sCurrentLine = br7.readLine()) != null) {
goodsCount.add(Integer.parseInt(sCurrentLine));
}
br.close();
br1.close();
br2.close();
br3.close();
br4.close();
br5.close();
br6.close();
br7.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//往文本文件中写入数据
//把本次程序运行的数据写入文本文档
public void writeGoods(){
//目前为续写状态，后续根据实际需求更改
try {
//商品的信息包括：商品编号、商品名称、生产厂家、生产日期、型号、进货价、零售价格、数量。
BufferedWriter number = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\商品编号"));
BufferedWriter name = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\商品名称"));
BufferedWriter producer = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\生产厂家"));
BufferedWriter time = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\生产日期"));
BufferedWriter type = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\型号"));
BufferedWriter buy = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\进货价"));
BufferedWriter sell = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\零售价格"));
BufferedWriter count = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\数量"));
for (int i : goodsNumber) {
number.write(String.valueOf(i));
number.newLine();
number.flush();
}
for (String i : goodsName) {
name.write(i);
name.newLine();
name.flush();
}
for (String i : goodsManufacturer) {
producer.write(i);
producer.newLine();
producer.flush();
}
for (String i : goodsDateOfProduction) {
time.write(i);
time.newLine();
time.flush();
}
for (String i : goodsTypes) {
type.write(i);
type.newLine();
type.flush();
}
for (double i : goodsImportPrice) {
buy.write(String.valueOf(i));
buy.newLine();
buy.flush();
}
for (double i : goodsExitPrice) {
sell.write(String.valueOf(i));
sell.newLine();
sell.flush();
}
for (int i : goodsCount) {
count.write(String.valueOf(i));
count.newLine();
count.flush();
}
number.close();
name.close();
producer.close();
time.close();
type.close();
buy.close();
sell.close();
count.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}6. PasswordMg类，该类继承Customer类，包含一个方法；该方法主要为用户提供忘记密码后的修改密码操作。
import java.util.Scanner;
public class PassWordmg extends Customer{
public String setNewPassword(){
super.addCustomer0();
System.err.println("正在修改用户密码！");
System.out.println("请输入需要修改密码用户的用户名：");
Scanner nma=new Scanner(System.in);
String nameS=nma.next();
int address=customerName.indexOf(nameS);//定位用户地址
try{
if(customerName.contains(nameS)){
System.out.println("请输入修改后的密码：");
Scanner newPw=new Scanner(System.in);
String newPassWord=newPw.next();
System.out.println("请再次输入密码确认：");
Scanner newPw1=new Scanner(System.in);
String newPassWord1=newPw1.next();
if(newPassWord.equals(newPassWord1)){
cusPassword.set(address,newPassWord);
return setNewPassword();
}else {
System.err.println("两次密码不一致，请检查后再次输入！");
setNewPassword();
}
}else{
System.err.println("用户名输入错误或用户不存在，请检查后再次输入");
}
}catch (Exception e){
e.printStackTrace();
}
return setNewPassword();
}
}7. Pay类，该类继承Goods类，包含3个方法，这些方法主要用于客户在把商品添加至购物车后的支付操作、支付产生的信息写入文本文档、文档信息读入集合。
import java.util.ArrayList;
import java.util.Scanner;
public class Pay extends Goods {
ArrayList<Double> costTotal = new ArrayList<>();//计算总花销
double total;//计算总金额
ArrayList<String> bought = new ArrayList<>();//存放曾经购买过的商品信息
Customer people = new Customer();
ShoppingMg shoppingMg = new ShoppingMg();
TABtoCustomer next=new TABtoCustomer();
int adds;
//支付
public void payFor() {
try {
costTotal.add(0,0.0);
people.addCustomer0();
super.addGoods0();
System.out.println("请输入您想要购买的商品名：");
shoppingMg.ownGoods.add("可口可乐");
shoppingMg.ownGoodsCount.add(1);
Scanner shp = new Scanner(System.in);
String shoppingName = shp.next();
if (shoppingMg.ownGoods.contains(shoppingName)) {
System.out.println("请选择支付方式：");
System.out.println("\t1--微信");
System.out.println("\t2--支付宝");
System.out.println("\t3--银行卡");
Scanner chp = new Scanner(System.in);
int payChoose = chp.nextInt();
int address = shoppingMg.ownGoods.indexOf(shoppingName);//该商品在购物车中的位置
int adr = goodsName.indexOf(shoppingName);//该商品在商品库中的位置
System.out.println(goodsName);
int count = shoppingMg.ownGoodsCount.get(address);//商品在购物车中的数量
double price = goodsExitPrice.get(adr);//商品的价格
total = count * price;//总价
System.out.println("请输入用户名进行确认:");
Scanner confirm = new Scanner(System.in);
String local = confirm.next();
adds = people.customerName.indexOf(local);//找到该用户的信息储存位置
double cost1 = costTotal.get(adds);
costTotal.set(adds, total + cost1);
PersonalInformation admin = new PersonalInformation();
admin.grade();
switch (payChoose) {
case 1://微信支付
try {
System.out.println("是否确认支付？\n\t1--是\t2--否");
Scanner yee = new Scanner(System.in);
int yes = yee.nextInt();
switch (yes) {
case 1:
System.out.println("购买成功！");
bought.add(shoppingName);//产生购物历史
next.chooseAfterSignIn();
break;
case 2: {
return;
}
}
} catch (Exception e) {
e.printStackTrace();
}
case 2://支付宝支付
try {
System.out.println("是否确认支付？\n\t1--是\t2--否");
Scanner yee1 = new Scanner(System.in);
int yes1 = yee1.nextInt();
switch (yes1) {
case 1:
System.out.println("购买成功！");
bought.add(shoppingName);//产生购物历史
next.chooseAfterSignIn();
break;
case 2: {
payFor();
}
}
} catch (Exception e) {
e.printStackTrace();
}
case 3://银行卡支付
try {
System.out.println("是否确认支付？\n\t1--是\t2--否");
Scanner yee2 = new Scanner(System.in);
int yes2 = yee2.nextInt();
switch (yes2) {
case 1:
System.out.println("购买成功！");
bought.add(shoppingName);//产生购物历史
next.chooseAfterSignIn();
break;
case 2: {
payFor();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
} else {
System.out.println("从您的购物车中找不到该商品！");
payFor();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
TABtoCustomer err = new TABtoCustomer();
err.chooseAfterSignIn();
}
}
}8. PersonalIformation类，该类继承Pay类，包含7个方法，这些方法要实现以下功能：设置用户ID、用户注册后绑定手机号、用户绑定邮箱、统计用户总花销、判断用户级别（金牌客户、银牌客户、铜牌客户）、客户信息写入文本文档、从文本文档中读入客户信息。
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class PersonalInformation extends Pay {//记录客户个人信息
//客户ID、用户名、用户级别（金牌客户、银牌客户、铜牌客户）、用户注册时间、客户累计消费总金额、用户手机号、用户邮箱；
ArrayList<String> customerGrade = new ArrayList<>();//用户级别
ArrayList<String> registrationTime = new ArrayList<>();//用户注册时间
ArrayList<String> customerPhoneNumber = new ArrayList<>();//用户手机号
ArrayList<String> customerEmail = new ArrayList<>();//用户邮箱
ArrayList<String> customerID=new ArrayList<>();//用户ID
//设置用户ID
public void setCustomerID() {
try{
customerID = (ArrayList<String>) customerPhoneNumber.clone();
System.out.println("ID:"+customerID);
}catch (NumberFormatException e){
e.printStackTrace();
}
}
//绑定手机号
public void bindMobilePhoneNumber() {
customerPhoneNumber.add("18183923329");//
System.out.println("请输入您的手机号进行绑定：");
Scanner phn = new Scanner(System.in);
String phoneNumber = phn.next();
if (customerPhoneNumber.contains(phoneNumber)) {
System.err.println("该号码已经被注册！请换个号码重试");
bindMobilePhoneNumber();
} else {
customerPhoneNumber.add(phoneNumber);
System.out.println("号码绑定成功");
}
}
//绑定邮箱
public void bindEmail() {
customerEmail.add("yun.1923");
System.out.println("请输入您的邮箱账号进行绑定：");
Scanner phn = new Scanner(System.in);
String emailInput = phn.next();
if (customerPhoneNumber.contains(emailInput)) {
System.err.println("该号码已经被注册！请换个号码重试");
bindMobilePhoneNumber();
} else {
customerPhoneNumber.add(emailInput);
System.out.println("号码绑定成功");
}
}
//统计总花销
public void statisticalConsumptionAmount() {
super.costTotal.add(total);
System.out.println("总消费："+costTotal);
}
//判断客户级别
public void grade() {
people.addCustomer0();
this.statisticalConsumptionAmount();
double customerCost = costTotal.get(super.adds);
//金牌客户、银牌客户、铜牌客户
if (customerCost >= 0.0 && customerCost < 1000.0) {
customerGrade.add("铜牌客户");
System.out.println("客户级别："+customerGrade.get(super.adds));
}
if (customerCost >= 1000.0 && customerCost < 5000.0) {
customerGrade.add("银牌客户");
System.out.println("客户级别："+customerGrade.get(super.adds));
}
if (customerCost >= 5000.0) {
customerGrade.add("金牌客户");
System.out.println("客户级别："+customerGrade.get(super.adds));
}
if(costTotal.get(super.adds)==null){
customerGrade.add("铜牌客户");
System.out.println("客户级别："+customerGrade.get(super.adds));
}
}
//用户注册时间已经在customer类中解决
//从文本文档里面获取用户数据
public void acquireCustomerDate(){
try{
BufferedReader bfr = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\客户ID"));
BufferedReader bfr2 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户级别"));
BufferedReader bfr4 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\客户累计消费总金额"));
BufferedReader bfr5 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户手机号"));
BufferedReader bfr6 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户邮箱"));
String str;
while ((str = bfr.readLine()) != null) {
customerID.add(str);
}
while ((str = bfr2.readLine()) != null) {
customerGrade.add(str);
}
while ((str = bfr4.readLine()) != null) {
costTotal.add(Double.parseDouble(str));
}
while ((str = bfr5.readLine()) != null) {
customerPhoneNumber.add(str);
}
while ((str = bfr6.readLine()) != null) {
customerEmail.add(str);
}
bfr.close();
bfr2.close();
bfr4.close();
bfr5.close();
bfr6.close();
}catch(IOException e){
e.printStackTrace();
}
}
//把本次程序运行的数据存储至文本文档
//当前为重写模式
public void storageCustomerDate(){
try{
//客户ID、用户名、用户级别（金牌客户、银牌客户、铜牌客户）、用户注册时间、客户累计消费总金额、用户手机号、用户邮箱；
BufferedWriter ID = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\客户ID"));
BufferedWriter grade = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户级别"));
BufferedWriter costs = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\客户累计消费总金额"));
BufferedWriter phone = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户手机号"));
BufferedWriter email = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\用户邮箱"));
for (String i : customerID) {
ID.write(i);
ID.newLine();
ID.flush();
}
for (String i : customerGrade) {
grade.write(i);
grade.newLine();
grade.flush();
}
for (double i : costTotal) {
costs.write(String.valueOf(i));
costs.newLine();
costs.flush();
}
for (String i : customerPhoneNumber) {
phone.write(i);
phone.newLine();
phone.flush();
}
for (String i : customerEmail) {
email.write(i);
email.newLine();
email.flush();
}
ID.close();
grade.close();
costs.close();
phone.close();
email.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
9. ShoppingHs类，该类继承Pay类，包含3个方法，用于处理在Pay类中添加到购物车并且进行过支付处理的商品，把这一类商品添加到购物历史里面，产生购物历史、把购物历史读入程序、把购物历史写到文本文档。
import java.io.*;
public class ShoppingHs extends Pay {
public void getShoppingHs() {
shoppingMg.ownGoods.add("可口可乐");
System.out.println(shoppingMg.ownGoods);//遍历购物车里面的内容
System.out.println(bought);//遍历购物历史
}
//读取购物历史信息
public void readShoppingHs(){
try{
BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\购物历史"));
String hs;
while ((hs = br.readLine()) != null) {
bought.add(hs);
}
br.close();
}catch (IOException e){
e.printStackTrace();
}
}
//把购物历史存到文本文档中
public void writeShoppingHs(){
try{
//目前为续写模式
BufferedWriter his = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\购物历史"));
for (String i : bought) {
his.write(i);
his.newLine();
his.flush();
}
his.close();
}catch (IOException e){
e.printStackTrace();
}
}
}10. ShoppingMg类，该类继承Goods类，包含5个方法，这些方法主要实现客户登录后的以下功能：把商品添加到购物车、把商品从购物车中清除、修改购物车中的商品（修改商品数量，当商品数量小于等于0时，把该商品从购物车中删除）、把购物车中的商品信息写到文本文档、把文本文档中的商品信息读入程序。
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class ShoppingMg extends Goods {
//客户的购物车
ArrayList<String> ownGoods = new ArrayList<>();//购物车中的商品名称
ArrayList<Integer> ownGoodsCount = new ArrayList<>();//购物车中每种商品的数量
//增加商品至购物车
public void addGoodsToShopCar() {
super.addGoods0();
ownGoods.add("可口可乐");
ownGoodsCount.add(2);
TABtoCustomer tab=new TABtoCustomer();
System.out.println("\t1--商品名添加\n\t2--商品编号添加");
//用户选择
Scanner choose = new Scanner(System.in);
int add = choose.nextInt();
//用户输入
switch (add) {
case 1:
System.out.println("请输入你要购买的商品名称:");
Scanner buy = new Scanner(System.in);
String buyThings = buy.next();
if (goodsName.contains(buyThings)) {
ownGoods.add(buyThings);
int address4 = goodsName.indexOf(buyThings);
System.out.println("您购买的商品还剩余：");
System.out.println(goodsCount.get(address4));
System.out.println("请选择需要购买商品的数量");
Scanner num = new Scanner(System.in);
int number = num.nextInt();
ownGoodsCount.add(number);
//从商品库中减去被购买商品的数量
goodsCount.set(address4, goodsCount.get(address4) - number);
System.out.println("商品已成功添加至购物车，快去为宝贝买单吧！");
System.out.println("商品名："+ownGoods);
System.out.println("购买量："+ownGoodsCount);
System.out.println("\t1--继续\n\t2--返回");
Scanner trend=new Scanner(System.in);
int trends=trend.nextInt();
switch (trends){
case 1:
addGoodsToShopCar();//返回上一级
break;
case 2:
tab.chooseAfterSignIn();
break;
}
} else {
System.out.println("暂时还未找到您想要的商品");//判断商品是否存在
addGoodsToShopCar();//返回上一级
break;
}
case 2://使用商品名进行添加后期完善时加入
}
}
//把商品从购物车中清除
public void deleteGoodsFromShopCar() {
//先初始化添加第一位用户的购物车-->用于测试
ownGoods.add("可口可乐");
ownGoodsCount.add(2);
//先展示购物车中的内容
System.out.println("商品：" + ownGoods);
System.out.println("数量：" + ownGoodsCount);
try {
System.err.println("请确认是否继续商品删除操作");
System.out.println("\t1--继续\n\t2--退出");
Scanner chs = new Scanner(System.in);
int choose4 = chs.nextInt();
switch (choose4) {
case 1:
System.out.println("请输入需要删除的商品名：");
Scanner del1=new Scanner(System.in);
String delGoods=del1.next();
if(ownGoods.contains(delGoods)){
System.out.println("请选择删除方式：");
System.out.println("\t4--清除该商品的全部数量\n\t5--选择性清除");
Scanner del=new Scanner(System.in);
int delete=del.nextInt();
int address5=ownGoods.indexOf(delGoods);//找出商品在购物车中的位置
int address6=goodsName.indexOf(delGoods);//找出商品在商品库中的位置
switch (delete){
case 4:
ownGoods.remove(address5);
ownGoodsCount.remove(address5);
//把商品放回商品库
goodsCount.set(address6,goodsCount.get(address6)+ownGoodsCount.get(address5));
break;//后期加入还原点
case 5:
System.out.println("请输入需要删除的商品数量：");
Scanner deleteNumber=new Scanner(System.in);
int deleteCount=deleteNumber.nextInt();
if(deleteCount>ownGoodsCount.get(address5)||deleteCount<=0){
System.out.println("请重新选择");
}else {
ownGoodsCount.set(address5,ownGoodsCount.get(address5)-deleteCount);
System.out.println("删除成功");
//把商品放回商品库
goodsCount.set(address6,goodsCount.get(address6)+deleteCount);
}
}
}else {
System.err.println("购物车中没有此商品！");
System.err.println("请重新选择！");
deleteGoodsFromShopCar();
}
break;
case 2:
break;
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
}
//修改购物车中的商品//修改商品数量，当数量小于或等于0，则将该商品从购物车中清除。
public void modifyGoodsOfShopCar() {
if(ownGoodsCount.contains(0)){
int goodsAddress=ownGoodsCount.indexOf(0);//判断商品数等于0的商品在购物车中的位置
ownGoods.remove(goodsAddress);
}
}
//从文本文档中读取购物车信息
//商品名称和数量
public void readShoppingCar(){
try{
BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\已添加的商品"));
BufferedReader br1 = new BufferedReader(new FileReader("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\已添加的商品数量"));
String str;
while ((str = br.readLine()) != null) {
ownGoods.add(str);
}
while ((str = br1.readLine()) != null) {
ownGoodsCount.add(Integer.parseInt(str));
}
br.close();
br1.close();
}catch (IOException e){
e.printStackTrace();
}
}
//把购物车信息写到文本文档中
public void writeShoppingCar(){
try{
BufferedWriter og = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\已添加的商品"));
BufferedWriter og1 = new BufferedWriter(new FileWriter("C:\\Users\\asus\\Desktop\\实训实验报告\\第二阶段\\文本文件\\已添加的商品数量"));
for (String i : ownGoods) {
og.write(i);
og.newLine();
og.flush();
}
for (int i : ownGoodsCount) {
og1.write(String.valueOf(i));
og1.newLine();
og1.flush();
}
}catch(IOException e){
e.printStackTrace();
}
}
}11. TABtoAdmin类，该类继承Admin类，包含有1个方法，在此方法里面主要使用switch结构，为管理员登录后提供登陆后的操作选项，是一个登录后的选项卡。
import java.util.Scanner;
public class TABtoAdmin extends Admin {
public void adminTrend() {
System.out.println("请选择您接下来的操作：");
System.out.println("\t1--修改管理员密码");
System.out.println("\t2--修改客户密码");
System.out.println("\t3--客户管理");
System.out.println("\t4--商品管理");
System.out.println("\t5--退出");
Scanner trd1 = new Scanner(System.in);
int trend1 = trd1.nextInt();
switch (trend1) {
//修改管理员密码
case 1:
super.setSelfPassWord();
adminTrend();
break;
//修改客户密码
case 2:
super.changeCustomerPassword();
adminTrend();
break;
//客户管理
case 3:
super.customerManagement();
adminTrend();
break;
//商品管理
case 4:
super.goodsManage();
adminTrend();
break;
case 5:
System.exit(0);
}
}
} 12. TABtoCustomer类，该类继承Customer类，包含有1个方法，在此方法里面主要使用switch结构，为用户登录后提供登陆后的操作选项，是一个登录后的选项卡。
import java.util.Scanner;
public class TABtoCustomer extends Customer {
public void chooseAfterSignIn() {
System.out.println("请选择您接下来的操作：");
System.out.println("\t1--密码管理");
System.out.println("\t2--购物车管理");
System.out.println("\t3--支付");
System.out.println("\t4--查看购物历史");
System.out.println("\t5--返回");
Scanner trd = new Scanner(System.in);
int trend = trd.nextInt();
switch (trend) {
//密码管理
case 1:
super.setPassWord();
break;
//购物车管理
case 2:
super.shoppingMg();
break;
//支付
case 3:
super.pay();
break;
//购物历史
case 4:
super.shoppingHs();
break;
//返回
case 5:
main(null);
}
}
}13. User类，该类是所有类的主类，包含一个main方法，在该方法下主要实现把其它类进行一个聚合功能，在该方法下通过调用该类子类的方法和其他类的方法主要实现用户（管理员、客户）的登录操作，用户的注册操作以及对该系统所包含的所有商品进行浏览操作。
import java.io.*;
import java.util.Scanner;
public class User {
public static void main(String[] args) {
try{
System.err.println("============================");
System.err.println("\t1--登录");
System.err.println("\t2--注册");
System.err.println("\t3--搜索");
System.err.println("\t4--浏览商品");
System.err.println("\t5--退出");
System.err.println("请输入您的选择:");
Scanner ch = new Scanner(System.in);
int choose = ch.nextInt();
Admin admin = new Admin();
Goods good = new Goods();
Customer customer = new Customer();
good.addGoods0();
TABtoAdmin TtoAdmin = new TABtoAdmin();
PersonalInformation personalInformation=new PersonalInformation();
ShoppingHs shoppingHs=new ShoppingHs();
ShoppingMg shoppingMg=new ShoppingMg();
//文本文件导入
shoppingMg.readShoppingCar();
shoppingHs.readShoppingHs();
customer.readCustomerKey();
good.acquireGoodsInformation();
personalInformation.acquireCustomerDate();
if (choose > 0 && choose < 6) {
switch (choose) {
//登录
case 1:
System.out.println("请选择您的登录身份\n\t1--客户\n\t2--管理员");
Scanner read = new Scanner(System.in);
int reader = read.nextInt();
switch (reader) {
//客户登录
case 1:
customer. cuSignIn();
break;
//管理员登录
case 2:
admin.singIn();
TtoAdmin.adminTrend();
}
//注册
case 2:
//调用customer的方法
customer.customerRegister();
break;
//搜索商品（可以调用）
case 3:
//调用Goods类的方法
good.searchGoods();
System.out.println("是否继续搜索商品？");
System.out.println("\t1--继续\n\t2--退出");
Scanner cho = new Scanner(System.in);
int chi = cho.nextInt();
switch (chi) {
case 1:
good.searchGoods();
break;
case 2:
main(null);
break;
}
break;
//浏览商品
case 4:
good.showAllGoods();
main(null);
break;
//退出
case 5:
good.writeGoods();//先写一次文件产生源
personalInformation.storageCustomerDate();//产生源
customer.writeCustomerKey();//先写一次产生源
shoppingHs.writeShoppingHs();//产生源
shoppingMg.writeShoppingCar();//产生源
System.exit(0);//退出程序
}
} else {
System.err.println("请重新输入菜单中的选择");
main(null);
}
}catch (Exception e){
e.printStackTrace();
}
}
}项目工程文件：shoppingManage · Lxp181417/-1@8d4f81d (github.com)
MD5加密可以参考：https://blog.csdn.net/sayWhat_sayHello/article/details/88361035?utm_source=app&app_version=4.14.0&code=app_1562916241&uLinkId=usr1mkqgl919blen