JavaSE项目二：校园兼职平台

一.
项目要求：需求设计一个校园兼职平台来方便在校学生找兼职。

二.
项目前提掌握：
掌握java基本语法
熟悉使用流程控制
理解面向对象思想
熟练封装，继承，多态
熟悉使用接口，异常
熟悉使用集合
熟悉掌握I/o流相关操作
可使用自己学习的拓展知识对项目进行扩充

三.
项目功能结构：

四.
模块所有功能介绍：
（1）登录注册功能：用户通过注册进入平台，注册信息包括用户编号（用户编号决定角色类型，学号注册为兼职人员，教师编号注册为管理员），注册后到登录界面输入账号和密码登录平台，注册信息包括：用户编号（学号/教师 编号）、密码、姓名、出生日期、性别、电话、所在院系、注册日期等。后期如果忘记了密码，用户通过自己的账号和注册时的姓名找回密码。注意，为了安全起见，只有已经录入系统的用户可以注册账户，本平台提前录入了部分管理员和学生的信息到系统中供大家注册。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）

package wedu.view;


import wedu.util.IOUtils;
import wedu.util.TSUtility;
import wedu.dao.User;
import wedu.dao.UserAccount;

import java.io.*;
import java.text.ParseException;
import java.util.*;

/**
 * @author BaBa
 * @Version 1/0
 */
public class LoginView {
    //输入
    Scanner sc = new Scanner(System.in);
    //用户的text路径
    private static final String UserText = "D:\\编程\\IDEA\\IdeaProjects\\Probject2\\files\\User.txt";
    //用户信息的text路径
    private static final String UserInfo = "D:\\编程\\IDEA\\IdeaProjects\\Probject2\\files\\UserInformation.txt";
    private User user = new User();
    //创建Properties集合存储用户的编号以及姓名
    Properties pop = new Properties();
    ArrayList<User> arrayList = new ArrayList<User>();

    //从已知的用户文档中读取到Properties集合中
    public void read() throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(UserText));
        pop.load(br);
        br.close();
    }

    //登录注册首界面
    public User LoginScreen() throws IOException, ParseException, ClassNotFoundException, InterruptedException {
        User users = new User();
        boolean temp = true;
        Scanner sc = new Scanner(System.in);
        while (temp) {
            check();
            temp = true;
            int options = sc.nextInt();
            switch (options) {
                case 1:
                    //登录
                    users = signIn();
                    temp = users == null;
                    break;
                case 2:
                    //注册
                    register();
                    break;
                case 3:
                    System.out.print("退出中：");
                    temp = false;
                    break;
                default:
                    System.out.println("您输入的有误，请重新输入（1-3）!!!");
                    break;
            }
        }
        return users;
    }

    public void check() {
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🔣                                  🔣");
        System.out.println("🔣            ~登录注册界面~           🔣");
        System.out.println("🔣                                  🔣");
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🐻1. <登录>          *");
        System.out.println("🐘2. <注册>          *");
        System.out.println("🦁3. <退出>          *");
        System.out.println("请输入您的选项：");
    }


    //登录
    public User signIn() throws IOException, ClassNotFoundException, InterruptedException, ParseException {
        File file = new File(UserInfo);
        if (file.length() != 0) {
            arrayList = (ArrayList<User>) IOUtils.myDeserializable(UserInfo);
        }
        read();
        //设置登录失败次数
        int count = 5;
        //设置循环条件
        boolean flag = true;

        //判断文件或目录是否存在或者长度
        if (file.length() == 0 || !file.exists()) {
            System.out.println("现无人注册，请先注册！！");
        } else {
            while (flag) {
                System.out.println("*******************");
                System.out.println("*****         *****");
                System.out.println("***** 登录界面 *****");
                System.out.println("*****         *****");
                System.out.println("*******************");
                System.out.println("请输入您的账户:");
                String uid = TSUtility.readKeyBoard(4, false);
                System.out.println("请输入您的密码:");
                int password = TSUtility.readInt();
                boolean flag1 = true;
                //遍历已经注册的用户
                for (User user1 : arrayList) {
                    if (uid.equals(user1.getUID())) {
                        flag1 = false;
                        //匹配密码是否正确
                        if (password == user1.getPassword()) {
                            TSUtility.loadSpecialEffects();
                            System.out.println("登陆成功！欢迎您" + uid);
                            System.out.println();
                            return user1;
                        }//如果密码不正确
                        else {
                            count--;
                            System.out.println("登录失败！用户名或密码错误！");
                            System.out.println("是否忘记密码？（Y/N）");
                            char choose = TSUtility.readConfirmSelection();
                            if (choose == 'Y') {
                                System.out.println("请输入您的名字：");
                                String username = TSUtility.readKeyBoard(4, false);
                                if (uid.equals(user1.getUID()) && username.equals(user1.getUsername())) {
                                    System.out.println(uid + "的密码是:" + user1.getPassword());
                                } else {
                                    System.out.println("查询失败!您输入的名字和已有的不匹配");
                                    System.out.println("登录次数还剩" + count + "次");
                                    break;
                                }
                            } else if (choose == 'N') {
                                System.out.println("登录次数还剩" + count + "次");
                            }
                            //对于登陆次数，如为0则退出程序
                            if (count == 0) {
                                System.out.println("登录次数为0！强制退出");
                                System.exit(0);
                            }
                        }
                    }
                }
                //如果找不到其信息
                if (flag1) {
                    System.out.println("该账户未注册，请先注册!");
                    break;
                }
            }
        }
        return null;
    }

    //注册
    public void register() throws IOException, ClassNotFoundException {
        read();
        File file = new File(UserInfo);
        //防止空指针异常
        if (file.length() != 0) {
            Object o = IOUtils.myDeserializable(UserInfo);
            arrayList = (ArrayList<User>) o;
        }
        System.out.println("请输入您注册的账户(学号/教师编号)(四位)：");
        //获取到其账号
        String uid = sc.next();
        //用于判断其是否注册过账户的条件
        boolean boo = false;
        if (file.length() == 0) {
            user.setUID(uid);
            //存入姓名
            System.out.println("请输入您的姓名：");
            String username = TSUtility.readKeyBoard(4, false);
            pop.setProperty(uid,username);
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(UserText));
            pop.store(bufferedWriter,null);
            bufferedWriter.close();
            user.setUsername(username);
            //存入密码
            System.out.println("请输入您的注册密码：");
            String password = TSUtility.readKeyBoard(8, false);
            int pw = Integer.parseInt(password);
            user.setPassword(pw);
            //存入年龄
            System.out.println("请输入您的年龄：");
            while (true) {
                int age = TSUtility.readInt();
                if (age >= 16 && age <= 60) {
                    user.setAge(age);
                    System.out.println("请输入你的性别(男/女)：");
                    while (true) {
                        String sex = TSUtility.readKeyBoard(1, false);
                        if (sex.equals("男") || sex.equals("女")) {
                            user.setSex(sex);
                            call(user);//存电话（主要是判断其电话号码长度）
                            Department(user);//存入院系（目前只有理工学院和建工学院）
                            user.setRegdat(new Date());//存入当前年月
                            Balance(user);//存入余额（无条件）
                            arrayList.add(user);
                            IOUtils.mySerializable(arrayList, UserInfo);
                            System.out.println("注册成功！请登录！");
                            break;
                        } else {
                            System.out.println("输入错误，请重新输入（男/女）：");
                        }
                    }
                    break;
                } else {
                    System.out.println("输入年龄不符要求，请重新输入（16-60）：");
                }
            }



        } else {
            for (User user1 : arrayList) {
                if (uid.equals(user1.getUID())) {
                    boo = true;
                }
            }
            if (boo) {
                System.out.println("您已注册过账号，请登录！！");
            } else {
                user.setUID(uid);
                //存入姓名
                System.out.println("请输入您的姓名：");
                String username = TSUtility.readKeyBoard(4, false);
                pop.setProperty(uid,username);
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(UserText));
                pop.store(bufferedWriter,null);
                bufferedWriter.close();
                user.setUsername(username);
                //存入密码
                System.out.println("请输入您的注册密码：");
                String password = TSUtility.readKeyBoard(8, false);
                int pw = Integer.parseInt(password);
                user.setPassword(pw);
                //存入年龄
                System.out.println("请输入您的年龄：");
                while (true) {
                    int age = TSUtility.readInt();
                    if (age >= 16 && age <= 60) {
                        user.setAge(age);
                        System.out.println("请输入你的性别(男/女)：");
                        while (true) {
                            String sex = TSUtility.readKeyBoard(1, false);
                            if (sex.equals("男") || sex.equals("女")) {
                                user.setSex(sex);
                                call(user);//存电话（主要是判断其电话号码长度）
                                Department(user);//存入院系（目前只有理工学院和建工学院）
                                user.setRegdat(new Date());//存入当前年月
                                Balance(user);//存入余额（无条件）
                                arrayList.add(user);
                                IOUtils.mySerializable(arrayList, UserInfo);
                                System.out.println("注册成功！请登录！");
                                break;
                            } else {
                                System.out.println("输入错误，请重新输入（男/女）：");
                            }
                        }
                        break;
                    } else {
                        System.out.println("输入年龄不符要求，请重新输入（16-60）：");
                    }
                }
            }
        }
    }


    public static void call(User user) {
        boolean b = true;
        //存入电话
        while (b) {
            System.out.println("请输入你的电话号码：");
            String phone = TSUtility.readKeyBoard(11, false);
            if (phone.length() == 11) {
                user.setPhone(phone);
                b = false;
            } else {
                System.out.println("您输入的电话号码不正确，请重新输入！！");
            }
        }


    }

    public static void Department(User user) {
        //存入院系
        boolean b = true;
        while (b) {
            System.out.println("请输入你的所在院系：（理工学院/建工学院）");
            String department = TSUtility.readKeyBoard(8, false);
            if (Objects.equals(department, "理工学院") || Objects.equals(department, "建工学院")) {
                user.setDepartment(department);
                b = false;
            } else {
                System.out.println("请输入正确的学院！！！");
            }
        }
    }


    public static void CreditRating(User user) {
        //存入信用等级
        boolean b = true;
        while (b) {
            System.out.println("请输入您的信用等级（最开始都是五级,最低零级）：");
            int creditRating = TSUtility.readInt();
            if (creditRating == 5) {
                user.setCredit_rating(creditRating);
                b = false;
            } else {
                System.out.println("您输入的数字有问题，请重新输入！！！！");
            }

        }
    }

    public static void Balance(User user) {
        //存入余额
        System.out.println("请输入您的余额：");
        Double balance = TSUtility.readDouble();
        user.setBalance(balance);
    }
}

（2）个人信息管理：包括个人信息修改、密码修改、查询信用等级和查询余额功能。普通用户登录成功之后，可以修改个人注册时录入的信息，学号和注册时间不可更改，密码单独修改；也可以查询个人的信用等级，若信用等级不是最高，则查询个人信用等级时附加显示“按时完成X次后信用等级恢复至X级”（默认未逾期完成兼职工作3次恢复1级信用等级，等级梯度为1-5级，5级最高）。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）

package wedu.view;

import wedu.dao.User;
import wedu.service.PersonalInformationService;
import wedu.util.DateUtils;
import wedu.util.IOUtils;
import wedu.util.TSUtility;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;

/**
 * @author BaBa
 * @Version 1/0
 * 个人信息管理界面：
 */
public class PersonalInformationView {
    public void revise(User user, String UserInfo) throws IOException, InterruptedException, ClassNotFoundException {
        Object o = IOUtils.myDeserializable(UserInfo);
        ArrayList<User> users = (ArrayList<User>) o;
        //对于视图层的对象创建
        PersonalInformationService ps = new PersonalInformationService();
//        Date date = new Date();
        boolean flag = true;
        for (User user1 : users) {
            if (user1.getUID().equals(user.getUID())) {
                while (flag) {
                    InterfaceSelection();
                    //做选项
                    int options = TSUtility.readInt();
                    switch (options) {
                        case 1:
                            System.out.println("用户编号" + "\t\t" + "密码" + "\t\t" + "名字" + "\t\t" + "年龄" + "\t\t" + "性别" + "\t\t" + "手机号码"
                                    + "\t\t" + "所在院系" + "\t\t\t" + "注册时间" + "\t\t\t\t\t\t\t" + "信用等级" + "\t\t" + "余额" + "\t\t" + "完成人数");
                            System.out.println(user1.getUID() + "\t\t" + user1.getPassword() + "\t\t" + user1.getUsername() + "\t\t" + user1.getAge()
                                    + "\t\t" + user1.getSex() + "\t\t" + user1.getPhone() + "\t\t" +
                                    user1.getDepartment() + "\t\t" + DateUtils.dateToString(user.getRegdat(), "yyyy年 mm月 dd日") + "\t\t" + user1.getCredit_rating() + "\t\t" + user1.getBalance() + "\t\t" + user1.getCompleteNumber());
                            break;
                        case 2:
                            //选项界面
                            revise();
                            ps.PersonalInformationrevise(user, UserInfo);
                            System.out.println("*********************");
                            break;
                        case 3:
                            //密码修改
                            ps.revisePassword(user, UserInfo);
                            System.out.println("*********************");
                            break;
                        case 4:
                            //查询信用等级
                            ps.queryCreditRating(user,UserInfo);
                            System.out.println("*********************");
                            break;
                        case 5:
                            //查询余额
                            ps.queryBalance(user,UserInfo);
                            System.out.println("*********************");
                            break;
                        case 6:
                            System.out.println("退出中");
                            TSUtility.loadSpecialEffects();
                            flag = false;
                            System.out.println("*********************");
                            break;
                        default:
                            System.out.println("，您输入的有误，请重新输入（1-5）!!!");
                            break;

                    }
                }
            }
        }
    }

    public void InterfaceSelection() {
        System.out.println("****************************🐱");
        System.out.println("***   <个人信息管理界面>    ***");
        System.out.println("***         （:          ***🐱");
        System.out.println("****************************🐱");
        System.out.println("1(个人信息查看)");
        System.out.println("2(个人信息修改)");
        System.out.println("3(密码修改)");
        System.out.println("4(查询信用等级)");
        System.out.println("5(查询余额)");
        System.out.println("6(退出)");
        System.out.println("请输入你需要进行的操作：");
    }

    //选择界面
    public void revise() {
        System.out.println("********************🐱");
        System.out.println("***   <修改界面>   ***");
        System.out.println("***     （:      ***🐱");
        System.out.println("********************🐱");
        System.out.println("1(修改年龄)");
        System.out.println("2(修改性别)");
        System.out.println("3(修改手机号)");
        System.out.println("4(修改所在院系)");
        System.out.println("5(不修改，退出)");
        System.out.println("请输入你需要修改的个人信息：");
    }
}

（3）兼职申请功能：包括兼职信息查询、申请工作和结束工作。用户登录成功之后，可以查询所有的兼职信息，包括自己能申请的职位和不能申请的职位，也可以只查看自己能申请的职位（是否可申请与信用等级、岗位所需人员、兼职时间相关）。用户还可查看自己已完成的兼职信息和自己正在完成的兼职信息。满足条件的兼职，用户可以申请，开始工作时间为系统当前时间，相对的该兼职岗位对应的所需人员需要减少；完成工作后（逾期完成信用自动降低1级，0级为最低，0级后不可再申请兼职工作），需要计算所得薪酬（所得薪酬和是否逾期、逾期天数相关），若未逾期且信用等级未满，则需要计算恢复信用等级所需的次数，完成时间手动输入，不可小于兼职开始时间。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）

package wedu.service;

import wedu.dao.ApplyJob;
import wedu.dao.Job;
import wedu.dao.User;
import wedu.util.IOUtils;
import wedu.util.TSUtility;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;

/**
 * @author BaBa
 * @Version 1/0
 * 兼职申请功能业务层
 * 包括兼职信息查询、申请工作和结束工作。用户登录成功之后，可以查询所有的兼职信息，
 * 包括自己能申请的职位和不能申请的职位，也可以只查看自己能申请的职位（是否可申请与信用等级、岗位所需人员、兼职时间相关）。
 * 用户还可查看自己已完成的兼职信息和自己正在完成的兼职信息。满足条件的兼职，用户可以申请，开始工作时间为系统当前时间，
 * 相对的该兼职岗位对应的所需人员需要减少；完成工作后（逾期完成信用自动降低1级，0级为最低，0级后不可再申请兼职工作），
 * 需要计算所得薪酬（所得薪酬和是否逾期、逾期天数相关），若未逾期且信用等级未满，则需要计算恢复信用等级所需的次数，完成时间手动输入，
 * 不可小于兼职开始时间。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
 */
public class ApplyPartTimeService {



    //个人兼职信息查询(Personal part-time information inquiry)(1)
    public void inquiry(User user, String UserJob) throws IOException, ClassNotFoundException {
        boolean flag = true;
        File file = new File(UserJob);//用户工作的txt路径创建对象
        //判断里面内容是否为空
        if (file.length() == 0) {
            System.out.println("现在没有申请的兼职记录信息，请先申请！！！");
        } else if (file.length() != 0) {
            Object o = IOUtils.myDeserializable(UserJob);
            ArrayList<ApplyJob> applyJobArrayList = (ArrayList<ApplyJob>) o ;
            //拿取到每一个信息和用户的ID匹配，如果有就展示其兼职信息
            for (ApplyJob applyJob : applyJobArrayList) {
                if (user.getUID().equals(applyJob.getUID())) {
                    flag = false;
                    System.out.println(applyJob);
                }
            }
            //如果没有就显示，没有兼职记录信息，通过flag来判断
            if (flag) {
                System.out.println("未查询到兼职记录！");
            }
        }
    }

    //申请工作
    public void applyJob(User user, String JobInfo, String UserJob,String UserInfo) throws IOException, ClassNotFoundException, InterruptedException {
        Object o = IOUtils.myDeserializable(JobInfo);
        ArrayList<Job> jobs = (ArrayList<Job>) o;
        boolean flag = true;
        while (flag) {
            System.out.println("****************************");
            System.out.println("1(查询所有的职位信息)");
            System.out.println("2(仅查询当前能申请的职位信息)");
            System.out.println("3(申请职位)");
            System.out.println("4(退出)");
            System.out.println("请输入你需要进行的操作：");
            int options = TSUtility.readInt();
            switch (options) {
                case 1:
                    //查询所有的职位信息
                    if (jobs != null) {
                        for (Job job : jobs) {
                            System.out.println(job);
                        }
                    } else {
                        System.out.println("当前没有任何兼职，请联系管理员！！！");
                    }
                    break;
                case 2:
                    if (jobs != null) {
                        //仅查询当前能申请的职位信息(兼职等级小于等于用户的信誉等级就可以申请，大于的就不能)
                        for (Job job : jobs) {
                            if (job.getJob_level() <= user.getCredit_rating()) {
                                System.out.println(job);
                            }
                        }
                    } else {
                        System.out.println("当前没有任何兼职，请联系管理员！！！");
                    }
                    break;
                case 3:
                    if (jobs != null) {
                        //申请兼职
                        applyPosition(jobs, user, JobInfo, UserJob,UserInfo);
                    } else {
                        System.out.println("当前没有任何兼职，请联系管理员！！！");
                    }
                    break;
                case 4:
                    System.out.println("退出中");
                    TSUtility.loadSpecialEffects();
                    flag = false;
                    break;
                default:
                    System.out.println("你输入的有误，请重新输入（1-4）！！！");
                    break;
            }
        }
    }

    //申请职位(Apply for a position)
    public void applyPosition(ArrayList<Job> jobs, User user, String JobInfo, String UserJob,String UserInfo) throws IOException, ClassNotFoundException {
        ApplyJob applyJob = new ApplyJob();
        Object o = IOUtils.myDeserializable(UserInfo);
        ArrayList<User> users = (ArrayList<User>) o;
        ArrayList<ApplyJob> applyJobs1 = new ArrayList<>();
        for (User user1:users) {
                if (user1.getUID().equals(user.getUID())) {
                    boolean flag = true;
                    System.out.println("请输入您申请工作的营业执照编号：");
                    String jid = TSUtility.readKeyBoard(18, false);
                    for (Job job : jobs) {
                        if (user.getCompleteNumber() == 1) {
                            System.out.println("您当前已有工作，请勿再接工作，谢谢！！");
                        } else {
                            //通过比对输入的和文件里对应的编号是否一样，再进行下一步操作
                            if (jid.equals(job.getJID())) {
                                flag = false;
                                //要求其兼职等级小于等于其信用等级并且要求的人数大于0才能录用
                                if (job.getJob_level() <= user1.getCredit_rating() && job.getJob_demand() > 0) {
                                    //录用的话，其人数需要减1
                                    job.setJob_demand(job.getJob_demand() - 1);
                                    IOUtils.mySerializable(jobs, JobInfo);
                                    //分别把编号和营业执照编号放到其中
                                    applyJob.setUID(user1.getUID());
                                    applyJob.setJID(job.getJID());
                                    Date date = new Date();
                                    applyJob.setWork_start(date);
                                    //当前时间加上你想要上班的时间，就是最终时间
                                    applyJob.setWork_end(new Date(date.getTime() + job.getJob_time() / 24L / 60 / 60 / 1000));
                                    applyJob.setWork_state("false");
                                    applyJob.setCompleteNumber(1);
                                    user1.setCompleteNumber(1);
                                    applyJobs1.add(applyJob);
                                    //将信息写入到文本中

                                    System.out.println("申请该工作成功！！！");
                                    break;
                                } else {
                                    System.out.println("条件不符合，申请失败");
                                }
                            }
                        }
                    }
                    if (flag) {
                        System.out.println("该营业执照编号不存在！");
                    }
                }
        }
        IOUtils.mySerializable(applyJobs1, UserJob);
        IOUtils.mySerializable(users, UserInfo);
    }

    //结束工作
    public void endJob(User user, String JobInfo, String UserInfo, String UserJob) throws IOException, ClassNotFoundException {
        Object o = IOUtils.myDeserializable(JobInfo);
        ArrayList<Job> jobs = (ArrayList<Job>) o;
        Object obj = IOUtils.myDeserializable(UserInfo);
        ArrayList<User> users = (ArrayList<User>) obj;
        Object ob = IOUtils.myDeserializable(UserJob);
        ArrayList<ApplyJob> userjobs = (ArrayList<ApplyJob>) ob;
        ArrayList<ApplyJob> arrayList = new ArrayList<>();
        File file = new File(UserJob);
        if (file.length()!=0||!file.exists()) {
            //遍历每一个用户
            for (User user1 : users) {
                //找到用户登录的id
                if (user1.getUID().equals(user.getUID())) {
                    //遍历所有工作
                    for (Job job : jobs) {
                        //遍历申请的工作
                        for (ApplyJob userjob : userjobs) {
                            //找到用户申请的工作
                            if (job.getJID().equals(userjob.getJID())) {
                                //设置实际工作时间
                                Date date = new Date();
                                //通过预期结束时间和当前时间相比较（before()方法:当前面的时间早于后面的时间时返回true,否则返回false.），
                                如果结束时间在当前时间之前，且状态没有变为完成，则逾期
                                if (userjob.getWork_end().after(date) && userjob.getWork_state().equals("false")) {
                                    //拿到结束时间
                                    Date endTime = userjob.getWork_end();
                                    //获取相差时间
                                    long day = date.getTime() / 24L / 60 / 60 / 1000 - endTime.getTime() / 24L / 60 / 60 / 1000;//这里的时间大于零
                                    //如果逾期一次，信用等级下降一次
                                    user1.setCredit_rating(user1.getCredit_rating() - 1);
                                    //逾期后需要把工资加到余额里面，然后再扣除其逾期的金额
                                    user1.setBalance(user1.getBalance() + job.getJobtype().getSalary());
                                    userjob.setCompleteNumber(0);
                                    user1.setCompleteNumber(0);
                                    System.out.println("本次工作超时：" + day + "完成，收入为：" + (user1.getBalance() - day * job.getJobtype().getDeduct_salary()));
                                    break;
                                }
                                //不逾期
                                else {
                                    userjob.setWork_state("true");
                                    Date startTime = userjob.getWork_start();
                                    Date endTime = userjob.getWork_end();
                                    long day = endTime.getTime() / 24L / 60 / 60 / 1000 - startTime.getTime() / 24L /60 / 60 / 1000;
                                    userjob.setCompleteNumber(0);
                                    arrayList = userjobs;
                                    user1.setCompleteNumber(0);
                                    System.out.println("收入：" + (user1.getBalance() + job.getJobtype().getSalary()));
                                }
                            }
                            //如果工作结束了，就需要将列表里面的内容删除
                            if (!arrayList.isEmpty()) {
                                userjobs.remove(arrayList);
                                IOUtils.mySerializable(userjobs, UserJob);
                                break;
                            }
                        }
                    }
                }
            }
        }
        else {
            System.out.println("当前您没有申请工作！！！！");
        }
        IOUtils.mySerializable(users,UserInfo);
        IOUtils.mySerializable(userjobs,UserJob);

    }
}

（4）基本信息维护功能：包括兼职等级设置、用户信用调整和逾期费用扣除比例调整。管理员端登录成功之后，可以调整兼职的等级（兼职等级梯度为一-五级，五级最高，一级最低），普通用户的信用等级>=兼职等级可申请职位，还可以增删兼职的类型，比如开发外包/销售/设计师等。管理员可以根据用户的表现动态地调整用户的信用等级，可越级增减，0级信用的普通用户管理员不可调整其信用等级。管理员还可以调整兼职的逾期费用，每天逾期扣除的费用相同，比如：原定一份兼职总薪资1000元，工作要求10天完成，逾期1天扣除100元，调整后一天扣除200元（扣除兼职费用为0后继续扣除用户余额，直到用户余额为<=0，自动结束工作，结算费用）。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）

package wedu.service;

import wedu.dao.Job;
import wedu.dao.User;
import wedu.util.IOUtils;
import wedu.util.TSUtility;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;

/**
 * @author BaBa
 * @Version 1/0
 * 基本信息维护业务层
 * 包括兼职等级设置、用户信用调整和逾期费用扣除比例调整。管理员端登录成功之后，
 * 可以调整兼职的等级（兼职等级梯度为一-五级，五级最高，一级最低），普通用户的信用等级>=兼职等级可申请职位，
 * 还可以增删兼职的类型，比如开发外包/销售/设计师等。管理员可以根据用户的表现动态地调整用户的信用等级，可越级增减，
 * 0级信用的普通用户管理员不可调整其信用等级。管理员还可以调整兼职的逾期费用，每天逾期扣除的费用相同，
 * 比如：原定一份兼职总薪资1000元，工作要求10天完成，逾期1天扣除100元，
 * 调整后一天扣除200元（扣除兼职费用为0后继续扣除用户余额，直到用户余额为<=0，自动结束工作，结算费用）。
 * （相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
 */
public class ReleaseService {
    //兼职等级设置
    public void partTimeLevelSetting(String JobInfo) throws IOException, ClassNotFoundException {
        boolean flag = true;
        Object o = IOUtils.myDeserializable(JobInfo);
        ArrayList<Job> jobs = (ArrayList<Job>) o;
        System.out.println("请输入需设置兼职等级的营业执照编号：");
        String jid = TSUtility.readKeyBoard(18, false);
        //遍历每个工作
        for (Job job : jobs) {
            //通过比对编号，找到对应需要设置等级的工作
            if (jid.equals(job.getJID())) {
                //找到相应的编号证明该工作存在
                flag = false;
                while (true) {
                    System.out.println("请输入调整后的兼职等级(数字)：");
                    int level = TSUtility.readInt();
                    //使用正则判断，对于level
                    boolean b = TSUtility.levelRegularJudgement("" + level);
                    if (b) {
                        //先判断设置的等级是否等于先前的等级
                        if (level != job.getJob_level()) {
                            //如果不等，则设置进去
                            job.setJob_level(level);
                            //再写入到文件中
                            IOUtils.mySerializable(job, JobInfo);
                            System.out.println("兼职等级设置成功！");
                            break;
                        }
                        //如果等于，则返回重新输入
                        else {
                            System.out.println("兼职等级与原来一致，请重新输入（1-5）：");
                        }
                    } else {
                        System.out.println("输入错误，请重新输入（1-5）：");
                    }
                }
            }
        }
        //如果没有找到，则显示未找到
        if (flag) {
            System.out.println("找不到该兼职信息，兼职等级设置失败！");
        }
    }

    //用户信用调整
    public void CreditAdjustments(String UserInfo) throws IOException, ClassNotFoundException {
        boolean flag = true;
        Object obj = IOUtils.myDeserializable(UserInfo);
        ArrayList<User> users = (ArrayList<User>) obj;
        //遍历每个用户
        for (User user : users) {
            System.out.println("请输入需调整用户信用的用户编号：");
            String uid = TSUtility.readKeyBoard(4, false);
            if (uid.equals(user.getUID())) {
                //如果用户信用为0，则不可调整
                if (user.getCredit_rating() == 0) {
                    System.out.println("该用户信用为0，不可调整！");
                } else {
                    flag = false;
                    System.out.println("请输入调整后的用户信用等级：");
                    while (true) {
                        int level = TSUtility.readInt();
                        boolean b = TSUtility.levelRegularJudgement("" + level);
                        if (b) {
                            //如果设置等级不等于先前等级
                            if (level != user.getCredit_rating()) {
                                user.setCredit_rating(level);
                                //写入到文档中
                                IOUtils.mySerializable(user, UserInfo);
                                System.out.println("用户信用调整成功！");
                                break;
                            } else {
                                System.out.println("用户信用等级与原来一致，请重新输入（1-5）:");
                            }
                        } else {
                            System.out.println("输入错误，请重新输入（1-5）：");
                        }
                    }
                }
            }
        }
        //如果没找到，则显示没找到
        if (flag) {
            System.out.println("找不到该用户信息，调整用户信用失败！");
        }
    }

    //逾期费用调整
    public void proportion(String JobInfo) throws IOException, ClassNotFoundException {
        boolean flag = true;
        Object o = IOUtils.myDeserializable(JobInfo);
        ArrayList<Job> jobs = (ArrayList<Job>) o;
        System.out.println("请输入你需设置兼职等级的营业执照编号：");
        String jid = TSUtility.readKeyBoard(18, false);
        //遍历每个工作
        for (Job job : jobs) {
            //对比其营业执照编号
            if (jid.equals(job.getJID())) {
                flag = false;
                while (true) {
                    System.out.println("请输入逾期费用：");
                    double dect = TSUtility.readDouble();
                    if (dect > 0) {
                        job.getJobtype().setDeduct_salary(dect);
                        System.out.println("逾期费用调整成功！");
                        break;
                    } else {
                        System.out.println("您输入的有误，请重新输入！！！");
                    }
                }
            }
        }
        IOUtils.mySerializable(jobs, JobInfo);
        if (flag) {
            System.out.println("找不到该兼职信息，调整逾期费用扣除比例调失败！");
        }
    }
}

（5）兼职信息投放：包括兼职人员设置、兼职的金额设置、兼职的时间录入以及兼职的其他信息录入。系统管理员登录成功之后可以把所有公司发布的兼职信息录入到平台，录入信息包括：营业执照编号、公司名字、岗位名称、兼职类型、兼职等级、工作内容、需求人数、工作时间等。系统管理员可以根据市场和公司要求，动态调整这些兼职工作的部分内容，比如需求人数、薪水等，工作时间不允许更改。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）

package wedu.service;

import wedu.dao.Job;
import wedu.dao.JobType;
import wedu.util.IOUtils;
import wedu.util.TSUtility;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author BaBa
 * @Version 1/0
 * 兼职信息投放业务层
 * 包括兼职人员设置、兼职的金额设置、兼职的时间录入以及兼职的其他信息录入。
 * 系统管理员登录成功之后可以把所有公司发布的兼职信息录入到平台，录入信息包括：营业执照编号、公司名字、岗位名称、兼职类型、兼职等级、工作内容、需求人数、工作时间等。
 * 系统管理员可以根据市场和公司要求，动态调整这些兼职工作的部分内容，比如需求人数、薪水等，工作时间不允许更改。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
 */
public class PartTimeDeliveryService {
    //添加兼职
    public void AddInformation(String JobInfo) throws IOException, ClassNotFoundException {
        File file = new File(JobInfo);
        ArrayList<Job> jobs = new ArrayList<Job>();
        Job job = new Job();
        JobType jobType = new JobType();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入营业执照编号：");
        String jid = TSUtility.readKeyBoard(18, false);
        System.out.println(file.length());
        if (file.length() != 0) {
            Object o = IOUtils.myDeserializable(JobInfo);
            jobs = (ArrayList<Job>) o;
            for (Job job1 : jobs) {
                if (!jid.equals(job1.getJID())) {
                    job.setJID(jid);
                    System.out.println("请输入公司名字：");
                    job.setCompany_name(TSUtility.readKeyBoard(12, false));
                    System.out.println("请输入岗位名称：");
                    job.setJob_name(TSUtility.readKeyBoard(12, false));
                    System.out.println("请输入兼职等级");
                    while (true) {
                        String level = TSUtility.readKeyBoard(1, false);
                        boolean b = TSUtility.levelRegularJudgement(level);
                        if (b) {
                            job.setJob_level(Integer.parseInt(level));
                            break;
                        } else {
                            System.out.println("输入错误，请重新输入（1-5）：");
                        }
                    }
                    System.out.println("请输入工作内容：");
                    job.setJob_content(TSUtility.readKeyBoard(50, false));

                    boolean b = true;
                    while (b) {
                        System.out.println("请输入需求人数：");
                        int num = sc.nextInt();
                        if (num > 0) {
                            job.setJob_demand(num);
                            b = false;
                        } else {
                            System.out.println("人数必须大于零，请重新输入！！");
                        }
                    }
                    System.out.println("请输入工作时间：");
                    while (true) {
                        String time = sc.next();
                        boolean b1 = TSUtility.timeRegularJudgement(time);
                        if (b1) {
                            job.setJob_time(Integer.parseInt(time));
                            break;
                        } else {
                            System.out.println("输入错误，请重新输入（1-365）：");
                        }
                    }
                    job.setJob_state("false");
                    System.out.println("请输入兼职类型编号：");
                    jobType.setJTID(TSUtility.readKeyBoard(16, false));
                    System.out.println("请输入兼职类型名称：");
                    jobType.setJobtype_name(TSUtility.readKeyBoard(10, false));
                    System.out.println("请输入薪水");
                    jobType.setSalary(TSUtility.readDouble());
                    System.out.println("请输入逾期费用：");
                    jobType.setDeduct_salary(TSUtility.readDouble());
                    job.setJobtype(jobType);
                    jobs.add(job);

                    System.out.println("发布兼职信息成功！！");
                    break;
                } else {
                    System.out.println("营业执照编号已近存在，请重新输入！！！！");
                }
            }
            IOUtils.mySerializable(jobs, JobInfo);
        } else {
            job.setJID(jid);
            System.out.println("请输入公司名字：");
            job.setCompany_name(TSUtility.readKeyBoard(12, false));
            System.out.println("请输入岗位名称：");
            job.setJob_name(TSUtility.readKeyBoard(12, false));
            System.out.println("请输入兼职等级");
            while (true) {
                String level = TSUtility.readKeyBoard(1, false);
                boolean b = TSUtility.levelRegularJudgement(level);
                if (b) {
                    job.setJob_level(Integer.parseInt(level));
                    break;
                } else {
                    System.out.println("输入错误，请重新输入（1-5）：");
                }
            }
            System.out.println("请输入工作内容：");
            job.setJob_content(TSUtility.readKeyBoard(50, false));

            boolean b = true;
            while (b) {
                System.out.println("请输入需求人数：");
                int num = sc.nextInt();
                if (num > 0) {
                    job.setJob_demand(num);
                    b = false;
                } else {
                    System.out.println("人数必须大于零，请重新输入！！");
                }
            }
            System.out.println("请输入工作时间：");
            while (true) {
                String time = sc.next();
                boolean b1 = TSUtility.timeRegularJudgement(time);
                if (b1) {
                    job.setJob_time(Integer.parseInt(time));
                    break;
                } else {
                    System.out.println("输入错误，请重新输入（1-365）：");
                }
            }
            job.setJob_state("false");
            System.out.println("请输入兼职类型编号：");
            jobType.setJTID(TSUtility.readKeyBoard(16, false));
            System.out.println("请输入兼职类型名称：");
            jobType.setJobtype_name(TSUtility.readKeyBoard(10, false));
            System.out.println("请输入薪水");
            jobType.setSalary(TSUtility.readDouble());
            System.out.println("请输入逾期费用：");
            jobType.setDeduct_salary(TSUtility.readDouble());
            job.setJobtype(jobType);
            jobs.add(job);
            System.out.println("发布兼职信息成功！！");

        }
        IOUtils.mySerializable(jobs, JobInfo);
    }
}

（6）系统管理功能：包括对普通用户、管理员和兼职信息的增删查改等。系统提前录入了一些管理员或者学生的信息在系统中，但是未全部录入，所以后续需要注册的用户需要已经录入的管理员登录平台进行信息录入，系统录入仅需要学号/教师编号和姓名即可，此信息供用户注册使用。管理员可以删除普通用户和别的管理员，以及没有用的兼职信息。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）

package wedu.view;

import wedu.dao.User;
import wedu.service.PersonalInformationService;
import wedu.service.SystemManageService;
import wedu.util.IOUtils;
import wedu.util.TSUtility;

import java.io.IOException;
import java.util.ArrayList;

/**
 * @author BaBa
 * @Version 1/0
 * 系统管理视图层
 */
public class SystemManageView {
    SystemManageService systemManageService = new SystemManageService();
    PartTimeDeliveryView partTimeDeliveryView = new PartTimeDeliveryView();
//    PersonalInformationService personalInformationService = new PersonalInformationService();
    //系统管理主要选择界面
    public void choose(String JobInfo,String UserInfo,String UserJob,String Users) throws InterruptedException, IOException, ClassNotFoundException {
        boolean flag = true;
        while (flag) {
            //系统管理主要界面
            System.out.println("****************************🐱");
            System.out.println("***     <系统管理界面>     ***");
            System.out.println("***         （:          ***🐱");
            System.out.println("****************************🐱");
            System.out.println("1(用户信息管理)");
            System.out.println("2(管理员信息管理)");
            System.out.println("3(兼职信息管理)");
            System.out.println("4(退出)");
            System.out.println("请输入你需要进行的操作：");
            int options1 = TSUtility.readInt();
            switch (options1) {
                case 1:
                    //用户信息管理
                    choose2(Users,UserInfo,UserJob);
                    break;
                case 2:
                    //管理员信息管理
                    choose3(Users,UserInfo);
                    break;
                case 3:
                    //兼职信息管理
                    choose4(JobInfo,UserJob);
                    break;
                case 4:
                    System.out.println("退出中");
                    TSUtility.loadSpecialEffects();
                    flag = false;
            }
        }
    }

    //用户信息管理选择操作界面
    public void choose2(String Users,String UserInfo,String UserJob) throws InterruptedException, IOException, ClassNotFoundException {
        boolean flag = true;
        while (flag) {
            System.out.println("****************************🐱");
            System.out.println("***  <用户注册信息管理界面> ***");
            System.out.println("***         （:          ***🐱");
            System.out.println("****************************🐱");
            System.out.println("1(增加注册用户)");
            System.out.println("2(删除注册用户)");
            System.out.println("3(修改用户注册信息)");
            System.out.println("4(查询用户信息)");
            System.out.println("5(退出)");
            System.out.println("请输入你需要进行的操作：");
            int options = TSUtility.readInt();
            switch (options) {
                case 1:
                    //增加注册用户
                    systemManageService.AddUser(Users);
                    break;
                case 2:
                    //删除注册用户
                    systemManageService.DelectUser(Users, UserInfo,UserJob);
                    break;
                case 3:
                    //修改用户注册信息
                    systemManageService.ReviseInfo(UserInfo);
//                    personalInformationService.revisePassword(user,UserInfo);
                    break;
                case 4:
                    //查询用户信息
                    systemManageService.InquireInfo(UserInfo);
                    break;
                case 5:
                    System.out.println("退出中");
                    TSUtility.loadSpecialEffects();
                    flag = false;
                    break;
                default:
                    System.out.println("，您输入的有误，请重新输入（1-5）!!!");
                    break;
            }
        }
    }

    //管理员信息管理操作界面
    public void choose3(String Users,String UserInfo) throws InterruptedException, IOException, ClassNotFoundException {
        boolean flag = true;
        while (flag) {
            System.out.println("****************************🐱");
            System.out.println("***   <管理员信息管理界面>   ***");
            System.out.println("***         （:          ***🐱");
            System.out.println("****************************🐱");
            System.out.println("1(增加管理员)");
            System.out.println("2(删除注册管理员)");
            System.out.println("3(修改管理员信息)");
            System.out.println("4(查询管理员信息)");
            System.out.println("5(退出)");
            System.out.println("请输入你需要进行的操作：");
            int options = TSUtility.readInt();
            switch (options) {
                case 1:
                    //增加管理员
                    systemManageService.AddAdministrator(Users);
                    break;
                case 2:
                    //删除管理员
                    systemManageService.DelectAdministrator(Users, UserInfo);
                    break;
                case 3:
                    //修改管理员信息
                    systemManageService.ReviseAdminInfo(UserInfo);
                    break;
                case 4:
                    //查询管理员信息
                    systemManageService.InquireAdminInfo(UserInfo);
                    break;
                case 5:
                    System.out.println("退出中");
                    TSUtility.loadSpecialEffects();
                    flag = false;
                    break;
            }
        }
    }

    //兼职信息管理选项界面
    public void choose4(String JobInfo,String UserJob) throws InterruptedException, IOException, ClassNotFoundException {
        boolean flag = true;
        while (flag) {
            System.out.println("****************************🐱");
            System.out.println("***   <兼职信息管理界面>    ***");
            System.out.println("***         （:          ***🐱");
            System.out.println("****************************🐱");
            System.out.println("1(增加兼职信息)");
            System.out.println("2(删除兼职信息)");
            System.out.println("3(修改兼职信息)");
            System.out.println("4(查询兼职信息)");
            System.out.println("5(退出)");
            System.out.println("请输入你需要进行的操作：");
            int options = TSUtility.readInt();
            switch (options) {
                case 1:
                    //增加兼职信息
                    partTimeDeliveryView.choose(JobInfo);
                    break;
                case 2:
                    //删除兼职信息
                    systemManageService.DelectPartTime(JobInfo,UserJob);
                    break;
                case 3:
                    //修改兼职信息
                    systemManageService.ModifyPartTimeInformation(JobInfo);
                    break;
                case 4:
                    //查询兼职信息
                    systemManageService.checkPartTime(UserJob,JobInfo);
                    break;
                case 5:
                    System.out.println("退出中");
                    TSUtility.loadSpecialEffects();
                    flag = false;
                    break;
                default:
                    System.out.println("，您输入的有误，请重新输入（1-5）!!!");
                    break;
            }
        }
    }

}

这里总结一下个人心得：
第一：各个模块之间数据传输，结合其IO流的关系，就设计到了转换类型以及空指针的异常，我的遗漏是，通过主界面的传参user在所有关系中只作为其对比作用，其更改的时候好是需要序列化和反序列化，这样的步骤必须要，我就是因为这个步骤卡了五六天，以下是主界面。

package wedu.view;

import wedu.dao.User;
import wedu.util.IOUtils;
import wedu.util.TSUtility;

import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;

/**
 * @author BaBa
 * @Version 1/0
 * 主界面
 */
public class IndexView {
    private static final String JobInfo = "D:\\编程\\IDEA\\IdeaProjects\\Probject2\\files\\JobInformation.txt";//工作信息文本路径
    private static final String Users = "D:\\编程\\IDEA\\IdeaProjects\\Probject2\\files\\User.txt";//用户文本路径
    private static final String UserInfo = "D:\\编程\\IDEA\\IdeaProjects\\Probject2\\files\\UserInformation.txt";//用户申请工作文本路径
    private static final String UserJob = "D:\\编程\\IDEA\\IdeaProjects\\Probject2\\files\\UserJob.txt";//用户兼职文本路径
    public static User user = new User();

    public static void main(String[] args) throws IOException, ParseException, ClassNotFoundException, InterruptedException {
        LoginView loginView = new LoginView();//登录注册
        PersonalInformationView PIV = new PersonalInformationView();//个人信息
        ApplyPartTimeView APV = new ApplyPartTimeView();//兼职申请
        SystemManageView SMV = new SystemManageView();//系统管理
        Release release = new Release();//基本信息维护
        PartTimeDeliveryView partTimeDeliveryView = new PartTimeDeliveryView();//兼职信息投放

        //欢迎界面
        Welcome();
        boolean b = true;
        while (b) {
            System.out.println("请输入您的选项：");
            System.out.println("1. 登录注册");
            System.out.println("2. 退出");
            int option = TSUtility.readInt();
            switch (option) {
                case 1:
                    User user = loginView.LoginScreen();
                    boolean loopFlag = true;
                    ArrayList<User> arrayList = new ArrayList<>();
                    File file = new File(UserInfo);
                    if (file.length()!=0||!file.exists()){
                        Object o = IOUtils.myDeserializable(UserInfo);
                        arrayList = (ArrayList<User>) o;
                    }
                    for (User user1:arrayList) {
                        if (user1.getUID().equals(user.getUID())) {
                            while (loopFlag) {
                                //主菜单界面
                                MainMenu();
                                int options = TSUtility.readInt();
                                switch (options) {
                                    case 1:
                                        //个人信息管理
                                        PIV.revise(user, UserInfo);
                                        break;
                                    case 2:
                                        //兼职申请
                                        APV.choose(user, UserJob, JobInfo, UserInfo);
                                        break;
                                    case 3:
                                        //基本信息维护（仅管理员）
//                    for (User user1:arrayList) {
                                        if (Integer.parseInt(user1.getUID()) / 10 / 10 / 10 % 10 == 2) {
                                            release.choose(JobInfo, UserInfo);
                                        } else {
                                            System.out.println("您不是管理员");
                                        }
//                    }
                                        break;
                                    case 4:
                                        //兼职信息投放（仅管理员）
                                        if (Integer.parseInt(user1.getUID()) / 10 / 10 / 10 % 10 == 2) {
                                            partTimeDeliveryView.choose(JobInfo);
                                        } else {
                                            System.out.println("您不是管理员");
                                        }
                                        break;
                                    case 5:
                                        //系统管理（仅管理员）
                                        if (Integer.parseInt(user1.getUID()) / 10 / 10 / 10 % 10 == 2) {
                                            SMV.choose(JobInfo, UserInfo, UserJob, Users);
                                        } else {
                                            System.out.println("您不是管理员");
                                        }
                                        break;
                                    case 6:
                                        System.out.print("确认是否返回登录注册(Y/N)：");
                                        char yn = TSUtility.readConfirmSelection();
                                        if (yn == 'Y') {
                                            loopFlag = false;
                                        }
                                        break;
                                }
                            }
                            break;
                        }
                    }
                    break;
                case 2:
                    b = false;
                    System.out.println("退出中！！");
                    break;
                default:
                    System.out.println("您输入的有误！！！");
                    break;
            }
        }

    }

    //欢迎界面
    public static void Welcome() {
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🔣                                        🔣");
        System.out.println("🔣         欢迎来到校园兼职平台软件          🔣");
        System.out.println("🔣                                        🔣");
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🐕");
        System.out.println("🐕");
        System.out.println("🐕");
        System.out.println("🐕-----------<请您先进行登录>-------------🐕");
        TSUtility.readReturn();
    }

    //主菜单界面
    public static void MainMenu() {
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🔣                                  🔣");
        System.out.println("🔣            ~软件主菜单~            🔣");
        System.out.println("🔣                                  🔣");
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🐻1. <个人信息管理>                *");
        System.out.println("🐘2. <兼职申请>                   *");
        System.out.println("🦁3. <基本信息维护（仅管理员）>      *");
        System.out.println("🐖4. <兼职信息投放（仅管理员）>      *");
        System.out.println("🐱5. <系统管理（仅管理员）>         *");
        System.out.println("🦊6. <返回登录注册>                   *");
        System.out.println("⬇请选择：");
    }
}

第二：需要在登录注册的时候注意其逻辑的判断，注册过的用户无法再次注册，以及两个不同的文件之间用的是Properties和ArrayList得我选择，以及再删除用户，增加兼职和删除兼职，管理员的逻辑操作，就比如，删除用户的时候要把其对应的兼职工作删除，我这里用了一个中间值设置了其能接手的兼职数（每个用户只能接1个兼职）…

这里面的心酸，只有我自己知道，为时两个星期，真就做了两个星期，看到这里也好运赞三连，下面是代码源码。

https://www.aliyundrive.com/s/Z4yiKLZoGF4
提取码：x7f3