java图书管理系统——模拟实现和部分细节

最新推荐文章于 2023-03-13 05:58:38 发布

答辣喇叭

最新推荐文章于 2023-03-13 05:58:38 发布

阅读量537

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_63519461/article/details/124163318

版权

文章目录

大致框架
部分代码细节的分享
书的包
- Book类
- Booklist类
操作包
User包
Main测试类

大致框架

在这里插入图片描述我们再根据类的差异分装成不同的包

部分代码细节的分享

首先我们就要新建一个书架Booklist booklist = new Booklist();
然后开始登录，进入login方法，选择不同的身份进去系统，根据用户输入的内容返回不同的对象

假设输入1，那就返回new NormalUser()
假设输入2，那就返回new AdminUser()
然后用User user来接收这个返回值

由于管理员和普通用户的菜单是不一样的，所以我们让User的menu成为抽象类，随后重写AdminUser和NormalUser中的menu方法，从而我们调用user.menu()后就会发生多态去调用不同类中的menu方法

然后，由于每一个操作类都可以通过以下方式实现

public class FindOperation/*或者是DelOperation……*/ {
	//对书架上的书籍进行操作
	public int work(Booklist booklist) {}
}

所以我们不妨创建一个接口

public interface IOperation {
    int work(Booklist booklist);
}

然后让所有的操作类都去实现这个接口，之后便与我们利用多态便捷地去实现各种操作，如下。

public class FindOperation implements IOperation/*或者是DelOperation……*/ {
	//对书架上的书籍进行操作
	@override  //重写接口中的抽象方法
	public int work(Booklist booklist) {}
}

所以我们在User类中可以定义一个接口数组IOperation[] iOperation，而这个数组的初始化放在AdminUser和NormalUser的构造方法中，因为这两个用户可以进行的操作是不一样的，例如

//构造方法↓↓↓
public NormalUser() {  //正常用户可以进行的方法
//↓初始化父类的iOperation数组
this.iOperation = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
};
public AdminUser() {  //管理员用户可以进行的方法
this.iOperation = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new DisplayOperation()
        };

然后由于这个数组中的元素类型都是接口类型，而元素都是实现该接口的类的对象，所以在调用这个元素的work方法的时候，也会发生多态，调用这个对象对应的work方法，实现如下

//User类中的方法
public void doWork(int choise, Booklist booklist) {
   iOperation[choise].work(booklist);
}

用户则根据菜单来选择不用的操作，并调用这个User中的doWork方法user.doWork(choise, booklist);

然后再访问对应下标的iOperation[choise]，然后由于work是IOperation接口的实现，从而发生多态，调用这个对象的work方法

完整代码实现如下

书的包

Book类

package book;

public class Book {
    private String name;
    private String author;
    private int price;
    private String type;    //小说类型
    private boolean isBorrowed;   //是否被借出

    public Book(String name, String author, int price, String type) {
        this.name = name;    //书名
        this.author = author;  //作者
        this.price = price; //价格
        this.type = type;  //书籍的类型
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                (isBorrowed == false ? "  未借出  " : "  已借出  ") +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getType() {
        return type;
    }

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

    public boolean isBorrowed() {
        return isBorrowed;
    }

    public void setIsBorrowed(boolean borrowed) {
        this.isBorrowed = borrowed;
    }
}

Booklist类

package book;

public class Booklist {
    private Book[] books = new Book[10];  //书的数组
    private int usedSize;  //表示现在书架上的书的数量

		//构造方法：默认放点书进去
    public Booklist() {
        books[0] = new Book("高等数学","张三",90,"悬疑");
        books[1] = new Book("大学物理实验","李四",78,"惊悚");
        books[2] = new Book("数据结构与算法分析","马克",89,"科幻");
        this.usedSize = 3; 
    }
    //获取当前暑假上的书
    public int getUsedSize() {
        return usedSize;
    }
	 //更新usedSize的值
    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }

    //获得输入的下标对应的书的信息
    public Book getPos(int pos) {
        return books[pos];
    }
    //更新pos下标的信息
    public void setPos(int pos, Book books) {
        this.books[pos] = books;
    }
}

操作包

增加书籍

package Operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
//增加图书
public class AddOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        int curSize = booklist.getUsedSize();  //获取当前书籍数量
        Scanner in = new Scanner(System.in);

        System.out.println("新增图书！");
        System.out.println("请输入书籍名字");
        String name = in.nextLine();
        System.out.println("请输入作者名字");
        String author = in.nextLine();
        System.out.println("请输入书籍价钱");
        int price = in.nextInt();
        System.out.println("请输入书籍类型");
        in.nextLine();  //将缓冲区中的换行符吃掉
        String type = in.next();

        Book toAdd = new Book(name, author, price, type);//将输入的数据构造成一本新书
        booklist.setPos(curSize, toAdd);   //更新当前下标的书籍
        booklist.setUsedSize(curSize + 1);  //当前书籍数量加一
        System.out.println("添加成功");
        return 0;
    }
}

借阅书籍

package Operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
//借阅图书
public class BorrowOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        int curSize = booklist.getUsedSize();
        System.out.println("请输入要借阅的图书");
        String name = new Scanner(System.in).nextLine();
        for (int i = 0; i < curSize; i++) {
            Book tmp = booklist.getPos(i);//取出对应下标的书籍
            if (name.equals(tmp.getName())) {  //如果名字相等
                tmp.setIsBorrowed(true);     //更新isBorrowed为true
                System.out.println("借阅成功");
                return 0;
            }
        }
        System.out.println("图书馆里没有这本书籍！ 借阅失败");
        return 0;
    }
}

删除书籍

package Operation;
import book.Book;
import book.Booklist;

import java.util.Scanner;

//删除书籍
public class DelOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        int curSize = booklist.getUsedSize();  //获取当前书籍数量
        System.out.println("请输入要删除的图书");
        String name = new Scanner(System.in).nextLine();
        int index = 0; //记录第一次for循环结束之后的i下标
        //这次循环结束后，index要么到了待删除书籍的下标，要么index = curSize
        for (index = 0; index < curSize; index++) {
            if (name.equals(booklist.getPos(index).getName())) {
                break;
            }
        }
        if (index == curSize) { //如果下标达到curSize
            System.out.println("查无此书");
            return 0;
        }
        //从index+1开始，index+1覆盖index
        for (int j = index; j < curSize; j++) {
            Book tmp = booklist.getPos(j + 1);
            booklist.setPos(j, tmp);
        }
        //由于往前覆盖了，所以让curSize-1下标置为空，释放内存
        booklist.setPos(curSize - 1, null);
        booklist.setUsedSize(curSize - 1);//长度减一
        System.out.println("删除成功");
        return 0;
    }
}

打印书架

package Operation;
import book.Booklist;
//展示图书馆里边的书
public class DisplayOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        int size = booklist.getUsedSize();//获取当前书籍数量
        for (int i = 0; i < size; i++) {
            System.out.println(booklist.getPos(i)); //获取元素并打印
        }
        return 0;
    }
}

退出图书馆

package Operation;
import book.Booklist;
public class ExitOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        System.out.println("退出系统！");
        System.exit(0);
        return 0;
    }
}

查找书籍

package Operation;
import book.Booklist;
import java.util.Scanner;
//查找图书
public class FindOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        int curSize = booklist.getUsedSize();//获取当前长度
        System.out.println("请输入要查找的图书");
        String name = new Scanner(System.in).nextLine();
        for (int i = 0; i < curSize; i++) {
            if (name.equals(booklist.getPos(i).getName())) {
                System.out.println("查找成功");
                System.out.println(booklist.getPos(i));//查找后打印出来
                return 0;
            }
        }//遍历结束后，还没有找到，那就没有
        System.out.println("图书馆里没有这本书籍！");
        return 0;
    }
}

归还书籍

package Operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
public class ReturnOperation implements IOperation {
    @Override
    public int work(Booklist booklist) {
        int curSize = booklist.getUsedSize();//获取当前书籍数
        System.out.println("请输入要归还的图书");
        String name = new Scanner(System.in).nextLine();
        for (int i = 0; i < curSize; i++) {
            Book tmp = booklist.getPos(i);
            if (name.equals(tmp.getName())) { //名字相等
                tmp.setIsBorrowed(true);  //将isBorrowed置为false
                System.out.println("归还成功");
                return 0;
            }
        }
        System.out.println("图书馆里没有这本书籍！ 归还失败");
        return 0;
    }
}

User包

user

package user;
import Operation.IOperation;
import book.Booklist;

public abstract class User {
    String name;
    public IOperation[] iOperation;

    public User(String name) {
        this.name = name;
    }

    public abstract int menu();

    public void doWork(int choise, Booklist booklist) {
        iOperation[choise].work(booklist);
    }
}

普通用户类

package user;
import Operation.*;
import book.Booklist;
import java.util.Scanner;
public class NormalUser extends User {

    public NormalUser(String name) {
        super(name);
        //注意这里的iOperation就不用再加上引用类型了，直接用this表示父类的iOperation
        this.iOperation = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
        };
    }
    @Override
    public int menu() {
        System.out.println("==================");
        System.out.println("0.退出系统");
        System.out.println("1.查找图书");
        System.out.println("2.借阅图书");
        System.out.println("3.归还图书");
        Scanner in = new Scanner(System.in);
        System.out.println("请输入要进行的操作:");
        int choise = in.nextInt();
        return choise;
    }
}

管理员类

package user;

import Operation.*;
import book.Booklist;

import java.util.Scanner;

public class AdminUser extends User{

    public AdminUser(String name) {
        super(name);
        //相当于帮助父类构造这个接口数组
        this.iOperation = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new DisplayOperation()
        };
    }
    @Override
    public int menu() {
        System.out.println("==================");
        System.out.println("0.退出系统");
        System.out.println("1.查找图书");
        System.out.println("2.新增图书");
        System.out.println("3.删除图书");
        System.out.println("4.显示图书");
        Scanner in = new Scanner(System.in);
        System.out.println("请输入要进行的操作:");
        int choise = in.nextInt();
        return choise;
    }
}

Main测试类

import book.Booklist;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.*;

public class Main {
    //登录
    public static User login() {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您的登录方式： 1.普通用户登录   2.管理员登录");
        while (true) {
            int choise = in.nextInt();
            if (choise == 1) {
                System.out.println("请输入您的姓名");
                String name = in.next();
                System.out.println("你好,"+name+"欢迎来到图书管理系统");
                return new NormalUser(name);
            } else if (choise == 2) {
                System.out.println("请输入您的姓名");
                String name = in.next();
                System.out.println("你好,"+name+"欢迎来到图书馆");
                return new AdminUser(name);
            } else {
                System.out.println("输入有误，请再输入一次");
            }
        }
    }
    public static void main(String[] args) {
        User user = login();
        Booklist booklist = new Booklist();
        while (true) {
            int choise = user.menu();
            user.doWork(choise, booklist);
        }
    }
}