Java---题库管理系统（小项目）

项目策划书

题库管理系统
一．项目设计分析
该项目可以帮助莘莘学子寻找到需要的题目，同时可以打笔记使做题效率更高.
二.项目功能简介
<1>分级管理功能：该项目实现了管理员与用户的分离，管理员和用户权限不同.
<2>注册功能：用户在登陆界面可以进行账号的注册.
<3>修改用户信息功能：当用户或管理员登录系统时，可以完成自己的密码和昵称修改.
<4>查看题目功能：用户可根据类型和题目的序号对题目进行查看.
<5>记录笔记功能：当用户做题有所收获或见解时可以通过打笔记的方法记录自己的想法.
<6>删除笔记功能:防止自己打错笔记,避免不必要的资源浪费,同时使用户拥有一个较为整洁的笔记本.
<7>监察功能:管理员对用户的拥有增删改查的权力,防止恶意注册账号等

代码

实体

/**
 * @Author: Re
 * @Date: 2020/12/7 15:31
 * 用户实体
 */
public class User implements Comparable<User>{
    private Integer id;
    private int level;
    private String password;
    private String userName;
    private int nodeCount;
    private String node;
    private int collectionCount;

    public String getUserName() {
        return userName;
    }

    public String getNode() {
        return node;
    }

    public void setNode(String node) {
        this.node = node;
    }

    public int getLevel() {
        return level;
    }


    public User() {
    }

    public User(Integer id)
    {
        this.id = id;
    }

    public User(Integer id,String password,String userName,int nodeCount,int collectionCount,int level) {
        this.id=id;
        this.password = password;
        this.userName = userName;
        this.level=level;
        this.nodeCount=nodeCount;
        this.collectionCount=collectionCount;
    }

    public int getId() {
        return id;
    }

    public void setId(Integer id)
    {
        this.id = id;
    }

    public String getPassword() {
        return password;
    }

    public int getNodeCount() {
        return nodeCount;
    }

    public void setNodeCount(int nodeCount) {
        this.nodeCount = nodeCount;
    }

    public int getCollectionCount() {
        return collectionCount;
    }

    public String getName() {
        return userName;
    }

    public void setName(String userName) {
        this.userName = userName;
    }
    @Override
    public String toString() {
        String s= (this.level==1)? "管理员":"用户";
        return  "账号为：" + this.id +
                ",用户名为： " + this.userName +
                ",身份：  "+ s;
    }

    /**
     * 比较器，用于用户的排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(User o) {
        if(this.getId()==o.getId()){
            return this.getName().compareTo(o.getName());
        }else if(this.getId()>o.getId()){
            return 1;
        }
        return -1;
    }
}

import java.util.Objects;

/**
 * @Author: Re
 * @Date: 2020/12/7 15:46
 * 问题实体
 */
public class Questions implements Comparable<Questions>{
    private String content;
    private String type;
    private int sign;
    private String complexity;
    private String answer;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getComplexity()
    {
        return complexity;
    }

    public String getAnswer() {
        return answer;
    }

    public void setAnswer(String answer) {
        this.answer = answer;
    }

    public Questions() {
    }

    public Questions(String content, String type, int sign, String complexity, String answer) {
        this.content = content;
        this.type = type;
        this.sign = sign;
        this.complexity = complexity;
        this.answer = answer;
    }

    public String getContent() {
        return content;
    }

    public int getSign() {
        return sign;
    }

    public void setSign(int sign) {
        this.sign = sign;
    }

    @Override
    public String toString() {
        return "序号：" + sign+
                "--题目类型：" + type  +
                "--难易程度：" + complexity+
                "\n"+content+"?"
                ;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Questions questions = (Questions) o;
        return complexity == questions.complexity &&
                Objects.equals(type, questions.type) &&
                Objects.equals(sign, questions.sign);
    }

    /**
     * 比较器，用于题目的排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(Questions o) {
        if(this.getSign()==o.getSign()){
            return this.getType().compareTo(o.getType());
        }else if(this.getSign()>o.getSign()){
            return 1;
        }else {
            return -1;
        }
    }
}

import java.util.Date;

/**
 * @Author: Re
 * @Date: 2020/12/7 17:55
 * 笔记实体
 */
public class Note implements Comparable<Note>{
    private Date time;
    private String master;
    private Integer id;
    private Integer Count=0;
    private Integer sign=0;
    private String Content;

    public Note() {
    }

    public Note(String maser) {
        this.master = maser;
    }

    public int getSign() {
        return sign;
    }

    public void setSign(Integer sign) {
        this.sign = sign;
    }

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }

    public String getMaster() {
        return master;
    }

    public int getCount() {
        return Count;
    }

    public Integer getId() {
        return id;
    }

    public String getContent() {
        return Content;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Note( String master, Integer id, Integer count, Integer sign, String content) {
        this.master = master;
        this.id = id;
        Count = count;
        this.sign = sign;
        Content = content;
    }

    @Override
    public String toString() {
        return  "笔记内容："+getContent() +
                "\n               用户名：" + master  +
                " 笔记数目：" + Count ;
    }

    /**
     * 用于存入笔记的排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(Note o) {
        if(this.getId().equals(o.getId())){
            return this.getSign()-o.getSign();
        }else if(this.getId() > o.getId()){
            return 1;
        }
        return -1;
    }
}

Dao

接口

//用户dao层接口
import studio.lyl.questionbankmanagementsystem.entity.User;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/7 16:23
 */
public interface IUserDao {
    /**
     * 创建用户
     * @param user
     * @return boolean
     */
    boolean insertUser(User user) ;

    /**
     * 根据id删除用户
     * @param id
     * @return boolean
     */
    boolean deleteUserById(Integer id) ;

    /**
     * 修改用户信息
     * @param id
     * @param user
     * @return boolean
     */
    boolean updateUser(Integer id,User user) ;

    /**
     * 根据id查看用户信息
     * @param id
     * @return List
     */
    List<User> selectUserById(Integer id) ;

    /**
     * 查看所有用户信息
     * @return
     * @throws Exception
     */
    List<User> selectUser() ;
}

//题库dao层接口
import studio.lyl.questionbankmanagementsystem.entity.Questions;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/7 17:15
 */
public interface IQuestionDao{
    /**
     * 增加题目
     * @param questions
     * @return boolean
     */
    boolean insetQuestion(Questions questions) throws Exception;

    /**
     * 根据序号删除题目
     * @param sign
     * @param type
     * @return boolean
     */
    boolean deleteQuestion(int sign,String type) throws Exception;

    /**
     * 根据序号删除题目
     * @param sign
     * @param questions
     * @param type
     * @return
     */
    boolean updateQuestion(int sign ,String type ,Questions questions) throws Exception;

    /**
     * 根据序号查看题目
     * @param sign
     * @param type
     * @return String
     */
    List<Questions> selectQuestion(int sign, String type) ;

    /**
     * 根据序号和类型查看一个题的答案
     * @param sign
     * @param type
     * @return
     */
    List<Questions> selectAnswer(int sign,String type) ;

    /**
     * 查看一个类型里所有的题目
     * @param type
     * @return List
     * @throws Exception
     */
    List<Questions> selectQuestions(String type) ;

}

//笔记dao层窗口
import studio.lyl.questionbankmanagementsystem.entity.Note;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/7 18:13
 */
public interface INoteDao {
    /**
     * 增加笔记
     * @param note
     * @return boolean
     */
    boolean insetNote(Note note) ;

    /**
     * 根据用户id删除笔记
     * @param id
     * @return boolean
     */
    boolean deleteNote(Integer id,Integer sign) ;

    /**
     * 根据用户id更改笔记
     * @param id
     * @param note
     * @param sign
     * @return
     */
    boolean updateNote(Integer id,Integer sign,Note note) ;

    /**
     * 根据用户id查看笔记
     * @param id
     * @return
     */
    List<Note> selectNoteById(Integer id) ;

    /**
     * 查看所有的笔记
     * @return
     */
    List<Note> selectNote() ;
}

实现接口

//用户dao层接口实现

```import studio.lyl.questionbankmanagementsystem.dao.IUserDao;
import studio.lyl.questionbankmanagementsystem.entity.User;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/8 22:12
 */
public class UserDaoImpl implements IUserDao {

    @Override
    public boolean insertUser(User user)  {
        try {
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("QuestionBankManagementSystem\\User.txt",true));
            String returnString=String.format("%s,%s,%s,%s,%s,%s",user.getId(),user.getPassword(),user.getUserName(),0,0,0);
            bufferedWriter.write(returnString);
            bufferedWriter.newLine();
            bufferedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;

    }

    @Override
    public boolean deleteUserById(Integer id) {
        BufferedReader bufferedReader= null;
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String s=null;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                User user=new User(Integer.parseInt(strings[0]),strings[1],strings[2],Integer.parseInt(strings[3]),Integer.parseInt(strings[4]),Integer.parseInt(strings[5]));
                userList.add(user);
            }
            for (int i = 0; i < userList.size(); i++) {
                User userGet=userList.get(i);
                if(userGet.getId()==id) {
                    userList.remove(i);
                }
            }
            Collections.sort(userList);
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("QuestionBankManagementSystem\\User.txt"));
            for (int i = 0; i < userList.size(); i++) {
                User user=userList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s,%s",user.getId(),user.getPassword(),user.getUserName(),user.getNodeCount(),user.getCollectionCount(),user.getLevel());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedReader.close();
            bufferedWriter.flush();
            bufferedReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return false;
    }

    @Override
    public boolean updateUser(Integer id,User user)  {
        BufferedReader bufferedReader= null;
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String s=null;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                User userGet=new User(Integer.parseInt(strings[0]),strings[1],strings[2],Integer.parseInt(strings[3]),Integer.parseInt(strings[4]),Integer.parseInt(strings[5]));
                userList.add(userGet);
            }
            for (int i = 0; i < userList.size(); i++) {
                User userGet=userList.get(i);
                if(userGet.getId()==id) {
                    userList.set(i,user);
                }
            }
            Collections.sort(userList);
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("QuestionBankManagementSystem\\User.txt"));
            for (int i = 0; i < userList.size(); i++) {
                User userGet=userList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s,%s",userGet.getId(),userGet.getPassword(),userGet.getUserName(),userGet.getNodeCount(),userGet.getCollectionCount(),userGet.getLevel());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedReader.close();
            bufferedWriter.flush();
            bufferedReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public List<User> selectUserById(Integer id) {
        BufferedReader bufferedReader= null;
        List<User> returnUserList=new ArrayList<>();
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String s=null;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                User user=new User(Integer.parseInt(strings[0]),strings[1],strings[2],Integer.parseInt(strings[3]),Integer.parseInt(strings[4]),Integer.parseInt(strings[5]));
                userList.add(user);
            }
            for (int i = 0; i < userList.size(); i++) {
                User user=userList.get(i);
                if(user.getId()==id){
                    returnUserList.add(user);
                }
            }
            Collections.sort(returnUserList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return returnUserList;
    }

    @Override
    public List<User> selectUser() {
        BufferedReader bufferedReader= null;
        List<User> userList=new ArrayList<>();
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\User.txt"));
            String s=null;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                User user=new User(Integer.parseInt(strings[0]),strings[1],strings[2],Integer.parseInt(strings[3]),Integer.parseInt(strings[4]),Integer.parseInt(strings[5]));
                userList.add(user);
            }
            Collections.sort(userList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return userList;
    }
}

//题库dao层实现
import studio.lyl.questionbankmanagementsystem.dao.IQuestionDao;
import studio.lyl.questionbankmanagementsystem.entity.Questions;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/8 20:18
 */
public class QuestionDaoImpl implements IQuestionDao {

    @Override
    public boolean insetQuestion(Questions questions) {
        BufferedWriter bufferedWriter= null;
        try {
            bufferedWriter = new BufferedWriter(new FileWriter(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+questions.getType()+".txt",true));
            bufferedWriter.write(questions.getContent()+","+questions.getType()+","+questions.getSign()+","+questions.getComplexity()+","+questions.getAnswer());
            bufferedWriter.newLine();
            bufferedWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    @Override
    public boolean deleteQuestion(int sign,String type)  {
        BufferedReader bufferedReader= null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader = new BufferedReader(new FileReader(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            List<Questions> questionsList=new ArrayList<>();
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Questions questions=new Questions(strings[0],strings[1],Integer.parseInt(strings[2]),strings[3],strings[4]);
                questionsList.add(questions);
            }
            for (int i = 0; i < questionsList.size(); i++) {
                Questions questions=questionsList.get(i);
                if(questions.getSign()==sign){
                    questionsList.remove(i);
                }
            }
            Collections.sort(questionsList);
            bufferedWriter=new BufferedWriter(new FileWriter(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            for (int i = 0; i < questionsList.size(); i++) {
                Questions questions=questionsList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s",questions.getContent(),questions.getType(),questions.getSign(),questions.getComplexity(),questions.getAnswer());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    @Override
    public boolean updateQuestion(int sign,String type,Questions questions) {
        BufferedReader bufferedReader= null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader = new BufferedReader(new FileReader(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            List<Questions> questionsList=new ArrayList<>();
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Questions questionsSet=new Questions(strings[0],strings[1],Integer.parseInt(strings[2]),strings[3],strings[4]);
                questionsList.add(questionsSet);
            }
            for (int i = 0; i < questionsList.size(); i++) {
                Questions questionsSet=questionsList.get(i);
                if(questionsSet.getSign()==sign){
                    questionsList.set(i,questions);
                }
            }
            Collections.sort(questionsList);
            bufferedWriter=new BufferedWriter(new FileWriter(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            for (int i = 0; i < questionsList.size(); i++) {
                Questions questionsSet=questionsList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s",questionsSet.getContent(),questionsSet.getType(),questionsSet.getSign(),questionsSet.getComplexity(),questionsSet.getAnswer());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    @Override
    public List<Questions> selectQuestion(int sign,String type)  {
        BufferedReader bufferedReader= null;
        List<Questions> returnQuestionsList=new ArrayList<>();
        try {
            bufferedReader = new BufferedReader(new FileReader(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            List<Questions> questionsList=new ArrayList<>();
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Questions questions=new Questions(strings[0],strings[1],Integer.parseInt(strings[2]),strings[3],strings[4]);
                questionsList.add(questions);
            }
            for (int i = 0; i < questionsList.size(); i++) {
                Questions questions=questionsList.get(i);
                if(questions.getSign()==sign){
                    for (int j = 0; j < questionsList.size(); j++) {
                        returnQuestionsList.add(questions);
                    }
                }
            }
            Collections.sort(returnQuestionsList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return returnQuestionsList;
    }

    @Override
    public List<Questions> selectAnswer(int sign, String type) {
        BufferedReader bufferedReader= null;
        try {
            bufferedReader = new BufferedReader(new FileReader(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            List<Questions> questionsList=new ArrayList<>();
            String s=null;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Questions questions=new Questions(strings[0],strings[1],Integer.parseInt(strings[2]),strings[3],strings[4]);
                questionsList.add(questions);
            }
            for (int i = 0; i < questionsList.size(); i++) {
                Questions questions=questionsList.get(i);
                if(questions.getSign()==sign){
                    System.out.println(questions.getAnswer());
                }
            }
            Collections.sort(questionsList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public List<Questions> selectQuestions(String type) {
        BufferedReader bufferedReader=null;
        List<Questions> questionsList=null;
        try {
            bufferedReader = new BufferedReader(new FileReader(("QuestionBankManagementSystem\\Questions\\".endsWith("/") ? "QuestionBankManagementSystem\\Questions\\":"QuestionBankManagementSystem\\Questions\\"+"/")+type+".txt"));
            questionsList=new ArrayList<>();
            String s=null;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Questions questions=new Questions(strings[0],strings[1],Integer.parseInt(strings[2]),strings[3],strings[4]);
                questionsList.add(questions);
            }
            Collections.sort(questionsList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return questionsList;
    }
}

//笔记dao层实现
import studio.lyl.questionbankmanagementsystem.dao.INoteDao;
import studio.lyl.questionbankmanagementsystem.dao.IUserDao;
import studio.lyl.questionbankmanagementsystem.entity.Note;
import studio.lyl.questionbankmanagementsystem.entity.User;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/8 8:37
 */
public class NoteDaoImpl implements INoteDao  {

    @Override
    public boolean insetNote(Note note) {
        BufferedWriter bufferedWriter= null;
        IUserDao iUserDao=new UserDaoImpl();
        try {
            List<User> userList=iUserDao.selectUserById(note.getId());
            User user=userList.get(0);
            user.setNodeCount(user.getCollectionCount()+1);
            bufferedWriter = new BufferedWriter(new FileWriter("QuestionBankManagementSystem\\Note.txt",true));
            bufferedWriter.write(note.getMaster()+","+note.getId()+","+note.getCount()+","+note.getSign()+","+note.getContent());
            bufferedWriter.newLine();
            bufferedWriter.flush();;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
            return false;
    }

        @Override
        public boolean deleteNote(Integer id,Integer sign) {
        BufferedReader bufferedReader= null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\Note.txt"));
            List<Note> noteList=new ArrayList<>();
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Note note=new Note(strings[0],Integer.parseInt(strings[1]),Integer.parseInt(strings[2]),Integer.parseInt(strings[3]),strings[4]);
                noteList.add(note);
            }
            bufferedWriter=new BufferedWriter(new FileWriter("QuestionBankManagementSystem\\Note.txt"));
            for (int i = 0; i < noteList.size(); i++) {
                Note note=noteList.get(i);
                if(note.getId().equals(id)){
                    if (note.getSign()==sign){
                        noteList.remove(i);
                    }
                }
            }
            Collections.sort(noteList);
            for (int i = 0; i < noteList.size(); i++) {
                Note note=noteList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s",note.getMaster(),note.getId(),note.getCount(),note.getSign(),note.getContent());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return false;
    }

    @Override
    public boolean updateNote(Integer id,Integer sign,Note note) {
        BufferedReader bufferedReader= null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\Note.txt"));
            List<Note> noteList=new ArrayList<>();
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Note noteGet=new Note(strings[0],Integer.parseInt(strings[1]),Integer.parseInt(strings[2]),Integer.parseInt(strings[3]),strings[4]);
                noteList.add(noteGet);
            }
            bufferedWriter=new BufferedWriter(new FileWriter("QuestionBankManagementSystem\\Note.txt"));
            for (int i = 0; i < noteList.size(); i++) {
                Note noteSet=noteList.get(i);
                if(noteSet.getId().equals(id)) {
                    if(noteSet.getSign()==sign) {
                        noteList.set(sign-1, note);
                    }
                }
            }
            Collections.sort(noteList);
            for (int i = 0; i < noteList.size(); i++) {
                Note returnNote=noteList.get(i);
                    String returnString = String.format("%s,%s,%s,%s,%s", returnNote.getMaster(), returnNote.getId(), returnNote.getCount(), returnNote.getSign(), returnNote.getContent());
                    bufferedWriter.write(returnString);
                    bufferedWriter.newLine();
            }
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return false;
    }


    @Override
    public List<Note> selectNoteById(Integer id) {
        BufferedReader bufferedReader= null;
        List<Note> returnNoteList=new ArrayList<>();
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\Note.txt"));
            List<Note> noteList=new ArrayList<>();
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Note note=new Note(strings[0],Integer.parseInt(strings[1]),Integer.parseInt(strings[2]),Integer.parseInt(strings[3]),strings[4]);
                noteList.add(note);
            }
            for (int i = 0; i < noteList.size(); i++) {
                Note note=noteList.get(i);
                if(note.getId().equals(id)){
                   returnNoteList.add(note);
                }
            }
            Collections.sort(returnNoteList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return returnNoteList;
    }

    @Override
    public List<Note> selectNote() {
        BufferedReader bufferedReader= null;
        List<Note> noteList=new ArrayList<>();
        try {
            bufferedReader = new BufferedReader(new FileReader("QuestionBankManagementSystem\\Note.txt"));
            String s;
            while ((s=bufferedReader.readLine())!=null){
                String[] strings=s.split(",");
                Note note=new Note(strings[0],Integer.parseInt(strings[1]),Integer.parseInt(strings[2]),Integer.parseInt(strings[3]),strings[4]);
                noteList.add(note);
            }
            Collections.sort(noteList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return noteList;
    }
}

Service

接口

//用户service接口
import studio.lyl.questionbankmanagementsystem.entity.User;

/**
 * @Author: Re
 * @Date: 2020/12/7 22:46
 */
public interface IUserService {

    /**
     *用户登录
     * @param id
     * @param password
     * @return boolean
     * @throws Exception
     */
    boolean loginUserService(Integer id,String password) ;

    /**
     * 管理员登录
     * @param id
     * @param password
     * @return
     */
    boolean loginAdministratorService(Integer id,String password);

    /**
     *
     * @param user
     * @return boolean
     * @throws Exception
     */
    boolean registService(User user) ;

    /**
     * 创建用户
     * @param user
     * @return boolean
     */
    boolean insertUser(User user) ;

    /**
     * 根据id删除用户
     * @param id
     * @return boolean
     */
    boolean deleteUserById(Integer id) ;

    /**
     * 根据用户id修改用户信息
     * @param id
     * @return boolean
     */
    boolean updateUser(Integer id,User user) ;

    /**
     * 根据id查看用户信息
     * @param id
     * @return User
     */
    User selectUserById(Integer id) ;

    /**
     * 查看所有用户信息
     * @return
     * @throws Exception
     */
    String selectUser() ;
}

//题库service接口
import studio.lyl.questionbankmanagementsystem.entity.Questions;

import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/9 15:55
 */
public interface IQuestionServise {
    /**
     * 增加题目
     * @param questions
     * @return boolean
     */
    boolean insetQuestion(Questions questions) ;

    /**
     * 根据序号删除题目
     * @param sign
     * @param type
     * @return boolean
     */
    boolean deleteQuestion(int sign,String type) ;

    /**
     * 根据序号删除题目
     * @param sign
     * @param questions
     * @param type
     * @return
     */
    boolean updateQuestion(int sign ,String type ,Questions questions) ;

    /**
     * 根据序号查看题目
     * @param sign
     * @param type
     * @return String
     */
    Questions selectQuestion(int sign, String type) ;

    /**
     * 查看一个类型全部的题目
     * @param type
     * @return List
     */
    List<Questions> selectQuestions(String type) ;

    /**
     * 根据题目和序号查看改题目的答案
     * @param type
     * @return Questions
     */
    Questions selectAnswer(int sign,String type);
}

//笔记service接口
package studio.lyl.questionbankmanagementsystem.service;

import studio.lyl.questionbankmanagementsystem.entity.Note;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/9 15:46
 */
public interface INoteService {
    /**
     * 增加笔记
     * @param note
     * @return boolean
     */
    boolean insetNote(Note note) ;

    /**
     * 根据用户id删除笔记
     * @param id
     * @param sign
     * @return boolean
     */
    boolean deleteNote(Integer id,Integer sign) ;

    /**
     * 根据用户id更改笔记
     * @param id
     * @param note
     * @param sign
     * @return
     */
    boolean updateNote(Integer id,Integer sign,Note note) ;

    /**
     * 根据用户id查看笔记
     * @param id
     * @return
     */
    List<Note> selectNoteById(Integer id) ;

    /**
     * 查看所有的笔记
     * @return
     */
    List<Note> selectNote() ;
}

实现接口

//用户Service接口实现
import studio.lyl.questionbankmanagementsystem.dao.IUserDao;
import studio.lyl.questionbankmanagementsystem.dao.impl.UserDaoImpl;
import studio.lyl.questionbankmanagementsystem.entity.User;
import studio.lyl.questionbankmanagementsystem.service.IUserService;

import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/11 20:50
 */
public class UserServiceImpl implements IUserService {
    IUserDao iUserDao=new UserDaoImpl();

    @Override
    public boolean loginUserService(Integer id, String password) {
        List<User> userList=iUserDao.selectUserById(id);
        User user=userList.get(0);
        if(user==null||user.getLevel()==1){
            System.out.println("账号错误！");
            return false;
        }else {
            for (int i = 0; i < userList.size(); i++) {
                if(user.getPassword().equals(password)){
                    System.out.println("登录成功。");
                    return true;
                }
            }
        }
        System.out.println("密码错误！");
        return false;
    }

    @Override
    public boolean loginAdministratorService(Integer id, String password) {
        List<User> userList=iUserDao.selectUserById(id);
        if (userList.size()==0){
            System.out.println("账号错误");
            return false;
        }else {
            User user=userList.get(0);
            if (user == null || user.getLevel() == 0) {
                System.out.println("账号错误！");
                return false;
            } else {
                for (int i = 0; i < userList.size(); i++) {
                    if (user.getPassword().equals(password)) {
                        System.out.println("登录成功。");
                        return true;
                    }
                }
            }
        }
        System.out.println("密码错误！");
        return false;
    }

    @Override
    public boolean registService(User user) {
        List<User> userList=iUserDao.selectUserById(user.getId());
        if(userList.size()==0){
            iUserDao.insertUser(user);
            System.out.println("注册用户成功");
            return true;
        }
        System.out.println("用户已存在，注册失败");
        return false;
    }

    @Override
    public boolean insertUser(User user) {
        List<User> userList=iUserDao.selectUserById(user.getId());
        if(userList.size()==0){
            iUserDao.insertUser(user);
            System.out.println("增加用户成功");
            return true;
        }
        System.out.println("用户已存在，增加用户失败");
        return false;
    }

    @Override
    public boolean deleteUserById(Integer id) {
        List<User> userList=iUserDao.selectUserById(id);
        if(userList.size()==0){
            System.out.println("用户不存在");
            return false;
        }
        iUserDao.deleteUserById(id);
        System.out.println("用户删除成功");
        return true;
    }

    @Override
    public boolean updateUser(Integer id, User user)  {
        List<User> userList=iUserDao.selectUserById(id);
        if(userList.size()==0){
            System.out.println("用户不存在，更改用户信息失败");
            return false;
        }
        iUserDao.updateUser(id, user);
        System.out.println("更改用户信息成功");
        return true;
    }

    @Override
    public User selectUserById(Integer id)  {
        List<User> userList=iUserDao.selectUserById(id);
        if(userList.size()==0){
            return null;
        }else {
            User user=userList.get(0);
            System.out.println(user);
            return user;
        }
    }

    @Override
    public String selectUser() {
        List<User> userList= iUserDao.selectUser();
        for (int i = 0; i < userList.size(); i++) {
            User user=userList.get(i);
            System.out.println(user);
        }
        return userList.toString();
    }
}

//题库Service接口实现
import studio.lyl.questionbankmanagementsystem.dao.IQuestionDao;
import studio.lyl.questionbankmanagementsystem.dao.impl.QuestionDaoImpl;
import studio.lyl.questionbankmanagementsystem.entity.Questions;
import studio.lyl.questionbankmanagementsystem.service.IQuestionServise;

import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/9 16:11
 */
public class QuestionServiceImpl implements IQuestionServise {
    IQuestionDao iQuestionDao=new QuestionDaoImpl();
    @Override
    public boolean insetQuestion(Questions questions) {
        try {
            iQuestionDao.insetQuestion(questions);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }

    @Override
    public boolean deleteQuestion(int sign, String type) {
        List<Questions> questionsList=iQuestionDao.selectQuestion(sign,type);
        if(questionsList.size()==0){
            System.out.println("题目不存在！");
            return false;
        }else {
            try {
                iQuestionDao.deleteQuestion(sign, type);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("题目已删除");
            return true;
        }
    }

    @Override
    public boolean updateQuestion(int sign, String type, Questions questions) {
        List<Questions> questionsList=iQuestionDao.selectQuestion(sign, type);
        if(questionsList.size()==0){
            System.out.println("题目不存在！");
            return false;
        }else {
            try {
                iQuestionDao.deleteQuestion(sign, type);
                iQuestionDao.insetQuestion(questions);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("题目更改成功。");
            return true;
        }
    }

    @Override
    public Questions selectQuestion(int sign, String type) {
        List<Questions> questionsList=iQuestionDao.selectQuestion(sign, type);
        if(questionsList.size()==0){
            return null;
        }else {
            Questions questions=questionsList.get(0);
            return  questions;
        }
    }

    @Override
    public List<Questions> selectQuestions(String type) {
        List<Questions> questionsList=iQuestionDao.selectQuestions(type);
        if(questionsList.size()==0){
            System.out.println("该题库暂无题目");
            return null;
        }else {
            for (int i = 0; i < questionsList.size(); i++) {
                System.out.println(questionsList.get(i));
            }
            return questionsList;
        }
    }


    @Override
    public Questions selectAnswer( int sign,String type) {
        List<Questions> questionsList=iQuestionDao.selectQuestion(sign,type);
        if(questionsList.size()==0){
            System.out.println("该题库暂无题目");
            return null;
        }else {
            Questions questions=questionsList.get(0);
            System.out.println("本题答案为:   "+questions.getAnswer());
            return null;
        }
    }
}

//笔记Service接口实现
import studio.lyl.questionbankmanagementsystem.dao.INoteDao;
import studio.lyl.questionbankmanagementsystem.dao.impl.NoteDaoImpl;
import studio.lyl.questionbankmanagementsystem.entity.Note;
import studio.lyl.questionbankmanagementsystem.service.INoteService;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/11 20:17
 */
public class NoteServiceImpl implements INoteService {
    INoteDao iNoteDao=new NoteDaoImpl();
    @Override
    public boolean insetNote(Note note) {
        iNoteDao.insetNote(note);
        System.out.println("添加笔记成功");
        return true;
    }

    @Override
    public boolean deleteNote(Integer id,Integer sign) {
        List<Note> noteList=iNoteDao.selectNoteById(id);
        if(noteList.size()==0){
            System.out.println("笔记不存在！");
            return false;
        }else {
            iNoteDao.deleteNote(id,sign);
            System.out.println("笔记已删除。");
            return true;
        }
    }

    @Override
    public boolean updateNote(Integer id,Integer sign, Note note) {
        List<Note> noteList = iNoteDao.selectNoteById(id);
        if (noteList.size() == 0) {
            System.out.println("笔记不存在！");
            return false;
        } else {
            List<Note> noteListBySign = new ArrayList<>();
            for (int i = 0; i < noteList.size(); i++) {
                Note noteBySign = noteList.get(i);
                if (noteBySign.getSign() == sign) {
                    noteListBySign.add(noteBySign);
                }
            }
            if (noteListBySign.size() == 0) {
                System.out.println("笔记不存在");
            } else {
                iNoteDao.updateNote(id, sign, note);
                System.out.println("笔记已更改。");

            }
        }
        return true;
    }

    @Override
    public List<Note> selectNoteById(Integer id) {
        List<Note> noteList=iNoteDao.selectNoteById(id);
        if(noteList.size()==0){
            return null;
        }else {
            return noteList;
        }
    }

    @Override
    public List<Note> selectNote() {
        List<Note> noteList=iNoteDao.selectNote();
        if(noteList.size()==0){
            System.out.println("现无笔记存在。");
            return null;
        }else {
            return noteList;
        }
    }
}

Controller

//用户Controller层
import studio.lyl.questionbankmanagementsystem.entity.User;
import studio.lyl.questionbankmanagementsystem.service.IUserService;
import studio.lyl.questionbankmanagementsystem.service.impl.UserServiceImpl;

/**
 * @Author: Re
 * @Date: 2020/12/11 22:05
 */
public class UserController {
    IUserService iUserService=new UserServiceImpl();

    /**
     *登录用户
     * @param id
     * @param password
     * @return boolean
     * @throws Exception
     */
    public boolean loginUser(Integer id,String password) {
        return iUserService.loginUserService(id, password);
    }

    public boolean loginAdministrator(Integer id,String password){
        return iUserService.loginAdministratorService(id,password);
    }

    /**
     *注册用户
     * @param user
     * @return boolean
     * @throws Exception
     */
    public boolean registUser(User user) {
        return iUserService.registService(user);
    }

    /**
     * 创建用户
     * @param user
     * @return boolean
     */
    public boolean insertUser(User user) {
        return iUserService.insertUser(user);
    }

    /**
     * 根据id删除用户
     * @param id
     * @return boolean
     */
    public boolean deleteUserById(Integer id) {
        return iUserService.deleteUserById(id);
    }

    /**
     * 根据用户id修改用户信息
     * @param id
     * @return boolean
     */
    public boolean updateUser(Integer id,User user) {
        return iUserService.updateUser(id, user);
    }

    /**
     * 根据id查看用户信息
     * @param id
     * @return String
     */
    public User selectUserById(Integer id) {
        return iUserService.selectUserById(id);
    }

    /**
     * 查看所有用户信息
     * @return
     * @throws Exception
     */
    public String selectUser() {
        return iUserService.selectUser();
    }
}

//题库controller层
import studio.lyl.questionbankmanagementsystem.entity.Questions;
import studio.lyl.questionbankmanagementsystem.service.IQuestionServise;
import studio.lyl.questionbankmanagementsystem.service.impl.QuestionServiceImpl;

import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/11 22:02
 */
public class QuestionsController {
    IQuestionServise iQuestionServise=new QuestionServiceImpl();

    /**
     * 增加题目
     * @param questions
     * @return boolean
     */
    public boolean insetQuestion(Questions questions) {
        return iQuestionServise.insetQuestion(questions);
    }

    /**
     * 根据序号删除题目
     * @param sign
     * @param type
     * @return boolean
     */
    public boolean deleteQuestion(int sign,String type) {
        return iQuestionServise.deleteQuestion(sign, type);
    }

    /**
     * 根据序号更改题目
     * @param sign
     * @param questions
     * @param type
     * @return
     */
    public boolean updateQuestion(int sign ,String type ,Questions questions) {
        return iQuestionServise.updateQuestion(sign, type, questions);
    }

    /**
     * 根据序号查看题目
     * @param sign
     * @param type
     * @return question
     */
    public Questions selectQuestion(int sign, String type) {
        return iQuestionServise.selectQuestion(sign, type);
    }

    /**
     * 查看一个类型中所有的题目
     * @param type
     * @return
     * @throws Exception
     */
    public List<Questions> selectQuestions(String type) {
        return iQuestionServise.selectQuestions(type);
    }

    /**
     * 根据题目类型和序号查看题目答案
     * @param type
     * @return Question
     */
    public Questions selectAnswer(int sign,String type){
        return iQuestionServise.selectAnswer(sign , type);
    }
}

//笔记controller层
package studio.lyl.questionbankmanagementsystem.controller;

import studio.lyl.questionbankmanagementsystem.entity.Note;
import studio.lyl.questionbankmanagementsystem.service.INoteService;
import studio.lyl.questionbankmanagementsystem.service.impl.NoteServiceImpl;

import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/11 21:58
 */
public class NoteController {
    INoteService iNoteService=new NoteServiceImpl();
    /**
     * 增加笔记
     * @param note
     * @return boolean
     */
    public boolean insetNote(Note note) {
        return iNoteService.insetNote(note);
    }

    /**
     * 根据用户id删除笔记
     * @param id
     * @return boolean
     */
    public boolean deleteNote(Integer id,Integer sign) {
        return iNoteService.deleteNote(id,sign);
    }

    /**
     * 根据用户id更改笔记
     * @param id
     * @param sign
     * @param note
     * @return
     */
    public boolean updateNote(Integer id,Integer sign,Note note) {
        return iNoteService.updateNote(id,sign ,note);
    }

    /**
     * 根据用户id查看笔记
     * @param id
     * @return
     */
    public List<Note> selectNoteById(Integer id) {
        return iNoteService.selectNoteById(id);
    }

    /**
     * 查看所有的笔记
     * @return
     */
    public List<Note> selectNote() {
        return iNoteService.selectNote();
    }
}

View

//用户View层
import studio.lyl.questionbankmanagementsystem.controller.UserController;
import studio.lyl.questionbankmanagementsystem.entity.User;
import studio.lyl.questionbankmanagementsystem.service.IUserService;
import studio.lyl.questionbankmanagementsystem.service.impl.UserServiceImpl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @Author: Re
 * @Date: 2020/12/11 22:28
 */
public class UserView {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    UserController userController=new UserController();
    String id= null;

    public boolean loginAdministrator(){
        System.out.println("欢迎进入登录界面");
        System.out.println("请输入账号");
        String password=null;
        try {
            boolean re=true;
            while (re){
            id = bufferedReader.readLine();
            if(id==null){
                System.out.println("输入的账号有误请，重新输入");
                continue;
            }else {
                try {
                    Integer.parseInt(id);
                } catch (NumberFormatException e) {
                    System.out.println("输入的账号有误请，重新输入");
                    continue;
                }
            }
            re=false;
            }
            System.out.println("请输入密码");
            password=bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return userController.loginAdministrator(Integer.parseInt(id),password);
    }

    public boolean loginUser() {
        System.out.println("欢迎进入登录界面");
        System.out.println("请输入账号");
        String password=null;
        try {
            boolean re=true;
            while (re){
                id = bufferedReader.readLine();
                if(id==null){
                    System.out.println("输入的账号有误请，重新输入");
                    continue;
                }else {
                    try {
                        Integer.parseInt(id);
                    } catch (NumberFormatException e) {
                        System.out.println("输入的账号有误请，重新输入");
                        continue;
                    }
                }
                re=false;
            }
            System.out.println("请输入密码");
            password=bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return userController.loginUser(Integer.parseInt(id),password);
    }

    public void registUser() {
        System.out.println("欢迎进入注册界面");
        System.out.println("请输入您想要的账号");
        try {
            boolean re=true;
            while (re){
                id = bufferedReader.readLine();
                if(id==null){
                    System.out.println("输入的账号有误请，重新输入");
                    continue;
                }else {
                    try {
                        Integer.parseInt(id);
                    } catch (NumberFormatException e) {
                        System.out.println("输入的账号有误请，重新输入");
                        continue;
                    }
                }
                re=false;
            }
            System.out.println("请输入你的密码");
            String password=bufferedReader.readLine();
            System.out.println("请输入你的昵称");
            String userName=bufferedReader.readLine();
            User user=new User(Integer.parseInt(id),password,userName,0,0,0);
            userController.registUser(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void insertUser() {
        System.out.println("欢迎进入增加用户界面");
        System.out.println("请输入您想要的账号");
        String id= null;
        try {
            id = bufferedReader.readLine();
            System.out.println("请输入您的密码");
            String password=bufferedReader.readLine();
            System.out.println("请输入你的昵称");
            String userName=bufferedReader.readLine();
            User user=new User(Integer.parseInt(id),password,userName,0,0,0);
            userController.insertUser(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void deleteUserById() {
        System.out.println("欢迎进入用户删除界面");
        System.out.println("请输入您想删除的用户账号");
        String userId;
        try {
            userId = bufferedReader.readLine();
            userController.deleteUserById(Integer.parseInt(userId));
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void updateUser() {
        System.out.println("欢迎进入更改用户信息界面");
        try {
            IUserService iUserService=new UserServiceImpl();
            User userInterposition=iUserService.selectUserById(Integer.parseInt(id));
            System.out.println("请输入新密码");
            String updatePassword=bufferedReader.readLine();
            System.out.println("请输入新昵称");
            String updateUserName=bufferedReader.readLine();
            User user=new User(Integer.parseInt(id),updatePassword,updateUserName,userInterposition.getNodeCount(),userInterposition.getCollectionCount(),userInterposition.getLevel());
            userController.updateUser(Integer.parseInt(id),user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void selectUserById() {
        System.out.println("欢迎进入用户查询界面");
        System.out.println("用户信息如下");
        userController.selectUserById(Integer.parseInt(id));
    }

    public void selectUser() {
        System.out.println("欢迎进入用户查询界面");
        System.out.println("用户信息如下");
        userController.selectUser();
    }
}

//题库View层
import studio.lyl.questionbankmanagementsystem.controller.QuestionsController;
import studio.lyl.questionbankmanagementsystem.entity.Questions;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/11 22:29
 */
public class QuestionsView {
    QuestionsController questionsController=new QuestionsController();
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    public void insetQuestion() {
        System.out.println("欢迎进入添加题目界面");
        System.out.println("请输入题目类型");
        System.out.println("类型可分为 Math，English，Thought，HighLevelLanguage。");
        String type= null;
        try {
            type = bufferedReader.readLine();
            System.out.println("请输入内容");
            String content=bufferedReader.readLine();
            System.out.println("请输入题目答案");
            String answer=bufferedReader.readLine();
            System.out.println("请输入题目难易程度");
            String complexity=bufferedReader.readLine();
            List<Questions> questionsList=questionsController.selectQuestions(type);
            if (questionsList==null){
                Questions questions = new Questions(content, type, 1, complexity, answer);
                questionsController.insetQuestion(questions);
            }else {
                Questions questions = new Questions(content, type, questionsList.size() + 1, complexity, answer);
                questionsController.insetQuestion(questions);
            }
            System.out.println("添加题目成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void deleteQuestion() {
        System.out.println("欢迎进入删除题目页面");
        System.out.println("请输入题目类型");
        System.out.println("类型可分为 Math，English，Thought，HighLevelLanguage。");
        String type= null;
        try {
            type = bufferedReader.readLine();
            System.out.println("请输入题目序号");
            String sign=bufferedReader.readLine();
            questionsController.deleteQuestion(Integer.parseInt(sign),type);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void updateQuestion() {
        System.out.println("欢迎进入更改题目界面");
        System.out.println("请输入更改题目类型");
        System.out.println("类型可分为 Math，English，Thought，HighLevelLanguage。");
        String type= null;
        try {
            type = bufferedReader.readLine();
            System.out.println("请输入更改题目的序号");
            String sign=bufferedReader.readLine();
            System.out.println("请输入更改后内容");
            String content=bufferedReader.readLine();
            System.out.println("请输入更改后题目答案");
            String answer=bufferedReader.readLine();
            System.out.println("请输入更改后题目难易程度");
            String complexity=bufferedReader.readLine();
            Questions questions=new Questions(content,type,Integer.parseInt(sign),complexity,answer);
            questionsController.updateQuestion(Integer.parseInt(sign),type,questions);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void selectAnswer(int sign,String type){
        questionsController.selectAnswer(sign,type);
    }

    public void selectQuestion(int sign,String type) {
        System.out.println(questionsController.selectQuestion(sign,type));
    }

    public void selectQuestions(String type) {
        questionsController.selectQuestions(type);
    }
}

//笔记View层
import studio.lyl.questionbankmanagementsystem.controller.NoteController;
import studio.lyl.questionbankmanagementsystem.entity.Note;
import studio.lyl.questionbankmanagementsystem.entity.User;
import studio.lyl.questionbankmanagementsystem.service.IUserService;
import studio.lyl.questionbankmanagementsystem.service.impl.UserServiceImpl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

/**
 * @Author: Re
 * @Date: 2020/12/11 22:29
 */
public class NoteView {
    NoteController noteController = new NoteController();
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    String id;

    public void insetNote() {
        System.out.println("欢迎进入添加笔记界面");
        System.out.println("请输入用户的id");
        try {
            IUserService iUserService = new UserServiceImpl();
            id = bufferedReader.readLine();
            User user = iUserService.selectUserById(Integer.parseInt(id));
            System.out.println("请输入你想记录的内容");
            String content = bufferedReader.readLine();
            List<Note> noteListById = noteController.selectNoteById(Integer.parseInt(id));
            List<Note> noteList = noteController.selectNote();
            if(noteList==null&&noteListById==null){
                if (user == null) {
                    System.out.println("用户不存在");
                } else {
                    Note note = new Note(user.getName(), Integer.parseInt(id),  1,  1, content);
                    noteController.insetNote(note);
                }
            }else if(noteListById==null) {
                if (user == null) {
                    System.out.println("用户不存在");
                } else {
                    Note note = new Note(user.getName(), Integer.parseInt(id), noteList.size() + 1,  1, content);
                    noteController.insetNote(note);
                }
            }else {
                if (user == null) {
                    System.out.println("用户不存在");
                } else {
                    System.out.println(user);
                    System.out.println(noteList);
                    System.out.println(noteListById);
                    Note note = new Note(user.getName(), Integer.parseInt(id), noteList.size() + 1, noteListById.size() + 1, content);
                    noteController.insetNote(note);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void deleteNote() {
        System.out.println("欢迎进入删除笔记界面");
        System.out.println("请输入您想删除笔记的用户id");
        try {
            System.out.println("请输入您想删除的序号");
            String sign = bufferedReader.readLine();
            noteController.deleteNote(Integer.parseInt(id), Integer.parseInt(sign));
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void updateNote() {
        System.out.println("欢迎进入更改笔记界面");
        System.out.println("请输入需要更改笔记的用户id");
        try {
            id = bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("请输入需要修改的内容");
        String content;
        try {
            content = bufferedReader.readLine();
            List<Note> noteListById = noteController.selectNoteById(Integer.parseInt(id));
            List<Note> noteList = noteController.selectNote();
            IUserService iUserService = new UserServiceImpl();
            User user = iUserService.selectUserById(Integer.parseInt(id));
            if (user == null) {
                System.out.println("用户不存在");
            } else {
                Note note = new Note(user.getName(), Integer.parseInt(id), noteList.size(), noteListById.size(), content);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public boolean selectNoteById() {
        System.out.println("欢迎进入笔记查询界面");
        System.out.println("请输入您要查询笔记的用户id");
        String id = null;
        try {
            id = bufferedReader.readLine();
            System.out.println("查询结果如下");
            List<Note> noteList = noteController.selectNoteById(Integer.parseInt(id));
            if (noteList==null) {
                System.out.println("用户无笔记存在");
                return true;
            } else {
                for (int i = 0; i < noteList.size(); i++) {
                    System.out.println(noteList.get(i));
                }
            }
            } catch(IOException e){
                e.printStackTrace();
            }
            return true;
        }

    public boolean selectNote() {
        System.out.println("欢迎进入笔记查询界面");
        System.out.println("查询结果如下");
        List<Note> noteList = noteController.selectNote();
        for (int i = 0; i < noteList.size(); i++) {
            System.out.println(noteList.get(i));
        }
        return true;
    }
}

//SeparationView层
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @Author: Re
 * @Date: 2020/12/16 0:09
 */
public class Separation {
    BufferedReader bufferedReader = null;
    public void separation() {
        NoteView noteView = new NoteView();
        QuestionsView questionsView = new QuestionsView();
        UserView userView = new UserView();
        boolean symbolUser = false;
        boolean symbolAdministrator = false;
        boolean re0 = true;
        while (re0) {
            System.out.println("*********请选择页面进入*********");
            System.out.println("1.注册      2.登录     3.管理员登录   4.退出系统");
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            String chioce = null;
            try {
                chioce = bufferedReader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            switch (chioce) {
                case "1":
                    userView.registUser();
                    re0 = false;
                    break;
                case "2":
                    symbolUser = userView.loginUser();
                    re0 = !symbolUser;
                    break;
                case "3":
                    symbolAdministrator = userView.loginAdministrator();
                    re0 = !symbolAdministrator;
                    break;
                case "4":
                    re0 = false;
                    break;
                default:
                    System.out.println("您输入的数据有误");
            }
        }


        if (symbolUser) {
            boolean re = true;
            boolean symbolQuestion = false;
            boolean symbolNote = false;
            while (re) {
                System.out.println("*********请选择页面进入*********");
                System.out.println("1.更改用户信息  2.查询用户信息  3.进入题库  4. 查看笔记   5.退出程序");
                String chioceSecond = null;
                try {
                    chioceSecond = bufferedReader.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                switch (chioceSecond) {
                    case "1":
                        userView.updateUser();
                        break;
                    case "2":
                        userView.selectUserById();
                        break;
                    case "3":
                        symbolQuestion = true;
                        break;
                    case "4":
                        symbolNote = noteView.selectNoteById();
                        break;
                    case "5":
                        re = false;
                        break;
                    default:
                        System.out.println("您输入的数据有误");
                        break;
                }
                if (symbolQuestion) {
                    System.out.println("欢迎进入题库");
                    System.out.println("*********请选择页面进入*********");
                    System.out.println("请输入您想查找的题目类型");
                    System.out.println("类型可分为 Math，English，Thought，HighLevelLanguage。");
                    String type = null;
                    String sign= null;
                    boolean re1=true;
                    try {
                        while (re1) {
                            type = bufferedReader.readLine();
                            if(type.equals("Math")||type.equals("English")||type.equals("Thought")||type.equals("HighLevelLanguage")){
                              re1=false;
                            }else {
                                System.out.println("输入错误，请重新输入");
                            }
                        }
                        System.out.println("请输入需要查找的题目序号");
                        sign= bufferedReader.readLine();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    questionsView.selectQuestion(Integer.parseInt(sign),type);
                    System.out.println("是否查看该题答案");
                    System.out.println("1. 是      2.返回主界面");
                    try {
                        chioceSecond=bufferedReader.readLine();
                        switch (chioceSecond){
                            case "1":
                                questionsView.selectAnswer(Integer.parseInt(sign),type);
                                break;
                            case "2":
                                break;
                            default:
                                System.out.println("输入的数据有误");
                                break;
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                symbolQuestion = false;

                if (symbolNote) {
                    System.out.println("*********请选择页面进入*********");
                    System.out.println("1.增加笔记  2.删除笔记  3.更改笔记  4.查看笔记  5.退出程序");
                    String chioceForth = null;
                    try {
                        chioceForth = bufferedReader.readLine();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    switch (chioceForth) {
                        case "1":
                            noteView.insetNote();
                            break;
                        case "2":
                            noteView.deleteNote();
                            break;
                        case "3":
                            noteView.updateNote();
                            break;
                        case "4":
                            noteView.selectNoteById();
                            break;
                        case "5":
                            re = false;
                            break;
                        default:
                            System.out.println("您输入的数据有误");
                            break;
                    }
                }
                symbolNote=false;
            }
        }

        if (symbolAdministrator) {
            boolean re = true;
            boolean symbolQuestion = false;
            boolean symbolNote = false;
            while (re) {
                System.out.println("*********请选择页面进入*********");
                System.out.println("1.增添用户      2.查看所有用户信息      3更改管理员信息        4.根据账号删除用户      5.进入题库        6.查看用户笔记      7.退出程序");
                BufferedReader bufferedReaderSecond = new BufferedReader(new InputStreamReader(System.in));
                String chioceSecond = null;
                try {
                    chioceSecond = bufferedReaderSecond.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                switch (chioceSecond) {
                    case "1":
                        userView.insertUser();
                        break;
                    case "2":
                        userView.selectUser();
                        break;
                    case "3":
                        userView.updateUser();
                        break;
                    case "4":
                        userView.deleteUserById();
                        break;
                    case "5":
                        symbolQuestion = true;
                        break;
                    case "6":
                        symbolNote = noteView.selectNote();
                        break;
                    case "7":
                        re = false;
                        break;
                    default:
                        System.out.println("您输入的数据有误");
                        break;
                }
                    if (symbolQuestion) {
                        System.out.println("欢迎进入题库");
                        System.out.println("*********请选择页面进入*********");
                        System.out.println("请输入您想查看的题目类型");
                        System.out.println("类型可分为 Math，English，Thought，HighLevelLanguage。");
                        String type = null;
                        boolean re2=true;
                        try {
                            while (re2) {
                                type = bufferedReaderSecond.readLine();
                                if (type.equals("Math")||type.equals("English")||type.equals("Thought")||type.equals("HighLevelLanguage")) {
                                    re2=false;
                                }else{
                                    System.out.println("输入错误，请重新输入");
                                }
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        System.out.println("欢迎进入"+type+"题库");
                        questionsView.selectQuestions(type);
                        System.out.println("*********请选择页面进入*********");
                        System.out.println("1.再次查找----------2.增加题目---------3.删除题目-----------4.更改题目---------6.退出程序");
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
                        String chioceThird = null;
                        try {
                            chioceThird = bufferedReader.readLine();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        switch (chioceThird) {
                            case "1":
                                questionsView.selectQuestions(type);
                                break;
                            case "2":
                                questionsView.insetQuestion();
                                break;
                            case "3":
                                questionsView.deleteQuestion();
                                break;
                            case "4":
                                questionsView.updateQuestion();
                                break;
                            case "5":
                                re = false;
                                break;
                            default:
                                System.out.println("你输入的数据有误");
                        }
                    }
                    symbolQuestion=false;
                if (symbolNote) {
                    System.out.println("*********请选择页面进入*********");
                    System.out.println("1.增加笔记  2.删除笔记  3.更改笔记  4.查看笔记  5.退出程序");
                    String chioceForth = null;
                    try {
                        chioceForth = bufferedReaderSecond.readLine();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    switch (chioceForth) {
                        case "1":
                            noteView.insetNote();
                            break;
                        case "2":
                            noteView.deleteNote();
                            break;
                        case "3":
                            noteView.updateNote();
                            break;
                        case "4":
                            noteView.selectNoteById();
                            break;
                        case "5":
                            re = false;
                            break;
                        default:
                            System.out.println("您输入的数据有误");
                            break;
                    }
                }
                symbolNote=false;
            }
        }
    }
}

Utils

//Creat
import java.io.IOException;

/**
 * @author Ding
 * @date 2019/11/23 19:55
 */
public class Create {
    public static void main(String[] args) throws IOException {
        CreateFileName createFileName=new CreateFileName();
        CreatePathName createPathName=new CreatePathName();
        createPathName.create("QuestionBankManagementSystem");
        createPathName.create("QuestionBankManagementSystem\\Questions");
        createFileName.create("QuestionBankManagementSystem\\Note.txt");
        createFileName.create("QuestionBankManagementSystem\\Questions\\Math.txt");
        createFileName.create("QuestionBankManagementSystem\\Questions\\English.txt");
        createFileName.create("QuestionBankManagementSystem\\Questions\\Thought.txt");
        createFileName.create("QuestionBankManagementSystem\\Questions\\HighLevelLanguage.txt");
        createFileName.create("QuestionBankManagementSystem\\User.txt");
    }
}

//CreateFileName
import java.io.File;
import java.io.IOException;

/**
 * @author Ding
 * @date 2019/11/23 19:54
 */
public class CreateFileName {
    /**
     * 创建文件
     * @param filename
     * @return boolean
     * @throws IOException
     */
    public boolean create(String filename) throws IOException {
        File file = new File(filename);
        file.createNewFile();
        if (file.exists()) {
            return false;
        }
        if (file.createNewFile()) {
            return true;
        } else {
            return false;
        }
    }
}

//CreatePathName
import java.io.File;
import java.io.IOException;

/**
 * @author Ding
 * @date 2019/11/23 19:53
 */
public class CreatePathName {

    /**
     * 创建目录
     * @param Filename
     * @return boolean
     * @throws IOException
     */
    public boolean create(String Filename) throws IOException {
        File file = new File(Filename);
        if (file.exists()) {
            return false;
        }
        if (!Filename.endsWith(File.separator)) {
            Filename = Filename + File.separator;
        }
        if (file.mkdir()) {
            return true;
        } else {
            return false;
        }
    }
}

Main

import studio.lyl.questionbankmanagementsystem.view.*;

/**
 * @Author: Re
 * @Date: 2020/12/7 22:36
 */
public class QuestionBankManagementSystem {
    public static void main(String[] args) {
        Separation separation=new Separation();
        separation.separation();
    }
}

总结

总的来说，这次小组的考核题虽然难，但好在给的时间挺长的，所以我才能好好的完善项目，虽然还有缺点，但我满足了。
这个项目我还认识了个大哥“空指针异常”，真是噩梦。