图书馆管理系统（控制台版本的简单的管理系统）

最新推荐文章于 2023-06-26 13:15:22 发布

&从小白到大白&

最新推荐文章于 2023-06-26 13:15:22 发布

阅读量2.4k

点赞数 1

文章标签：图书馆管理系统（控制台版本的简单管理系统）

本文链接：https://blog.csdn.net/qq_44773719/article/details/102655546

版权

一、需求分析：
面向对象进行设计就是将需求根据不同的角色进行拆分，然后根据不同的角色实现不同功能。
针对图书馆管理系统我们可以将角色分为管理员和普通用户。
（1）针对普通用户，支持的操作：
a）查找书籍
b）借阅书籍
c）归还书籍
（2）针对管理员，支持的操作：
a）查找书籍
b）增加书籍
c）删除书籍
d）打印所有书籍信息

二、概要设计
想清楚程序应该分为几个模块，每个模块都是干啥的，模块之间是如何交互的？
由于当前的系统相对比较简单，暂且设为一个模块。

三、详细设计
每个模块具体的一些细节再考虑清楚

四、开始编码
我们根据实际情况将系统的各个功能放在三个包中
（1）user包：包含了Admin（管理员）、NormalUser（普通用户）以及他们的一个父类User类
（2）book包：包含了book类（用于描述每本书的信息），bookList类（存放所有书籍的信息）
（3）operation包：包含了各种具体实现的操作
注：我们可以将各种具体的操作放在User类中，也可以把操作看成一个名词，将“操作”独立出来，每种类（Admin、NormaiUser）对应一个类，User类只要持有这些类的实例就行了。把操作提取成类，这样也就把操作和用户之间进行了“解耦合”，降低了相互之间的影响。

编码的整体结构：
book：
Book：描述一本书的信息；
BookList：管理若干本书，简单的顺序链表

user：
User：抽象类，包含名字和用户支持的操作数组
Admin：表示管理员，继承自User
NormalUser：普通用户，继承自User

operation：包含了若干个类，每个类表示一种操作，每个用户可以根据具体的需求持有不同的操作。
共同的接口 IOperation，需要重写一个 work 方法，这个方法要针对 bookList 进行操作。

具体的代码实现：

1.book 包：
（1）Book 类：


```java
package package1.book;

public class Book {
    private String name;
    private String id;
    private String author;
    private int price;
    private String type;
    private boolean isborrowed;

    public Book(String name, String id, String author,
                int price, String type, boolean isborrowed) {
        this.name = name;
        this.id = id;
        this.author = author;
        this.price = price;
        this.type = type;
        this.isborrowed = isborrowed;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ", isborrowed=" + isborrowed +
                '}';
    }

    public boolean isIsborrowed() {
        return isborrowed;
    }

    public void setIsborrowed(boolean isborrowed) {
        this.isborrowed = isborrowed;
    }
}


（2）BookList 类：

```java
public class BookList {
    private Book[] books = new Book[100];
    private int size;

    public BookList() {
        books[0] = new Book("金瓶梅","001","兰陵笑笑生",
                100,"古典名著",false);
        books[1] = new Book("水浒传","002","施耐庵",
                200,"古典名著",false);
        books[2] = new Book("西游记","003","吴承恩",
                300,"古代名著",false);
        size = 3;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public Book getBook(int index) {
        return books[index];
    }

    public void setBook(int index, Book book) {
        books[index] = book;
    }
}

2.user 包：
（1）User 类（抽象类）：


```java
import package1.Operation.IOperation;
import package1.book.BookList;

abstract public class User {
    protected String name;

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

    //持有当前用户支持的操作对象
    protected IOperation[] operations;

    //打印一个操作菜单，不同的用户支持的操作不同，对应的菜单也就不同
    abstract public int menu();

    //根据用户输入的选项（menu的返回结果）
    //调用对应的操作对象
    //注意多态在这个代码中的体现
    public void doOperation(int choice, BookList bookList) {
        operations[choice].work(bookList);
    }
}


（2）Admin 类：

```java
import package1.Operation.*;

import java.util.Scanner;

public class Admin extends User {
    public Admin(String name) {
        super(name);
        operations = new IOperation[] {
          new ExitOpreation(),
          new FindOperation(),
          new AddOperation(),
          new Deloperation(),
          new PrintAllOperation()
        };
    }

    @Override
        public int menu() {
        System.out.println("----------------");
        System.out.println("hello" + name);
        System.out.println("1.查找图书");
        System.out.println("2.增加图书");
        System.out.println("3.删除图书");
        System.out.println("4.打印所有信息");
        System.out.println("0.退出");
        System.out.println("----------------");
        System.out.println("请输您的选择: ");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

（3）NormalUser 类：

package package1.user;

import package1.Operation.*;

import java.util.Scanner;

public class NormalUser extends User {
    public NormalUser(String name) {
        super(name);
        //在这里构造 operation 数组
        //让我们数组中的 operation 对象的顺序和菜单中的序号相匹配
        operations = new IOperation[] {
                new ExitOpreation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
        };
    }

    @Override
    public int menu() {
        System.out.println("----------------");
        System.out.println("hell" + name);
        System.out.println("1.查找图书");
        System.out.println("2.借阅图书");
        System.out.println("3.归还图书");
        System.out.println("0.退出");
        System.out.println("----------------");
        System.out.println("请输入您的选择： ");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        //close 本质上是在关闭 System.in
        //后面还要用到 System.in ，此处不能盲目关闭
        //scanner.close();
        return choice;
    }
}

3.Operation 包：
（1）IOperation 接口

package package1.Operation;

import package1.book.BookList;

public interface IOperation {
    void work(BookList bookList);
}

（2）FindOperation 类：

package package1.Operation;

import package1.book.Book;
import package1.book.BookList;

import java.util.Scanner;

public class FindOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("查找书籍");
        System.out.println("请输入要查找的书名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.next();
        int count =  0;
        for (int i = 0; i < bookList.getSize(); i++) {
            Book book = bookList.getBook(i);
            if (book.getName().equals(name)) {
                //打印这本书的信息
                System.out.println(book);
                count++;
            }
        }
        if (count == 0) {
            System.out.println("没找到次书");
        } else {
            System.out.println("共计找到 " + count + " 本书!");
        }
    }
}

（3）BorrowOperation 类：

package package1.Operation;

import package1.book.Book;
import package1.book.BookList;

import java.util.Scanner;

public class BorrowOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅书籍");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要借阅书籍的编号");
        String id = scanner.next();
        for (int i = 0; i < bookList.getSize(); i++) {
            Book book = bookList.getBook(i);
            if (!book.getId().equals(id)) {
                continue;
            }
            //执行具体的借书操作
            if (book.isIsborrowed()) {
                System.out.println("这本书已经被借走了");
                break;
            }
            book.setIsborrowed(true);
        }
    }
}

（4）ReturnOpeartion 类：

package package1.Operation;

import package1.book.Book;
import package1.book.BookList;

import java.util.Scanner;

public class ReturnOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
            System.out.println("归还书籍");
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入要归还书籍的编号");
            String id = scanner.next();
            for (int i = 0; i < bookList.getSize(); i++) {
                Book book = bookList.getBook(i);
                if (!book.getId().equals(id)) {
                    continue;
                }
                //执行具体的还书操作
                if (!book.isIsborrowed()) {
                    System.out.println("这本书已经被会还了");
                    break;
                }
                book.setIsborrowed(false);
            }
        }
}

（5）AddOperation 类：

package package1.Operation;

import package1.book.Book;
import package1.book.BookList;

import java.util.Scanner;

public class AddOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("新增一本书籍");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名");
        String name = scanner.next();
        System.out.println("请输入序号");
        String id = scanner.next();
        System.out.println("请输入作者");
        String author = scanner.next();
        System.out.println("请输入价格");
        int price = scanner.nextInt();
        System.out.println("请输入类别");
        String type = scanner.next();
        Book book = new Book(name,id,
                author,price,type,false);
        bookList.setBook(bookList.getSize(),book);
        bookList.setSize(bookList.getSize() + 1);
    }
}

（6）Deloperation 类：

package package1.Operation;

import package1.book.Book;
import package1.book.BookList;

import java.util.Scanner;

public class Deloperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("删除书籍");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要删除的序号: ");
        String id = scanner.next();
        //先查找
        int i = 0;
        for (; i < bookList.getSize(); i++) {
            Book book = bookList.getBook(i);
            if (book.getId().equals(id)) {
                //找到了
                break;
            }
        }
        if (i >= bookList.getSize()) {
            //没找到
            return;
        }
        //处理找到了的情况
        //直接用最后一个元素覆盖当前要删除的元素，然后在把 size-- 即可。
        //bookList.setBook(i,bookList.getBook(bookList.getSize() - 1));
        Book lastBook = bookList.getBook(bookList.getSize() - 1);
        bookList.setBook(i,lastBook);
        bookList.setSize(bookList.getSize() - 1);
    }
}

（7）PrintAllOperation 类：

package package1.Operation;

import package1.book.BookList;

public class PrintAllOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("打印所有书籍的信息");
        for (int i = 0; i < bookList.getSize(); i++) {
            System.out.println(bookList.getBook(i));
        }
        System.out.println("共计 " + bookList.getSize() + " 书!");
    }
}

（8）ExitOperation 类：

package package1.Operation;

import package1.book.BookList;

public class ExitOpreation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("goodbye!");
        System.exit(0);
    }
}

4.main方法（程序的入口）

package package1;

import package1.book.BookList;
import package1.user.Admin;
import package1.user.NormalUser;
import package1.user.User;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //程序的入口
        //1.先准备好书籍信息数据
        BookList bookList = new BookList();
        //2.创建用户(这里的多态,不用管 package1.user 的实际身份）
        User user = login();
        //3.进入主循环
        while (true) {
            int choice = user.menu();
            user.doOperation(choice,bookList);
        }
    }

    public static User login() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的姓名");
        String name = scanner.next();
        System.out.println("请输入您的角色:(1.普通用户 2.管理员)");
        int role = scanner.nextInt();
        if (role == 1) {
            return new NormalUser(name);
        }
        return new Admin(name);

    }
}

效果展示：
在这里插入图片描述
项目源码：https://github.com/YTCfight/Library-management-system/tree/master/src/package1

&从小白到大白&

关注

1
点赞
踩
40

收藏

觉得还不错? 一键收藏
0
评论
图书馆管理系统（控制台版本的简单的管理系统）

一、需求分析：面向对象进行设计就是将需求根据不同的角色进行拆分，然后根据不同的角色实现不同功能。针对图书馆管理系统我们可以将角色分为管理员和普通用户。（1）针对普通用户，支持的操作：a）查找书籍b）借阅书籍c）归还书籍（2）针对管理员，支持的操作：a）查找书籍b）增加书籍c）删除书籍d）打印所有书籍信息二、概要设计想清楚程序应该分为几个模块，每个模块都是干啥的，模块之间是...
复制链接

扫一扫