Java项目实战-基于I/O流设计的图书馆管理系统项目总结
由于目前学习进度的原因，我还未开始学习数据库等知识，所以为了完成项目要求，这次就使用I/O流的知识来进行存储，将书籍信息，用户信息和日志都保存到各自的文件中，再进行增删改查的操作
图书馆管理系统
项目描述：
项目重点知识
- 掌握java基本语法
- 熟悉使用流程控制
- 理解面向对象思想36
- 熟练封装，继承，多态
- 熟悉使用接口，异常
- 熟悉使用集合
- 熟悉掌握I/o流相关操作
功能概述
在我设计的项目里，用户和管理员的登录完全分开。若使用用户登录则无法中途切换为管理员，若使用管理员登录则无法中途切换为用户。
用户界面：
用户进入系统后会看到这张用户界面：
用户界面会展示6种功能，分别是：
- 全部书籍：展示图书馆中所收藏的全部图书，输出书名与借阅状态，不用的登录即可使用。
- 查询书籍：可输入书名来查询书籍的详细信息，会展示书名、作者、售价、书籍分类、出版社与借阅状态，不用的登录即可使用。
- 用户管理;用户通过此界面来进行登录、注册、修改个人信息等操作。
- 借阅书籍：用户通过此功能进行书籍借阅操作，通过输入书名来选择索要借阅的书籍，登陆后使用。
- 归还书籍：用户归还所借阅的书籍，会打印出用户所借阅过得书籍，输入书名后确认归还，登陆后使用。
- 退出系统：结束整个系统。
管理员界面：
管理员需要使用管理员ID来登录管理员界面，有三次尝试机会，都不通过则结束系统。管理员进入系统后会看到这张管理员界面：
管理员界面会展示3 种功能，分别是：
- 书籍管理：用于管理书籍信息，可以查看全部书籍、查询书籍、添加书籍、修改书籍信息、删除书籍和查看日志。
- 用户管理： 用于管理用户信息，主要是查看用户列表、查询用户信息与删除用户。
- 退出系统：结束整个系统。
详细代码：
Test类
运行测试类
public class Test {
public static void main(String[] args) throws Exception {
Library library = new Library(); //构造Library对象
library.use(); //调用对象的登录方法。
}
}
User类
用户属性定义与重写用户toString方法
public class User {
private String name;//姓名
private String password;//密码
private String sex;//性别
private int age;//年龄
private long phoneNum;//手机号码
private String faculty;//院系
public User(String name,String password,String sex,int age,long phoneNum,String faculty){
this.name = name;
this.password = password;
this.sex = sex;
this.age = age;
this.phoneNum = phoneNum;
this.faculty = faculty;
}
public User(){
}
@Override//重写toString方法
public String toString() {
return name + '\'' + password + '\'' + sex + '\'' + age + '\'' + phoneNum + '\'' + faculty + '\n';
}
//get，set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) { this.password = password; }
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public long getPhoneNum() {
return phoneNum;
}
public void setPhoneNum(long phoneNum) {
this.phoneNum = phoneNum;
}
public String getFaculty() {
return faculty;
}
public void setFaculty(String faculty) {
this.faculty = faculty;
}
}
Books类
书籍属性定义与重写书籍toString方法
public class Books {
private String bookName; //书名
private String author; //作者
private double price; //价格
private String category; //分类
private String press;//出版社
private boolean state; //状态 true：已借出 false：未借出
private String borrowName;//借阅人
private String borrowTime;//借阅时间
public Books(String bookName, String author, double price, String category, String press, boolean state, String borrowName, String borrowTime){
this.bookName = bookName;
this.author = author;
this.price = price;
this.category = category;
this.press = press;
this.state = state;
this.borrowName = borrowName;
this.borrowTime = borrowTime;
}
public Books(){
}
@Override//重写toString方法
public String toString() {
return bookName +'\''+author+'\''+price+'\''+category+'\''+press+'\''+state+'\''+borrowName+'\''+borrowTime+'\n';
}
//get，set方法
public String getBookName() { return bookName; }
public void setBookName(String bookName) { this.bookName = bookName; }
public String getAuthor() { return author; }
public void setAuthor(String author) { this.author = author; }
public double getPrice() { return price; }
public void setPrice(double price) { this.price = price; }
public String getCategory() { return category; }
public void setCategory(String category) { this.category = category; }
public String getPress() { return press; }
public void setPress(String press) { this.press = press; }
public boolean getState() { return state; }
public void setState(boolean state) { this.state = state; }
public String getBorrowName() { return borrowName; }
public void setBorrowName(String borrowName) { this.borrowName = borrowName; }
public String getBorrowTime() { return borrowTime; }
public void setBorrowTime(String borrowTime) { this.borrowTime = borrowTime; }
}
Library类
这里主要是选择以用户还是以管理员登录
import java.util.Scanner;
public class Library {
Scanner scanner = new Scanner(System.in);
InException ie = new InException();//排错
public static final int PASSWORD = 1234;//管理员ID
public int logInCount;//登录状态输入标志量
public void use() throws Exception {
//输入前的用户提示
System.out.println("===============图书管理系统===============");
System.out.println(" 请选择登录状态：1.普通用户 2.管理员 3.退出 ");
//输入排错
logInCount = ie.inputErr(logInCount);
//以用户身份进入
if (logInCount == 1){
System.out.println("欢迎使用本系统");
UserInterface userInterface = new UserInterface();
userInterface.userMenu();
}
//以管理员身份进入
if (logInCount == 2){
System.out.println("==========请输入身份ID==========");
int times = 3;//最大输入次数
int key = 0;//定义管理员ID
//输入次数判定
while(times > 0){
System.out.print("请输入ID：");
key = ie.inputErr(key);//管理员输入ID
//输入错误判断与提示（完）
if (key != PASSWORD){
//3次全错，退出系统（完）
if (times <= 1){
times = 0;
System.out.println("超过最大次数，退出系统");
System.exit(0);
}
System.out.println("ID不正确，请重新输入，目前还可尝试" + (times-1) + "次");
times--;
}
//输入正确判断与提示
if (key == PASSWORD){
times = 0;
System.out.println("欢迎金馆长！");
BackstageInterface backstageInterface = new BackstageInterface();
backstageInterface.rootMenu();
}
}
}
//退出程序(完)
if (logInCount >= 3 || logInCount <= 0){
System.out.println("即将结束系统，感谢您的使用！");
System.exit(0);
}
}
}
InException类
这里主要是排除输入异常的，将非数字的输入挡在外面。这里其实可以进行优化，不必结束系统。
import java.util.Scanner;
public class InException {
Scanner scanner = new Scanner(System.in);
public int inputErr(int count){
try{
count = scanner.nextInt();//输入你的选择选择
}catch (Exception e){
System.err.println("输入不符合规范退出系统");
System.exit(0);
}
return count;
}
}
UserInterface类
用户界面，用户可以使用的所有功能都在其中
import Books.AllBook;
import Books.FindBook;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
public class UserInterface {
Scanner scanner = new Scanner(System.in);
InException ie = new InException();//排错
File fileUser = new File("用户信息.txt");
File fileBook = new File("书籍.txt");
User user = new User();//存放的是现在正在进行操作的用户信息
List<String> listUser = new ArrayList<>();//创建个list集合，登录处最开始使用
List<String> listBook = new ArrayList<>();//创建个list集合，存放书籍信息
boolean managementFlag = true, modifyFlag = true;//while循环标志位，分别是：用户管理界面标志量/修改信息界面标志量
public int userCount;//用户菜单输入标志量
public int userInfoCount;//用户管理界面输入标志量
public int userModifyCount;//修改信息界面输入标志量
public int borrowBookIf;//借阅界面确认输入标志量
public long dayTime = 30;//最大借阅时间设定
String nowUser;//现在使用系统的用户信息
//用户菜单
public void userMenu() throws Exception {
while (true) {
System.out.println("==========图书管理系统==========");
System.out.println(" 1.全部图书 2.查询书籍 3.用户管理 ");
System.out.println(" 4.借阅书籍 5.归还书籍 6.退出系统 ");
userCount = ie.inputErr(userCount);//排错
//全部图书(完)
if (userCount == 1) {
AllBook allBook = new AllBook();
allBook.allBooks();
System.out.println(" ");
}
//查询书籍(完)
if (userCount == 2) {
FindBook findBook = new FindBook();
findBook.findBooks();
System.out.println(" ");
}
//用户管理(完)
if (userCount == 3) {
userManagement();//本类用户管理界面方法
System.out.println(" ");
}
//借阅书籍
if (userCount == 4) {
//读取书籍文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String bookString;
while ((bookString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
listBook.add(bookString);//一行放入一位list集合
}
reader.close();//关闭流
userBorrowBooks();
listBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//归还书籍
if (userCount == 5) {
//读取书籍文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String bookString;
while ((bookString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
listBook.add(bookString);//一行放入一位list集合
}
reader.close();//关闭流
userReturnBooks();
listBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//退出(完)
if (userCount >= 6 || userCount <= 0) {
System.out.println("即将结束系统，感谢您的使用！");
System.exit(0);
}
}
}
//3#用户管理界面(完)
public void userManagement() throws Exception {
managementFlag = true;
while (managementFlag) {
System.out.println("=======用户管理界面======");
System.out.println(" 1.登录 2.注册 3.修改信息 ");
System.out.println(" 输入其他数字返回上一层 ");
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileUser)));//缓冲流读取一个转换后的字符流数据
String tempString;
while ((tempString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
listUser.add(tempString);//一行放入一位list集合
}
reader.close();//关闭流
//System.out.println(listUser.size());
userInfoCount = ie.inputErr(userInfoCount);//排错
//登录(完)
if (userInfoCount == 1) {
userLogin();
listUser.clear();
break;
}
//注册(完)
if (userInfoCount == 2) {
userSignUp();
listUser.clear();
System.out.println(" ");
}
//修改信息(完)
if (userInfoCount == 3) {
userModify();
listUser.clear();
System.out.println(" ");
}
//返回上一层(完)
if (userInfoCount >= 4 || userInfoCount <= 0) {
managementFlag = false;
}
}
}
//3.1#用户管理界面——登录界面(完)
public void userLogin () throws Exception{
System.out.println("=======登 录======");
System.out.print("请输入用户名：");
String userLoginName = scanner.next();
System.out.print("请输入密码：");
String userLoginPassword = scanner.next();
//用户信息一个人也没有，直接跳出（完）
if (listUser.size() == 0){
System.out.println("第一位用户你好，请先注册");
}
//判断输入的用户名是否存在
boolean flag = false;
String[] userInf = new String[6];//开辟一个6位的String数组
//增强for判断用户名是否存在
for (String users : listUser) {
userInf = users.split("\'");//检测分隔符为" ' "
//判断用户名是否存在
if (userLoginName.equals(userInf[0])) {
flag = true;
break;
}
}
//如果存在，判断密码是否正确
if (flag){
if (userLoginPassword.equals(userInf[1])) {
System.out.println("登陆成功");
//把当前用户信息放入User
user.setName(userInf[0]);
user.setPassword(userInf[1]);
user.setSex(userInf[2]);
user.setAge(Integer.parseInt(userInf[3]));
user.setPhoneNum(Long.parseLong(userInf[4]));
user.setFaculty(userInf[5]);
//把当前用户信息放入一个字符串中
nowUser = (userInf[0] + '\'' + userInf[1] + '\'' + userInf[2] + '\'' + userInf[3] + '\'' + userInf[4] + '\'' + userInf[5]);
//记录日志
Log log = new Log(userInf[0]);
log.logRecord("登录了系统");
} //登陆成功
else {
System.out.println("密码错误");
}//密码错误
}
else {
System.out.println("用户名不存在");
}//用户名不存在
}
//3.2#用户管理界面——注册界面(完)
public void userSignUp () throws Exception{
String[] userInf = new String[6];//开辟一个6位的String数组,存放用户list的每一行
System.out.println("=======注 册======");
System.out.print("请输入用户名：");
String userSignUpName;
boolean repeat = false;
do {
userSignUpName = scanner.next();
for (String users : listUser) {
userInf = users.split("'");//检测分隔符为" ' "
if (userSignUpName.equals(userInf[0])) {
System.out.print("*用户名重名，请重新输入：");
repeat = true;
break;
}
}
if (!userSignUpName.equals(userInf[0])){
repeat = false;
}
}while (repeat == true);//重名判断
System.out.print("请输入密码：");
String userSignUpPassword = scanner.next();
System.out.print("请输入您的性别：");
String userSignUpSex = scanner.next();
System.out.print("请输入您的年龄：");
int userSignUpAge=1;
do {
while (!scanner.hasNextInt()) {
//没有这一行的话会导致无限循环
String userAge = scanner.next();
System.out.print("不是数字，重新输入年龄");
}//当是数字时循环结束
userSignUpAge = scanner.nextInt();
if (userSignUpAge <= 0){
System.out.println("请正确输入年龄");
}
}while(userSignUpAge <= 0);//不能为负数
System.out.print("请输入您的手机号码：");
long userSignUpPhone=1;
do {
while (!scanner.hasNextInt()) {
//没有这一行的话会导致无限循环
String userPhone = scanner.next();
System.out.print("不是数字，重新输入手机号码");
}//当是数字时循环结束
userSignUpPhone = scanner.nextLong();
if (userSignUpPhone <= 0){
System.out.println("请正确输入手机号");
}
}while (userSignUpPhone <=0);//不能为负数
System.out.print("请输入您的所在院系：");
String userSignUpFaculty = scanner.next();
//创建对象
User signUpUser = new User(userSignUpName, userSignUpPassword, userSignUpSex, userSignUpAge, userSignUpPhone, userSignUpFaculty);
fileUser.createNewFile();//根据抽象路径创建一个新的空文件，当抽象路径制定的文件存在时，创建失败
FileWriter fileWriter = new FileWriter(fileUser, true);//为false时是覆盖写入
fileWriter.write(signUpUser.toString());//写入对象
fileWriter.close();//关闭流
System.out.println("注册成功！");
//记录日志
Log log = new Log(userSignUpName);
log.logRecord("注册了账号");
}
//3.3#用户管理界面——修改信息界面(完)
public void userModify () throws Exception{
modifyFlag = true;
boolean ioFlag = false;//IO修改标志位
String modify = null;//修改用字符串
String[] userInf = new String[6];//开辟一个6位的String数组,存放用户list的每一行
//未登录提示
if (user.getName() == null){
System.out.println("你还未登录，请先去登录");
modifyFlag = false;
}
//修改信息操作，内存
while(modifyFlag){
System.out.println("==========修改信息==========");
System.out.print("1.姓 名:" + user.getName() + "\t");
System.out.println("2.密 码:" + user.getPassword());
System.out.print("3.性 别:" + user.getSex() + "\t");
System.out.println("4.年 龄:" + user.getAge());
System.out.print("5.手机号码:" + user.getPhoneNum() + "\t");
System.out.println("6.所在院系:" + user.getFaculty());
System.out.println(" *输入其他数字确认修改* ");
System.out.print("请输入要修改的数据序号：");
//修改数据临时存放字符串
modify = (user.getName()+'\''+user.getPassword()+'\''+user.getSex()+'\''+user.getAge()+'\''+user.getPhoneNum()+'\''+user.getFaculty());
// System.out.println(modify);
userModifyCount = ie.inputErr(userModifyCount);//排错
//修改姓名
if (userModifyCount == 1){
System.out.print("将姓名改为：");
String userModifyName;
boolean repeat = false;
do {
userModifyName = scanner.next();
for (String users : listUser) {
userInf = users.split("'");//检测分隔符为" ' "
if (userModifyName.equals(userInf[0])) {
System.out.print("*用户名重名，请重新输入：");
repeat = true;
break;
}
}
if (!userModifyName.equals(userInf[0])){
repeat = false;
}
}while (repeat == true);//重名判断
user.setName(userModifyName);
}
//修改密码
if (userModifyCount == 2){
System.out.print("将密码改为：");
String userModifyPassword = scanner.next();
user.setPassword(userModifyPassword);
}
//修改性别
if (userModifyCount == 3){
System.out.print("将性别改为：");
String userModifySex = scanner.next();
user.setSex(userModifySex);
}
//修改年龄
if (userModifyCount == 4){
System.out.print("将年龄改为：");
while (!scanner.hasNextInt()) {
//没有这一行的话会导致无限循环
String userAge = scanner.next();
System.out.print("不是数字，重新输入年龄");
}//当是数字时循环结束
int userModifyAge = scanner.nextInt();
user.setAge(userModifyAge);
}
//修改手机号码
if (userModifyCount == 5){
System.out.print("将手机号码改为：");
while (!scanner.hasNextInt()) {
//没有这一行的话会导致无限循环
String userPhone = scanner.next();
System.out.print("不是数字，重新输入年龄");
}//当是数字时循环结束
long userModifyPhone = scanner.nextLong();
user.setPhoneNum(userModifyPhone);
}
//修改所在院系
if (userModifyCount == 6){
System.out.print("将所在院系改为：");
String userModifyFaculty = scanner.next();
user.setFaculty(userModifyFaculty);
}
//退出，确认修改（完）
if (userModifyCount >= 7 || userModifyCount <= 0){
System.out.println("修改成功,退出修改界面");
ioFlag = true;
break;
}
System.out.println("\n修改后：");
}
//IO修改操作,存储
if(ioFlag){
//对用户列表进行操作
for (int i = 0; i < listUser.size(); i++) { //遍历
if(nowUser.equals(listUser.get(i))) { //如果list中存在与nowUser相同的值，则用modify替换
listUser.set(i, modify); //设置索引为i的值为modify
}
}
//将修改过的用户列表写入文件
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileUser)));//缓冲流读取一个转换后的字符流数据
String strModify;
while ((strModify = reader.readLine()) != null) {//循环读取，readLine是读一行内容
if (strModify.equals(nowUser)) {//读到的与现在运行中的用户数据相同
FileWriter fileWriter = new FileWriter(fileUser, false);//为false时是覆盖写入,写入对象
for (String s : listUser) { //遍历
fileWriter.write(s + "\n");//写入对象
}
fileWriter.close();//关闭流
}
}
reader.close();//关闭流
//记录日志
Log log = new Log(user.getName());
log.logRecord("修改了账号信息"+
"\n原："+nowUser+
"\n现："+modify);
nowUser = modify;//替换nowUser的值,为了下次修改
}
}
//4#借阅书籍界面(完)
public void userBorrowBooks() throws Exception{
String[] bookInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
String nowBook = null;//存放需要借阅的书籍
String needBook;//存放借阅书籍的信息，修改了借阅状态,借阅人和时间
if (user.getName() != null){
System.out.println("========借阅书籍=======");
System.out.print("请输入要借阅的书名：");
String borrowBookName = scanner.next();
//增强for循环，打印要借阅的书籍信息
boolean flag = false;
for (String users : listBook) {
bookInf = users.split("'");//检测分隔符为" ' "
//书籍被借出的判断
if (borrowBookName.equals(bookInf[0]) && bookInf[5].equals("true")){
System.out.println("书籍已被他人借走，你无法借阅");
return;
}
//找到书籍的判断
if (borrowBookName.equals(bookInf[0])) {
//打印找到的书籍
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("书名 \t \t作者");
System.out.println(bookInf[0]+" \t "+ bookInf[1]);
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("售价 \t分类 \t \t \t出版社 \t \t借阅状态");
System.out.println(bookInf[2]+" \t "+ bookInf[3]+" \t "+ bookInf[4]+" \t "+ bookInf[5]);
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
//把当前书籍放入一个字符串中
nowBook=(bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
+'\''+bookInf[4]+'\''+bookInf[5] +'\''+bookInf[6]+'\''+bookInf[7]);
flag = true;
break;
}
}
//借书判断
if(flag) {
System.out.println("是否借阅? 确认(1) 取消（2）");
borrowBookIf = ie.inputErr(borrowBookIf);//输入排错
if (borrowBookIf == 1) {
//读出现在的时间，存入数组
Date nowDate = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String borrowTime = sdf.format(nowDate);
//借出信息放入一个字符串中
needBook=(bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
+'\''+bookInf[4]+'\''+true +'\''+user.getName()+'\''+borrowTime);
//System.out.println(listBook);
for (int i = 0; i < listBook.size(); i++) {
if (nowBook.equals(listBook.get(i))) {
listBook.set(i, needBook);//将借阅信息放入其中
}
}//遍历修改list里的信息
//System.out.println(listBook);
//I/O操作
FileWriter fileWriter = new FileWriter(fileBook);//写入对象
for (String s : listBook) { //遍历
fileWriter.write(s + "\n");//写入对象
}
fileWriter.close();//关闭流
System.out.println("于 "+ borrowTime +" 借阅成功，请于"+ dayTime +"秒内归还，逾期将处以罚金");
//记录日志
Log log = new Log(user.getName());
log.logRecord("借阅了图书 "+"《"+ bookInf[0] +"》");
}//确认借书
else {
System.out.println("取消借书");
}//取消借书
}
else{
System.out.println("未找到该书籍");
}//没找到书籍的判断
}//已登录
else{
System.out.println("你还未登陆，请先登录再来借阅书籍");
}//未登录
}
//5#归还书籍界面(完)
public void userReturnBooks() throws Exception{
String[] bookInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
String nowBook = null;//存放需要借阅的书籍
if (user.getName() != null){
//增强for循环，打印所借阅的书籍信息
boolean flag = false;
System.out.println("===========你所借阅的书籍有===========");
for (String users : listBook) {
bookInf = users.split("'");//检测分隔符为" ' "
//找到用户借阅的书籍
if (bookInf[5].equals("true") && user.getName().equals(bookInf[6])){
System.out.print(bookInf[0] + "\t");
}
}//打印借出的书籍
System.out.println("\n====================================");
//System.out.println(listBook);
System.out.println("请选择你要归还的书籍");
String returnBookName = scanner.next();
//归还图书+判断是逾期
for (String users : listBook) {
bookInf = users.split("'");//检测分隔符为" ' "
//归还用户借阅的书籍
if (returnBookName.equals(bookInf[0]) && user.getName().equals(bookInf[6])){
//将现在的书放入nowBook
nowBook=(bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
+'\''+bookInf[4]+'\''+bookInf[5] +'\''+bookInf[6]+'\''+bookInf[7]);
//判断是否超时，超时需付罚金
Date nowDate = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String returnTime = sdf.format(nowDate);//获取归还时间
Date d1 = sdf.parse(bookInf[7]);//借出时间
Date d2 = sdf.parse(returnTime);//归还时间
long charge = (d2.getTime() - d1.getTime()) / (1000);//秒
//long charge1 = (d2.getTime() - d1.getTime()) / (24 * 60 * 60 * 1000);//天
//逾期书籍将缴纳罚金
if (charge <= dayTime) {
System.out.println("该书籍被您借出" + charge + "秒,感谢您规范用书！");
} else if (charge > dayTime) {
System.out.println("该书籍被您借出" + charge + "秒,您已逾期" + (charge - dayTime) + "秒,需交罚金：" + ((charge - dayTime)/10) * 2 + "元,谢谢配合！");
}
// if (charge1 <= 7) {
// System.out.println("该书籍被您借出" + charge1 + "天,感谢您规范用书！");
// } else if (charge1 > 7) {
// System.out.println("该书籍被您借出" + charge1 + "天,您已逾期" + (charge1 - 7) + "天,需交罚金：" + (charge1 - 7) * 5 + "元,谢谢配合！");
// }
//清除借阅状态和借阅人，借阅时间
for (int i = 0; i < listBook.size(); i++) {
if (nowBook.equals(listBook.get(i))) {
listBook.set(i, bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
+'\''+bookInf[4]+'\''+false+'\''+null+'\''+null);
}//将借出状态变为false，借阅人，时间清空
}//遍历修改list里的信息
//记录日志
Log log = new Log(user.getName());
log.logRecord("归还了图书 "+"《"+ bookInf[0] +"》");
flag = true;
break;
}
//没有借阅该书的判断
if (returnBookName.equals(bookInf[0]) && !(user.getName().equals(bookInf[6]))){
System.out.println("你并没有借阅这本书，无法归还");
}
}
//System.out.println(listBook);
if (flag){
//I/O操作
FileWriter fileWriter = new FileWriter(fileBook);//写入对象
for (String s : listBook) { //遍历
fileWriter.write(s + "\n");//写入对象
}
fileWriter.close();//关闭流
}//I/O操作
}//已登录
else{
System.out.println("你还未登陆，请先登录再来归还书籍");
}//未登录
}
}
BackstageInterface类
管理员界面，管理员可以使用的所有功能都在其中
import Books.AllBook;
import Books.FindBook;
import Books.Books;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class BackstageInterface {
Scanner scanner = new Scanner(System.in);
File fileUser = new File("用户信息.txt");
File fileBook = new File("书籍.txt");
InException ie = new InException();//排错
Books books = new Books();//图书类
List<String> rootListUser = new ArrayList<>();//创建个存放用户的list集合
List<String> rootListBook = new ArrayList<>();//创建个存放图书的list集合
String[] userInf = new String[6];//开辟一个6位的String数组,存放用户list的每一行
String[] bookInf = new String[8];//开辟一个6位的String数组,存放书籍list的每一行
public int rootCount;//管理员菜单输入标志量
public int rootBookCount;//书籍管理界面输入标志量
public int rootUserInfoCount;//用户管理界面输入标志量
public int bookModifyCount;//书籍修改界面输入标志量
public int delUserIf;//用户删除判断
public int delBookIf;//书籍删除判断
boolean managementFlag = true,modifyFlag = true;//while循环标志位，用户管理界面标志量/修改信息界面标志量
public void rootMenu() throws Exception {
while (true) {
System.out.println("==========金馆长的管理系统==========");
System.out.println(" 1.书籍管理 2.用户管理 3.退出系统 ");
rootCount = ie.inputErr(rootCount);//排错
//书籍管理
if (rootCount == 1) {
bookManagement();
System.out.println(" ");
}
//用户管理(完)
if (rootCount == 2) {
rootUserManagement();
System.out.println(" ");
}
//退出(完)
if (rootCount > 2 || rootCount < 1) {
System.out.println("即将结束系统，感谢您的使用！");
System.exit(0);
}
}
}
//1#书籍管理界面
public void bookManagement() throws Exception{
managementFlag = true;
while (managementFlag) {
System.out.println("========书 籍 管 理 界 面=======");
System.out.println(" 1.全部图书 2.查询书籍 3.增加书籍 ");
System.out.println(" 4.查看日志 5.书籍修改 6.删除书籍 ");
System.out.println(" 输入其他数字返回上一层 ");
//读取文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String bookString;
while ((bookString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
rootListBook.add(bookString);//一行放入一位list集合
}
reader.close();//关闭流
//System.out.println(rootListBook.size());//观察集合长度，保证不重复读取
rootBookCount = ie.inputErr(rootBookCount);//排错
//全部图书界面(完)
if (rootBookCount == 1){
AllBook allBook = new AllBook();
allBook.allBooks();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//查询书籍界面(完)
if (rootBookCount == 2){
FindBook findBook = new FindBook();
findBook.findBooks();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//增加书籍界面(完)
if (rootBookCount == 3){
addBook();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//查看日志界面
if (rootBookCount == 4){
Log log = new Log();
log.logRead();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//书籍修改界面(完)
if (rootBookCount == 5){
modifyBook();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//删除书籍界面(完)
if (rootBookCount == 6){
deleteBook();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//返回上一层(完)
if (rootBookCount > 6 || rootBookCount < 1) {
managementFlag = false;
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入,bug
}
}
}
//1.3#书籍管理界面——增加书籍界面(完)
public void addBook () throws Exception{
System.out.println("=======增加书籍======");
System.out.print("请输入书名：");
String addBookName;
boolean repeat = false;
do {
addBookName = scanner.next();
for (String users : rootListBook) {
bookInf = users.split("'");//检测分隔符为" ' "
if (addBookName.equals(bookInf[0])) {
System.out.print("*书籍重名，请重新输入：");
repeat = true;
break;
}
}
if (!addBookName.equals(bookInf[0])){
repeat = false;
}
}while (repeat == true);//重名判断
System.out.print("请输入书籍作者：");
String addBookAuthor = scanner.next();
System.out.print("请输入书籍价格：");
double addBookPrice=1;
do {
while (!scanner.hasNextDouble()) {
//没有这一行的话会导致无限循环
String bookPrice = scanner.next();
System.out.print("不是数字，重新输入价格");
}//当是数字时循环结束
addBookPrice = scanner.nextDouble();
if (addBookPrice <= 0){
System.out.println("请正确输入价格");
}
}while (addBookPrice <= 0);//不能为负数
System.out.print("请输入书籍分类：");
String addBookCategory = scanner.next();
System.out.print("请输入书籍出版社：");
String addBookPress = scanner.next();
//创建对象
Books addNewBook = new Books(addBookName,addBookAuthor,addBookPrice,addBookCategory,addBookPress,false,null,null);
fileBook.createNewFile();//根据抽象路径创建一个新的空文件，当抽象路径制定的文件存在时，创建失败
FileWriter fileWriter = new FileWriter(fileBook, true);//为false时是覆盖写入
fileWriter.write(addNewBook.toString());//写入对象
fileWriter.close();//关闭流
System.out.println("添加成功！");
}
//1.5#书籍管理界面——书籍修改界面(完)
public void modifyBook () throws Exception{
modifyFlag = true;//标志位为true
String modify = null;//修改用字符串
String nowModifyBook = null;//存放现在的书籍
boolean ioFlag = false;//IO修改标志位
String[] bookModifyInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
System.out.println("========书籍修改=======");
System.out.print("请确定要修改的书名：");
String modifyBookName = scanner.next();
//增强for循环，存入找到的书
boolean flag = false;
for (String users : rootListBook) {
bookModifyInf = users.split("'");//检测分隔符为" ' "
//书籍被借出的判断
if (modifyBookName.equals(bookModifyInf[0]) && bookModifyInf[5].equals("true")){
System.out.println("书籍已被借出，无法修改");
return;
}
if (modifyBookName.equals(bookModifyInf[0])) {
books.setBookName(bookModifyInf[0]);//存入书名
books.setAuthor(bookModifyInf[1]);//存入作者
books.setPrice(Double.parseDouble(bookModifyInf[2]));//存入价格
books.setCategory(bookModifyInf[3]);//存入类型
books.setPress(bookModifyInf[4]);//存入出版社
books.setState(Boolean.parseBoolean(bookModifyInf[5]));//存入借阅状态
books.setBorrowName(bookModifyInf[6]);//存入借阅人
books.setBorrowTime(bookModifyInf[7]);//存入借阅时间
//把当前书籍放入一个字符串中
nowModifyBook=(bookModifyInf[0]+'\''+bookModifyInf[1]+'\''+bookModifyInf[2]+'\''+bookModifyInf[3]
+'\''+bookModifyInf[4]+'\''+bookModifyInf[5] +'\''+bookModifyInf[6]+'\''+bookModifyInf[7]);
flag = true;
break;
}
}
if (flag){
while(modifyFlag){
System.out.println("来吧 展示：");
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("(1)书名 \t \t(2)作者");
System.out.println(books.getBookName()+" \t "+ books.getAuthor());
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("(3)售价 \t(4)分类 \t \t \t(5)出版社");
System.out.println(books.getPrice()+" \t "+ books.getCategory()+" \t "+ books.getPress());
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println(" 输入其他数字确认修改 ");
System.out.print("请输入要修改的数据序号：");
modify=(books.getBookName()+'\''+books.getAuthor()+'\''+books.getPrice()+'\''+books.getCategory()+'\''+
books.getPress()+'\''+ bookModifyInf[5]+'\''+ bookModifyInf[6]+'\''+ bookModifyInf[7]);
//System.out.println("while内"+modify);
bookModifyCount = ie.inputErr(bookModifyCount);//排错
//修改书名
if (bookModifyCount == 1){
System.out.print("将书名改为：");
String bookModifyName;
boolean repeat = false;
do {
bookModifyName = scanner.next();
for (String users : rootListBook) {
bookInf = users.split("'");//检测分隔符为" ' "
if (bookModifyName.equals(bookInf[0])) {
System.out.print("*书籍重名，请重新输入：");
repeat = true;
break;
}
}
if (!bookModifyName.equals(bookInf[0])){
repeat = false;
}
}while (repeat == true);//重名判断
books.setBookName(bookModifyName);
}
//修改作者
if (bookModifyCount == 2){
System.out.print("将作者改为：");
String bookModifyAuthor = scanner.next();
books.setAuthor(bookModifyAuthor);
}
//修改售价
if (bookModifyCount == 3){
System.out.print("将售价改为：");
while (!scanner.hasNextDouble()) {
//没有这一行的话会导致无限循环
String userPrice = scanner.next();
System.out.print("不是数字，重新输入价格");
}//当是数字时循环结束
double bookModifyPrice = scanner.nextDouble();
books.setPrice(bookModifyPrice);
}
//修改分类
if (bookModifyCount == 4){
System.out.print("将分类改为：");
String bookModifyCategory = scanner.next();
books.setCategory(bookModifyCategory);
}
//修改出版社
if (bookModifyCount == 5){
System.out.print("将出版社改为：");
String bookModifyPress = scanner.next();
books.setPress(bookModifyPress);
}
//退出，确认修改（完）
if (bookModifyCount > 5 || bookModifyCount < 1){
System.out.println("修改成功,退出修改界面");
ioFlag = true;
break;
}
}
//IO修改操作,存储
if(ioFlag){
//System.out.println("while外"+rootListBook.size());//排bug
//对用户列表进行操作
for (int i = 0; i < rootListBook.size(); i++) { //遍历
if(nowModifyBook.equals(rootListBook.get(i))) { //如果list中存在与nowBook相同的值，则用modify替换
rootListBook.set(i, modify); //设置索引为i的值为modify
}
}
//将修改过的用户列表写入文件
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String strModify;
while ((strModify = reader.readLine()) != null) {//循环读取，readLine是读一行内容
if (strModify.equals(nowModifyBook)) {//读到的与现在运行中的用户数据相同
FileWriter fileWriter = new FileWriter(fileBook, false);//为false时是覆盖写入,写入对象
for (String s : rootListBook) { //遍历
fileWriter.write(s + "\n");//写入对象
}
fileWriter.close();//关闭流
}
}
reader.close();//关闭流
}
}//找到的判断
else{
System.out.println("书籍不存在");
}//没找到的判断
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
}
//1.6#书籍管理界面——删除书籍界面(完)
public void deleteBook () throws Exception{
String delBook = null;//存放现在的书籍
String[] bookDeleteInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
System.out.println("========删除书籍=======");
System.out.print("请确定要删除的书名：");
String delBookName = scanner.next();
System.out.print("请确定要删除书的出版社：");
String delBookPress = scanner.next();
//增强for循环，打印要删除的书籍信息
boolean flag = false;
for (String books : rootListBook) {
bookDeleteInf = books.split("'");//检测分隔符为" ' "
//书籍被借出的判断
if (delBookName.equals(bookDeleteInf[0]) && delBookPress.equals(bookDeleteInf[4]) && bookDeleteInf[5].equals("true")){
System.out.println("书籍已被借出，无法删除");
return;
}
//找到书籍的判断
if (delBookName.equals(bookDeleteInf[0]) && delBookPress.equals(bookDeleteInf[4])) {
//打印找到的书籍
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("书名 \t \t作者");
System.out.println(bookDeleteInf[0]+" \t "+ bookDeleteInf[1]);
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("售价 \t分类 \t \t \t出版社 \t \t借阅状态");
System.out.println(bookDeleteInf[2]+" \t "+ bookDeleteInf[3]+" \t "+ bookDeleteInf[4]+" \t "+ bookDeleteInf[5]);
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
//把当前书籍放入一个字符串中
delBook=(bookDeleteInf[0]+'\''+bookDeleteInf[1]+'\''+bookDeleteInf[2]+'\''+bookDeleteInf[3]
+'\''+bookDeleteInf[4]+'\''+bookDeleteInf[5] +'\''+bookDeleteInf[6]+'\''+bookDeleteInf[7]);
flag = true;
break;
}
}
//删除判断
if(flag) {
System.out.println("是否删除? 确认(1) 取消（2）");
delBookIf = ie.inputErr(delBookIf);//输入排错
if (delBookIf == 1) {
//System.out.println(rootListBook);
for (int i = 0; i < rootListBook.size(); i++) {
if (delBook.equals(rootListBook.get(i))) {
rootListBook.remove(delBook);//删除
}
}//遍历
//System.out.println(rootListBook);
FileWriter fileWriter = new FileWriter(fileBook);//写入对象
for (String s : rootListBook) { //遍历
fileWriter.write(s + "\n");//写入对象
}
fileWriter.close();//关闭流
System.out.println("删除成功");
}//确认删除
else {
System.out.println("取消删除");
}//取消删除
}
else{
System.out.println("未找到该书籍");
}//没找到的判断
}
//2#用户管理界面(完)
public void rootUserManagement() throws Exception{
managementFlag = true;
while (managementFlag) {
System.out.println("========用 户 管 理 界 面=======");
System.out.println(" 1.用户列表 2.用户查询 3.删除用户 ");
System.out.println(" 输入其他数字返回上一层 ");
//读取文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileUser)));//缓冲流读取一个转换后的字符流数据
String userString;
while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
rootListUser.add(userString);//一行放入一位list集合
}
reader.close();//关闭流
//System.out.println(rootListUser.size());//观察集合长度，保证不重复读取
rootUserInfoCount = ie.inputErr(rootUserInfoCount);//排错
//用户列表(完)
if (rootUserInfoCount == 1) {
userList();
rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//用户查询(完)
if (rootUserInfoCount == 2) {
userFind();
rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//删除用户(完)
if (rootUserInfoCount == 3) {
//读取文件写进list
BufferedReader readers = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String bookString;
while ((bookString = readers.readLine()) != null) {//循环读取，readLine是读一行内容
rootListBook.add(bookString);//一行放入一位list集合
}
readers.close();//关闭流
delUser();
rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
System.out.println(" ");
}
//返回上一层(完)
if (rootUserInfoCount > 3 || rootUserInfoCount < 1) {
managementFlag = false;
rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
}
}
}
//2.1#用户管理界面——用户列表(完)
public void userList (){
System.out.println("====================用 户 列 表===================");
System.out.println("姓名 \t密码 \t性别 \t年龄 \t手机号码 \t所在院系");
//增强for循环，遍历打印出list
for (String users : rootListUser) {
userInf = users.split("'");//检测分隔符为" ' "
System.out.println(userInf[0]+" \t "+userInf[1]+" \t "+userInf[2]+" \t "+userInf[3]+" \t \t"+userInf[4]+" \t "+userInf[5]);
}
}
//2.2#用户管理界面——用户查询(完)
public void userFind (){
System.out.println("=======用户查询======");
System.out.print("请输入所要查询用户的姓名：");
String userFindName = scanner.next();
//增强for循环，打印查找到的用户信息
boolean flag = false;
for (String users : rootListUser) {
userInf = users.split("'");//检测分隔符为" ' "
if (userFindName.equals(userInf[0])) {
System.out.println("姓名 \t密码 \t性别 \t年龄 \t手机号码 \t所在院系");
System.out.println(userInf[0]+" \t "+userInf[1]+" \t "+userInf[2]+" \t "+userInf[3]+" \t \t"+userInf[4]+" \t "+userInf[5]);
flag = true;
break;
}
}
//没找到的判断
if (!flag){
System.out.println("用户名不存在");
}
}
//2.3#用户管理界面——删除用户(完)
public void delUser () throws Exception{
String[] bookInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
System.out.println("=======删除用户======");
System.out.print("请输入所要删除用户的姓名：");
String delUserName = scanner.next();
System.out.print("请输入所要删除用户的密码：");
String delUserPassword = scanner.next();
//增强for循环，打印将要删除的用户信息
boolean flag = false;
String delUser = null;
for (String users : rootListUser) {
userInf = users.split("'");//检测分隔符为" ' "
//书籍被借出的判断
for (String books : rootListBook) {
bookInf = books.split("'");//检测分隔符为" ' "
//书籍被借出的判断
if (delUserName.equals(userInf[0]) && delUserPassword.equals(userInf[1]) && bookInf[6].equals(delUserName)){
System.out.println("书籍已被借出，无法删除用户");
return;
}
}
if (delUserName.equals(userInf[0]) && delUserPassword.equals(userInf[1])) {
System.out.println("姓名 \t密码 \t性别 \t年龄 \t手机号码 \t所在院系");
System.out.println(userInf[0]+" \t "+userInf[1]+" \t "+userInf[2]+" \t "+userInf[3]+" \t \t"+userInf[4]+" \t "+userInf[5]);
delUser = (userInf[0]+'\''+userInf[1]+'\''+userInf[2]+'\''+userInf[3]+'\''+userInf[4]+'\''+userInf[5]);//存入数组以便删除
flag = true;
break;
}
}
//删除判断
if (flag){
System.out.println("是否删除? 确认(1) 取消（2）");
delUserIf = ie.inputErr(delUserIf);//输入排错
if (delUserIf == 1){
// System.out.println(rootListUser);
for (int i = 0; i < rootListUser.size(); i++) { //遍历
if(delUser.equals(rootListUser.get(i))) { //如果list中存在与nowUser相同的值，则用modify替换
rootListUser.remove(delUser); //设置索引为i的值为modify
}
}
// System.out.println(rootListUser);
FileWriter fileWriter = new FileWriter(fileUser);//写入对象
for (String s : rootListUser) { //遍历
fileWriter.write(s + "\n");//写入对象
}
fileWriter.close();//关闭流
System.out.println("删除成功");
}//确认删除
else{
System.out.println("取消删除");
}//取消删除
}
else{
System.out.println("该用户不存在");
}//该用户不存在
}
}
AllBook类
打印文件中的全部书籍
import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class AllBook {
File fileBook = new File("书籍.txt");
List<String> allBookList = new ArrayList<>();//创建个list集合
String[] allBookInf = new String[8];//开辟一个6位的String数组,存放list的每一行
//全部图书列出来(完)
public void allBooks() throws Exception {
System.out.println("========现有书籍&借阅状态=======");
System.out.println("书籍 \t \t借阅状态");
//读取文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String userString;
while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
allBookList.add(userString);//一行放入一位list集合
}
reader.close();//关闭流
//增强for循环，遍历打印出list
for (String users : allBookList) {
allBookInf = users.split("'");//检测分隔符为" ' "
System.out.println(allBookInf[0]+" \t "+" \t "+allBookInf[5]);
}
}
}
FindBook类
通过输入要查询的书名查询文件中的书籍
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class FindBook {
Scanner scanner = new Scanner(System.in);
File fileBook = new File("书籍.txt");
List<String> findBookList = new ArrayList<>();//创建个list集合
String[] findBookInf = new String[8];//开辟一个6位的String数组,存放list的每一行
//查询图书(完)
public void findBooks() throws Exception {
System.out.println("========查询图书=======");
System.out.print("请输入要查询的书名：");
String findBookName = scanner.next();
//读取文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
String userString;
while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
findBookList.add(userString);//一行放入一位list集合
}
reader.close();//关闭流
//增强for循环，打印查找到的用户信息
boolean flag = false;
for (String users : findBookList) {
findBookInf = users.split("'");//检测分隔符为" ' "
if (findBookName.equals(findBookInf[0])) {
System.out.println(" ");
System.out.println("书名 \t \t作者");
System.out.println(findBookInf[0]+" \t "+findBookInf[1]);
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("售价 \t分类 \t \t \t出版社 \t \t借阅状态");
System.out.println(findBookInf[2]+" \t "+findBookInf[3]+" \t "+findBookInf[4]+" \t "+findBookInf[5]);
flag = true;
break;
}
}
//没找到的判断
if (!flag){
System.out.println("书籍不存在");
}
}
}
Log类
日志的打印与记录功能
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Log {
private String userNameLog;//姓名
public Log(){}
public Log(String userNameLog){
this.userNameLog = userNameLog;
}
//写日志
public void logRecord(String something) throws Exception {
File log = new File("日志.txt");//确定日志文件夹
Date nowDate = new Date();//创建Date对象
SimpleDateFormat dateSize = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//定义日期格式
String nowTime = dateSize.format(nowDate);
FileWriter jfw = new FileWriter(log, true);
jfw.write(nowTime + " " + userNameLog + something + "\n");
jfw.write("------------------------------");
jfw.write(System.getProperty("line.separator"));//在段落后添加一个换行符
jfw.close();
}
//读日志
public void logRead() throws Exception{
File fileLog = new File("日志.txt");
System.out.println("======================== 查 看 日 志 ========================");
//读取文件写进list
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileLog)));//缓冲流读取一个转换后的字符流数据
String userString;
while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
System.out.println(userString);//输出日志
}
reader.close();//关闭流
}
//get，set方法
public String getUserNameLog() { return userNameLog; }
public void setUserNameLog(String userNameLog) { this.userNameLog = userNameLog; }
}
问题与反思：
在编写项目时，并没有完全掌握面向对象的编写方式，还在用面向过程的方式编写，没有发挥出java的优势。
在定义项目工程的时候没有做好包与类的划分，使得代码显得很凌乱。
由于基础的薄弱耗费了大量时间在补全知识上，导致项目工期时间不够用,自我时间规划不合理。
有很多注释是复制粘贴的未作修改，请见谅。
图书馆管理系统项目包已上传，真的不会弄了再去下载。
代码做过bug的检查，但若是还有bug存在，或是其他问题存在，请在评论区指出，我会尽力修改。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
