校园兼职平台

不念不忘少年蓝@ 2024-04-07 14:58 62阅读 0赞

#### **【项目前提】** ####

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

#### **【项目说明】** ####

1.  据了解，目前在校大学生80%以上有做兼职的需求，兼职打工已经不仅仅是经济困难的学生赚取生活费用的途径。调查显示，全球经济危机对就业产生冲击，用人单位对人员的社会实践能力要求提高，大学期间必要的社会实践既可以提高能力，又为适应社会，减轻家庭经济负担起到了积极的作用；社会中虚假兼职机构、欺骗性中介机构充斥，真伪难辨，学生受骗事件频发，极大的损害了学生的经济利益，甚至对学生的人生安全造成威胁。从校园踏入社会，兼职只是一段小小的插曲，通过兼职丰富阅历、增长社会经验固然是好事，可是毫无戒备的步入社会，不仅会事与愿违，还可能造成不必要的损所以。所以，我们需求设计一个校园兼职平台来方便在校学生找兼职。
2.  本平台根据角色定位不同有不同的模块，首先系统有一个登录注册模块，属于兼职人员的模块有个人信息管理和兼职申请；属于管理员的模块有基本信息维护、兼职信息投放和系统管理。
3.  平台登录注册：用户可以通过账号密码登录平台，如果用户是第一次使用该平台，则可以通过注册方式完成信息录入。平台根据用户输入的账号密码，判断该用户的角色是兼职人员还是管理员，展示不同的操作界面。如果用户忘记密码，可以通过自己的账号和注册时录入的真实姓名找回密码。
4.  个人信息管理：能够对用户的基本信息进行管理，包括个人信息的修改，如学生转到别的专业，此时要修改学生的基本信息；修改密码，为了账户的安全性，可以修改用户的密码。查询信用等级，比如有一个用户一开始可以完成兼职等级最高的工作，但是在这次工作中，未能按时完成工作，于是管理员降低了该用户的信用等级，该用户就不能接高级的兼职工作了。查询余额，用户每次按时完成兼职能得到一笔费用，有逾期会扣除一部分佣金，最后得到总的余额。
5.  兼职申请模块：用户能够查询所有的职位信息，因为信用等级的限制，用户也可以只查询自己能够申请的职位信息。查询到合适的职位用户可以直接申请，申请后到达工作截至时间前完成工作可以提前结束工作得到佣金，如果逾期后完成，管理员会调整用户的信用等级。用户可以查询自己已经完成过的兼职信息和自己正在完成的兼职信息。
6.  基本信息维护模块：管理员能够根据用户完成兼职的情况动态的调整用户的兼职等级状态。管理员可以调整兼职的等级，供用户选择。管理员能够根据兼职的等级不同设置逾期费用扣除比例，比如最高级的兼职逾期一天扣10元，扣除兼职费用后继续扣除用户余额，直到用户余额为0，自动结束工作，结算费用。
7.  兼职信息投放：管理员可以把所有公司的兼职招聘信息发布到网上，根据公司的需求设置岗位所需人员，工资以及兼职的时间段，比如发传单，这份兼职需要周一到周五的上午9点至11点工作，那么在这个时间段已经有了其他工作的用户就不能申请该工作。
8.  系统管理模块：管理员能够删除管理员账户，也能删除平台用户以及一些完成过的兼职信息。管理员能够添加平台用户信息到系统，本平台是针对学生的软件，所以能够注册的只能是学生，所以平台需要提前将学生信息录入系统，用户才能注册账号，如果未能及时录入信息照成无法注册，那么就需要联系管理员进行信息录入。管理员可以添加其他的管理员账户，为了安全起见，管理员和普通用户一样能够修改密码。管理员还能够查询所有的用户信息、管理员账户信息、已经投放的职位信息、已经完成的兼职信息和已经逾期的兼职信息。

#### **【项目内容】** ####

项目功能结构图：

![c1efae47a6914718ab3f6735b9524585.png][]

项目功能如下：

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

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

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

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

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

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

#### **【项目时长】** ####

7-14天

#### **【项目注意】** ####

1.  注意命名（类名，包名，方法名，注释等），请严格遵循Java命名规则完成项目。

参考文献：https://blog.csdn.net/yang\_best/article/details/42169549

1.  每一个业务逻辑操作需要加上日志打印功能（用I/o流实现，比如什么时候进行了增删改等操作，需要有记录，或者发现异常了也需要将信息同步在日志文件里）
2.  每个功能模块，如果有异常抛出，需要自定义异常来进行处理

#### **【参考设计】** ####

结合功能设计，设计5个实体类（或者更多）。

**用户实体**：用户编号（学号/教师编号）、密码、姓名、年龄、性别、电话、所在院系、注册日期等

**兼职信息实体**：营业执照编号、公司名字、岗位名称、兼职类型、兼职等级、工作内容、需求人数、工作时间等

**兼职类型**：兼职类型编号、兼职类型名称、薪水、逾期费用扣除比例

**普通用户账户**：账户编号、信用等级、余额

**User.java**：UID, password, username, age, sex, phone, department, regdat, credit\_rating, balance

**UserAccount**: ACID, credit\_rating, balance

**Job.java**: JID, company\_name, job\_name, jobtype\_name, job\_level, salary, deduct\_salary, job\_content, job\_demand, job\_time

**JobType.java**: JTID, salary, deduct\_salary, jobtype\_name

**ApplyJob.java**: UID, JID, work\_start, work\_end

### 部分源码： ###

#### entity包: ####

#### Job ####

package entity;
    
    import java.io.Serializable;
    
    //工作类
    public class Job implements Serializable {
        private String JID;//营业执照编号
        private String company_name;//公司名字
        private String job_name;//岗位名称
        private JobType jobType;//兼职类型
        private int job_level;//兼职等级
        private String job_content;//工作内容
        private int job_demand;//需求人数
        private int job_time;//工作时间
        private boolean state = false;//是否投放
        private boolean overdueState = false;//是否逾期
        private boolean completeState = false;//是否完成
        private static final long serialVersionUID = 42L;
    
        public Job() {
        }
    
        public Job(String JID) {
            this.JID = JID;
        }
    
        public Job(String JID, String company_name, String job_name, JobType jobType, int job_level, String job_content, int job_demand, int job_time, boolean state, boolean overdueState, boolean completeState) {
            this.JID = JID;
            this.company_name = company_name;
            this.job_name = job_name;
            this.jobType = jobType;
            this.job_level = job_level;
            this.job_content = job_content;
            this.job_demand = job_demand;
            this.job_time = job_time;
            this.state = state;
            this.overdueState = overdueState;
            this.completeState = completeState;
        }
    
        public String getJID() {
            return JID;
        }
    
        public void setJID(String JID) {
            this.JID = JID;
        }
    
        public String getCompany_name() {
            return company_name;
        }
    
        public void setCompany_name(String company_name) {
            this.company_name = company_name;
        }
    
        public String getJob_name() {
            return job_name;
        }
    
        public void setJob_name(String job_name) {
            this.job_name = job_name;
        }
    
        public JobType getJobType() {
            return jobType;
        }
    
        public void setJobType(JobType jobType) {
            this.jobType = jobType;
        }
    
        public int getJob_level() {
            return job_level;
        }
    
        public void setJob_level(int job_level) {
            this.job_level = job_level;
        }
    
        public String getJob_content() {
            return job_content;
        }
    
        public void setJob_content(String job_content) {
            this.job_content = job_content;
        }
    
        public int getJob_demand() {
            return job_demand;
        }
    
        public void setJob_demand(int job_demand) {
            this.job_demand = job_demand;
        }
    
        public int getJob_time() {
            return job_time;
        }
    
        public void setJob_time(int job_time) {
            this.job_time = job_time;
        }
    
        public boolean isState() {
            return state;
        }
    
        public void setState(boolean state) {
            this.state = state;
        }
    
        public boolean isOverdueState() {
            return overdueState;
        }
    
        public void setOverdueState(boolean overdueState) {
            this.overdueState = overdueState;
        }
    
        public boolean isCompleteState() {
            return completeState;
        }
    
        public void setCompleteState(boolean completeState) {
            this.completeState = completeState;
        }
    }

#### JobType ####

package entity;
    
    import java.io.Serializable;
    
    //兼职类型类
    public class JobType implements Serializable {
        private String JTID;//兼职类型编号
        private String jobType_name;//兼职类型名称
        private double salary;//薪水
        private double deduct_salary;//逾期扣除工资
        private static final long serialVersionUID = 42L;
    
        public JobType() {
        }
    
        public JobType(String JTID, String jobType_name, double salary, double deduct_salary) {
            this.JTID = JTID;
            this.jobType_name = jobType_name;
            this.salary = salary;
            this.deduct_salary = deduct_salary;
        }
    
        public String getJTID() {
            return JTID;
        }
    
        public void setJTID(String JTID) {
            this.JTID = JTID;
        }
    
        public String getJobType_name() {
            return jobType_name;
        }
    
        public void setJobType_name(String jobType_name) {
            this.jobType_name = jobType_name;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        public double getDeduct_salary() {
            return deduct_salary;
        }
    
        public void setDeduct_salary(double deduct_salary) {
            this.deduct_salary = deduct_salary;
        }
    }

#### ApplyJob ####

package entity;
    
    import java.io.Serializable;
    import java.util.Date;
    
    //应聘工作类
    public class ApplyJob implements Serializable {
        private String UID;
        private String JID;
        private Date work_start;
        private Date work_end;
        private static final long serialVersionUID = 42L;
    
        public ApplyJob() {
        }
    
    
        public ApplyJob(String JID) {
            this.JID = JID;
        }
    
        public ApplyJob(String UID, String JID, Date work_start) {
            this.UID = UID;
            this.JID = JID;
            this.work_start = work_start;
        }
    
        public ApplyJob(String UID, String JID, Date work_start, Date work_end) {
            this.UID = UID;
            this.JID = JID;
            this.work_start = work_start;
            this.work_end = work_end;
        }
    
        public String getUID() {
            return UID;
        }
    
        public void setUID(String UID) {
            this.UID = UID;
        }
    
        public String getJID() {
            return JID;
        }
    
        public void setJID(String JID) {
            this.JID = JID;
        }
    
        public Date getWork_start() {
            return work_start;
        }
    
        public void setWork_start(Date work_start) {
            this.work_start = work_start;
        }
    
        public Date getWork_end() {
            return work_end;
        }
    
        public void setWork_end(Date work_end) {
            this.work_end = work_end;
        }
    }

#### User ####

package entity;
    
    import java.io.Serializable;
    import java.util.Date;
    import java.util.HashMap;
    
    //用户类
    public class User implements Serializable {
        private String UID;
        private String username;
        private String password;
        private int age;
        private char sex;
        private String phone;
        private String department;//所在院系
        private Position position;//职位
        private UserAccount userAccount;
        private Date regdat = new Date();//注册日期
        private boolean state = true;//状态
        private HashMap<Job, Boolean> jobMap = new HashMap<>();
        private static final long serialVersionUID = 42L;
    
        public User() {
        }
    
        public User(String UID, String username, String password, int age, char sex, String phone, String department, Position position) {
            this.UID = UID;
            this.username = username;
            this.password = password;
            this.age = age;
            this.sex = sex;
            this.phone = phone;
            this.department = department;
            this.position = position;
        }
    
        public String getUID() {
            return UID;
        }
    
        public void setUID(String UID) {
            this.UID = UID;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public char getSex() {
            return sex;
        }
    
        public void setSex(char sex) {
            this.sex = sex;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public String getDepartment() {
            return department;
        }
    
        public void setDepartment(String department) {
            this.department = department;
        }
    
        public Position getPosition() {
            return position;
        }
    
        public void setPosition(Position position) {
            this.position = position;
        }
    
        public UserAccount getUserAccount() {
            return userAccount;
        }
    
        public void setUserAccount(UserAccount userAccount) {
            this.userAccount = userAccount;
        }
    
        public Date getRegdat() {
            return regdat;
        }
    
        public void setRegdat(Date regdat) {
            this.regdat = regdat;
        }
    
        public boolean isState() {
            return state;
        }
    
        public void setState(boolean state) {
            this.state = state;
        }
    
        public HashMap<Job, Boolean> getJobMap() {
            return jobMap;
        }
    
        public void setJobMap(HashMap<Job, Boolean> jobMap) {
            this.jobMap = jobMap;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "UID='" + UID + '\'' +
                    ", password='" + password + '\'' +
                    ", username='" + username + '\'' +
                    ", age=" + age +
                    ", sex='" + sex + '\'' +
                    ", phone='" + phone + '\'' +
                    ", department='" + department + '\'' +
                    ", position=" + position +
                    ", userAccount=" + userAccount +
                    ", regdat=" + regdat +
                    ", state=" + state +
                    ", jobMap=" + jobMap +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            User user = (User) o;
    
            if (age != user.age) return false;
            if (sex != user.sex) return false;
            if (state != user.state) return false;
            if (UID != null ? !UID.equals(user.UID) : user.UID != null) return false;
            if (password != null ? !password.equals(user.password) : user.password != null) return false;
            if (username != null ? !username.equals(user.username) : user.username != null) return false;
            if (phone != null ? !phone.equals(user.phone) : user.phone != null) return false;
            if (department != null ? !department.equals(user.department) : user.department != null) return false;
            if (position != user.position) return false;
            if (userAccount != null ? !userAccount.equals(user.userAccount) : user.userAccount != null) return false;
            if (regdat != null ? !regdat.equals(user.regdat) : user.regdat != null) return false;
            return jobMap != null ? jobMap.equals(user.jobMap) : user.jobMap == null;
        }
    
        @Override
        public int hashCode() {
            int result = UID != null ? UID.hashCode() : 0;
            result = 31 * result + (password != null ? password.hashCode() : 0);
            result = 31 * result + (username != null ? username.hashCode() : 0);
            result = 31 * result + age;
            result = 31 * result + (int) sex;
            result = 31 * result + (phone != null ? phone.hashCode() : 0);
            result = 31 * result + (department != null ? department.hashCode() : 0);
            result = 31 * result + (position != null ? position.hashCode() : 0);
            result = 31 * result + (userAccount != null ? userAccount.hashCode() : 0);
            result = 31 * result + (regdat != null ? regdat.hashCode() : 0);
            result = 31 * result + (state ? 1 : 0);
            result = 31 * result + (jobMap != null ? jobMap.hashCode() : 0);
            return result;
        }
    }

#### UserAccount ####

package entity;
    
    import java.io.Serializable;
    
    //用户帐号类
    public class UserAccount implements Serializable {
        private String ACID;//账户编号
        private double balance;//余额
        private int creditRating = 5;//信用等级(默认未逾期完成兼职工作3次恢复1级信用等级，等级梯度为1-5级，5级最高,逾期降低1级)
        private int performNumber;//总完成次数
        private int overdueNumber;//逾期次数
        private int onTimeCompletion;//按时完成次数
        private static final long serialVersionUID = 42L;
    
        public UserAccount() {
        }
    
        public UserAccount(String ACID, double balance, int creditRating, int performNumber, int overdueNumber, int onTimeCompletion) {
            this.ACID = ACID;
            this.balance = balance;
            this.creditRating = creditRating;
            this.performNumber = performNumber;
            this.overdueNumber = overdueNumber;
            this.onTimeCompletion = onTimeCompletion;
        }
    
        public String getACID() {
            return ACID;
        }
    
        public void setACID(String ACID) {
            this.ACID = ACID;
        }
    
        public double getBalance() {
            return balance;
        }
    
        public void setBalance(double balance) {
            this.balance = balance;
        }
    
        public int getCreditRating() {
            return creditRating;
        }
    
        public void setCreditRating(int creditRating) {
            this.creditRating = creditRating;
        }
    
        public int getPerformNumber() {
            return performNumber;
        }
    
        public void setPerformNumber(int performNumber) {
            this.performNumber = performNumber;
        }
    
        public int getOverdueNumber() {
            return overdueNumber;
        }
    
        public void setOverdueNumber(int overdueNumber) {
            this.overdueNumber = overdueNumber;
        }
    
        public int getOnTimeCompletion() {
            return onTimeCompletion;
        }
    
        public void setOnTimeCompletion(int onTimeCompletion) {
            this.onTimeCompletion = onTimeCompletion;
        }
    }

####    SchoolMember ####

package entity;
    
    import java.io.Serializable;
    
    //学校对象实体类
    public class SchoolMember implements Serializable {
        private String UID ;//学号
        private String userName;
        private static final long serialVersionUID = 42L;
    
        public SchoolMember() {
        }
    
        public SchoolMember(String UID, String userName) {
            this.UID = UID;
            this.userName = userName;
        }
    
        public String getUID() {
            return UID;
        }
    
        public void setUID(String UID) {
            this.UID = UID;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    }

#### Position(枚举） ####

package entity;
    
    public enum Position {
        CONTROLLER("管理员"),PART_TIME("兼职工");
    
        private String name;
    
        Position(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

#### service包： ####

#### FileService ####

package service;
    
    import entity.SchoolMember;
    
    import java.io.*;
    import java.util.HashMap;
    import java.util.HashSet;
    
    public class FileService {
        public static final File file1 = new File("D:\\guanqia\\关卡16_第二个实践项目\\project\\src\\information\\SchoolMembers.txt");
        public static final File file2 = new File("D:\\guanqia\\关卡16_第二个实践项目\\project\\src\\information\\Users.txt");
        public static final File file3 = new File("D:\\guanqia\\关卡16_第二个实践项目\\project\\src\\information\\Jobs.txt");
        public static final File file4 = new File("D:\\guanqia\\关卡16_第二个实践项目\\project\\src\\information\\ApplyJob.txt");
    
        public static void xlSet(HashSet<?> set, File file) throws IOException {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
            oos.writeObject(set);//序列化这个对象
            oos.flush();
            oos.close();
        }
    
        public static HashSet<?> fxlSet(File file) throws IOException, ClassNotFoundException {
            HashSet<?> set;
            if (!file.exists()) {//如果这个文件不存在
                file.createNewFile();//新建这个文件
            }
            if (file.length() == 0) {//如果这个文件没内容
                set = new HashSet<>();//新建一个空的HashSet集合
            } else {//如果存在，反序列化这文件
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
                Object o = ois.readObject();
                set = (HashSet<?>) o;
                ois.close();
            }
            return set;
        }
    
    
        public static void xlMap(HashMap<String, String> map) throws IOException {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file1));
            oos.writeObject(map);//序列化这个对象
            oos.flush();
            oos.close();
        }
    
        public static HashMap<String, String> fxlMap() throws IOException, ClassNotFoundException {
            HashMap<String, String> map;
            if (!FileService.file1.exists()) {//如果这个文件不存在
                FileService.file1.createNewFile();
            }
            if (file1.length() == 0) {//如果文件没内容
                map = new HashMap<>();
                SchoolMember sm1 = new SchoolMember("s190047144", "貂蝉");
                SchoolMember sm2 = new SchoolMember("s190047145", "西施");
                SchoolMember sm3 = new SchoolMember("s190047146", "王昭君");
                SchoolMember sm4 = new SchoolMember("s190047147", "杨玉环");
                SchoolMember sm5 = new SchoolMember("t190001", "蔡文姬");
                SchoolMember sm6 = new SchoolMember("t190002", "孙尚香");
                SchoolMember sm7 = new SchoolMember("t190003", "大乔");
                SchoolMember sm8 = new SchoolMember("t190004", "小乔");
                map.put(sm1.getUID(), sm1.getUserName());
                map.put(sm2.getUID(), sm2.getUserName());
                map.put(sm3.getUID(), sm3.getUserName());
                map.put(sm4.getUID(), sm4.getUserName());
                map.put(sm5.getUID(), sm5.getUserName());
                map.put(sm6.getUID(), sm6.getUserName());
                map.put(sm7.getUID(), sm7.getUserName());
                map.put(sm8.getUID(), sm8.getUserName());
            } else {
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file1));
                Object o = ois.readObject();
                map = (HashMap<String, String>) o;
                ois.close();
            }
            return map;
        }
    
    
    }

#### RegistService ####

package service;
    
    import entity.Position;
    import entity.User;
    import entity.UserAccount;
    import utils.TSUtility;
    
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Set;
    
    public class RegistService {
        //登录
        public static String sign(HashMap<String, String> map, HashSet<User> set) throws InterruptedException, IOException, ClassNotFoundException {
            System.out.println("------------------登录界面------------------");
            String ID = "";
            System.out.println("请输入用户编号：");
            String id = TSUtility.readString(10);
            //对象进行判断是否注册过
            boolean b = false;
            for (User u : set) {
                if (id.equals(u.getUID())) {//寻找id
                    b = true;
                    break;
                }
            }
            if (b) {
                if (id.startsWith("s")) {//如果是学生
                    System.out.println("学生登录：");
                } else if (id.startsWith("t")) {//如果是管理者
                    System.out.println("管理者登录：");
                }
                System.out.println("请输入你的密码：");
                String password = TSUtility.readString(10);
                boolean b1 = false;
                for (User u : set) {
                    if (id.equals(u.getUID()) && password.equals(u.getPassword())) {//找到与id对应的密码，判断是否正确
                        b1 = true;
                        break;
                    }
                }
                if (b1) {
                    System.out.println("登录成功！");
                    ID = id;
                } else {
                    System.out.println("密码输入错误，请核对后重新输入!");
                }
            } else {//没找到id
                System.out.println("请先注册账号！");
            }
            return ID;
        }
    
        //注册
        public static void regist(HashMap<String, String> map, HashSet<User> set) throws InterruptedException, IOException, ClassNotFoundException {
            System.out.println("------------------注册界面------------------");
            System.out.println("请输入用户编号：");
            String id = TSUtility.readString(10);
            //进行学号判断是否是学校成员
            boolean flag = false;
            Set<String> keySet = map.keySet();
            for (String s : keySet) {
                if (id.equals(s)) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                //进行判断是否注册过
                boolean b = false;
                for (User u : set) {
                    if (id.equals(u.getUID())) {//寻找id
                        b = true;
                        break;
                    }
                }
                if (!b) {
                    System.out.println("请输入年龄：");
                    int age = TSUtility.readInt();
                    System.out.println("请输入性别：");
                    char sex = TSUtility.readChar();
                    System.out.println("请输入电话：");
                    String phone = TSUtility.readString(15);
                    System.out.println("请输入所在院系：");
                    String department = TSUtility.readString(10);
                    System.out.println("请输入密码：");
                    String password = TSUtility.readString(10);
                    User user = null;
                    UserAccount ua = new UserAccount();
                    if (id.startsWith("s")) {//是学生
                        user = new User(id, map.get(id), password, age, sex, phone, department, Position.PART_TIME);
                        System.out.println("注册成功！");
                    } else if (id.startsWith("t")) {//是老师
                        user = new User(id, map.get(id), password, age, sex, phone, department, Position.CONTROLLER);
                        System.out.println("管理员添加成功！");
                    }
                    user.setUserAccount(ua);
                    set.add(user);
                } else {//找到id，被注册过
                    System.out.println("该账号已被注册，如有疑问请联系管理员！");
                }
            } else {
                System.out.println("本程序仅支持学校认可的成员使用！");
            }
        }
    
        //找回密码
        public static void forgetPassword(HashMap<String, String> map, HashSet<User> set) {
            System.out.println("请输入用户编号：");
            String id = TSUtility.readString(10);
            //对象进行判断是否注册过
            boolean b = false;
            for (User u : set) {
                if (id.equals(u.getUID())) {//寻找id
                    b = true;
                    break;
                }
            }
            if (b) {//找到id
                System.out.println("请输入您的姓名：");
                String name = TSUtility.readString(5);
                boolean b2 = false;
                for (User user : set) {
                    if (id.equals(user.getUID()) && user.getUsername().equals(name)) {
                        System.out.println("你的密码是：" + user.getPassword());
                        b2 = true;
                        break;
                    }
                }
                if (!b2) {
                    System.out.println("姓名输入有误，请核对后重新输入!");
                }
            } else {//没找到id
                System.out.println("请先注册账号！");
            }
        }
    
    
    }

#### View包： ####

#### LoginView ####

package view;
    
    import entity.ApplyJob;
    import entity.Job;
    import entity.User;
    import service.FileService;
    import service.RegistService;
    import utils.TSUtility;
    
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.HashSet;
    
    public class LoginView {
        public static HashMap<String, String> map;//学院成员
        public static HashSet<User> set;//用户
        public static HashSet<Job> setJob;//兼职
        public static HashSet<ApplyJob> setApplyJob;//正在兼职的成员和工作
    
        static {
            try {
                map = FileService.fxlMap();
                set = (HashSet<User>) FileService.fxlSet(FileService.file2);
                setJob = (HashSet<Job>) FileService.fxlSet(FileService.file3);
                setApplyJob = (HashSet<ApplyJob>) FileService.fxlSet(FileService.file4);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
        public static User loginRegist() {
            String id = "";
            while (true) {
                System.out.println("======================================");
                System.out.println("||                                  ||");
                System.out.println("||        欢迎使用校园兼职平台          ||");
                System.out.println("||         用户登录或注册服务           ||");
                System.out.println("||                                  ||");
                System.out.println("======================================");
                System.out.println("请选择你需要的服务选项：(1-4)");
                System.out.println("1.  用户登录");
                System.out.println("2.  用户注册");
                System.out.println("3.  忘记密码");
                System.out.println("4.  退出程序");
                char c = TSUtility.dispatchMenuSelection();
                switch (c) {
                    case '1':
                        try {
                            if (set != null) {
                                id = RegistService.sign(map, set);
                            }
                        } catch (InterruptedException | IOException | ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                        if (id.equals("")) {
                            break;
                        }
                        break;
                    case '2':
                        try {
                            if (map != null) {
                                RegistService.regist(map, set);
                                break;
                            }
                        } catch (InterruptedException | IOException | ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                        break;
                    case '3':
                        if (set != null) {
                            RegistService.forgetPassword(map, set);
                            break;
                        }
                        break;
                    case '4':
                        System.out.println("是否退出程序 (Y/N)");
                        char off = TSUtility.readConfirmSelection();
                        if (off == 'Y') {
                            try {
                                FileService.xlMap(LoginView.map);
                                FileService.xlSet(LoginView.set, FileService.file2);
                                FileService.xlSet(LoginView.setJob, FileService.file3);
                                FileService.xlSet(LoginView.setApplyJob, FileService.file4);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
    
                            System.exit(0);
                        } else {
                            break;
                        }
                }
                for (User user : set) {
                    if (id.equals(user.getUID())) {
                        return user;
                    }
                }
            }
        }
    }

#### HomeView ####

package view;
    
    import entity.User;
    
    import java.text.ParseException;
    
    public class HomeView {
        public static void main(String[] args) throws InterruptedException, ParseException {
            User user = LoginView.loginRegist();//登录
            if (user.getUID().startsWith("s")) {
                //如果是学生，进用户主页
                UserView.userHomePage(user);
            } else if (user.getUID().startsWith("t")) {
                //如果是管理者，进管理者页面
                CaretakersView.caretakersHomePage();
            }
        }
    }

#### 工具类： ####

package utils;
    
    import java.util.Scanner;
    
    public class TSUtility {
        private static Scanner scanner = new Scanner(System.in);
    
    
        /**
         * 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’5’中的任意字符，则方法返回。返回值为用户键入字符。
         */
        public static char readMenuSelection() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);
                c = str.charAt(0);
                if (c != '1' && c != '2' &&
                        c != '3' && c != '4' && c != '5') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
    
        /**
         * 用于界面菜单的选择。该方法读取键盘，如果用户键入’0’-’5’中的任意字符，则方法返回。返回值为用户键入字符。
         */
        public static char readCreditAdjustment() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);
                c = str.charAt(0);
                if (c != '0' && c != '1' && c != '2' &&
                        c != '3' && c != '4' && c != '5') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
        /**
         * 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’8’中的任意字符，则方法返回。返回值为用户键入字符。
         */
        public static char readPartTime() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);
                c = str.charAt(0);
                if (c != '1' && c != '2' &&
                        c != '3' && c != '4' && c != '5' && c != '6' && c != '7' && c != '8') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
        /**
         * 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’7’中的任意字符，则方法返回。返回值为用户键入字符。
         */
        public static char readPartTimeJob() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);
                c = str.charAt(0);
                if (c != '1' && c != '2' &&
                        c != '3' && c != '4' && c != '5' && c != '6' && c != '7') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
        /**
         * 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’3’中的任意字符，则方法返回。返回值为用户键入字符。
         */
        public static char loginMenuSelection() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);
                c = str.charAt(0);
                if (c != '1' && c != '2' && c != '3') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
        /**
         * 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。
         */
        public static char dispatchMenuSelection() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);
                c = str.charAt(0);
                if (c != '1' && c != '2' && c != '3' && c != '4') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
        /**
         * 从键盘读取一个字符，并将其作为方法的返回值。
         */
        public static char readChar() {
            String str = readKeyBoard(1, false);
            return str.charAt(0);
        }
    
        /**
         * 从键盘读取一个字符，并将其作为方法的返回值。
         * 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
         */
        public static char readChar(char defaultValue) {
            String str = readKeyBoard(1, true);
            return (str.length() == 0) ? defaultValue : str.charAt(0);
        }
    
        /**
         * 从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
         */
        public static int readInt() {
            int n;
            for (; ; ) {
                String str = readKeyBoard(2, false);
                try {
                    n = Integer.parseInt(str);
                    break;
                } catch (NumberFormatException e) {
                    System.out.print("数字输入错误，请重新输入：");
                }
            }
            return n;
        }
    
        /**
         * 从键盘读取一个长度不超过4位的浮点数，并将其作为方法的返回值。
         */
        public static double readDouble() {
            double n;
            for (; ; ) {
                String str = readKeyBoard(4, false);
                try {
                    n = Double.parseDouble(str);
                    break;
                } catch (NumberFormatException e) {
                    System.out.print("数字输入错误，请重新输入：");
                }
            }
            return n;
        }
    
        /**
         * 从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
         * 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
         */
        public static int readInt(int defaultValue) {
            int n;
            for (; ; ) {
                String str = readKeyBoard(2, true);
                if (str.equals("")) {
                    return defaultValue;
                }
    
                try {
                    n = Integer.parseInt(str);
                    break;
                } catch (NumberFormatException e) {
                    System.out.print("数字输入错误，请重新输入：");
                }
            }
            return n;
        }
    
        /**
         * 从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
         */
        public static String readString(int limit) {
            return readKeyBoard(limit, false);
        }
    
        /**
         * 从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
         * 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
         */
        public static String readString(int limit, String defaultValue) {
            String str = readKeyBoard(limit, true);
            return str.equals("") ? defaultValue : str;
        }
    
        /**
         * 用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
         */
        public static char readConfirmSelection() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false).toUpperCase();
                c = str.charAt(0);
                if (c == 'Y' || c == 'N') {
                    break;
                } else {
                    System.out.print("选择错误，请重新输入：");
                }
            }
            return c;
        }
    
        private static String readKeyBoard(int limit, boolean blankReturn) {
            String line = "";
    
            while (scanner.hasNextLine()) {
                line = scanner.nextLine();
                if (line.length() == 0) {
                    if (blankReturn) return line;
                    else continue;
                }
                if (line.length() < 1 || line.length() > limit) {
                    System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
                    continue;
                }
                break;
            }
    
            return line;
        }
    
    }

[c1efae47a6914718ab3f6735b9524585.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/bada69a3a771456e9e5e52d8436b9dda.png