购物管理系统1.1--文档读写

概要:

本次升级较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

  • 3
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不吃折耳根

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值