• 图书管理系统(java版)

    目录


    前言：学习完java的基本语法过后，我们一起做一个比较综合和小项目，图书管理系统

    项目介绍

    图书管理系统,首先就是要明白不同登入系统的身份有相应不同的操作，比如说图书管理员就可以往书架中新添图书，删除图书等普通用户不能进行的操作，所以我们要针对不同用户写出相应的处理方法，理解这一点后，我们就要抽象出用户操作的目标，对此我们可将该项目所涉及到的类归结为3个包（书，书架），（用户），（操作方法），详情请看相应的代码，其中包含了详细的注释

    1.图书馆入口主函数

    import Book.bookList;
import User.AdminUser;
import User.NormalUser;
import User.user;
import java.util.Scanner;

public class Main {
    //加载函数login，确定登录用户的身份，返回合适的用户对象
    public static user login(){
        System.out.println("欢迎来到大熊猫图书馆");
        System.out.println("请输入你的昵称");
        Scanner scanner=new Scanner(System.in) ;
        String name=scanner.nextLine();
        System.out.println("请输入您的登录身份   1.管理员    2.读者");
        int ID=scanner.nextInt();
        //当输入ID为1时，返回一个管理员对象
        if(ID==1){
            System.out.println("你已进入管理员界面");
            return new AdminUser(name,"管理员");
            //当输入ID为2时，返回一个读者对象
        }else if(ID==2){
            System.out.println("你已进入读者界面");
            return new NormalUser(name,"读者");
        }
        System.out.println("登陆失败"+"\n"+"亲亲，看清楚一点，下次请输入正确的选项哦");

        return null;
    }



    public static void main(String[] args) {
        //实例化一个书架对象
        bookList bookList=new bookList();
        //用一个父类的引用接受login方法返回的子类对象，便于调用父类方法时发生多态
        user user=login();
        while(true){
            //这里的user.menu指的是用父类(user)引用调用子类重写的抽象方法
            int choice=user.menu();
            //与上方法用法一样
            user.doWork(choice,bookList);
        }

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    2.书包

    因为书架类中会用到书的对象，所以我们将书类与书架类放在同一个包中

    书类(Book)

    package Book;
//对书类进行抽象
public class book {
    private String name;
    private String auther;
    private double price;
    private String bookStyle;
    private boolean isBorrowed;

    /**
     * 书类的一个带参数的构造方法(不含成员属性isBorrowed)
     * 因为isBorrowed是一个布尔类型的成员属性，就算构造方法未对其进行传参
     * 初始化，在类中也会默认初始化为false,又因为在添加一个书时，默认的借出状态
     * 也为未借出(false),正因为布尔类型属性这一特点，所以构造方法中不用对其传参
     * 初始化
     * @param name 书名
     * @param auther 作者
     * @param price 价格
     * @param bookStyle 类型
     */
    public book(String name, String auther, double price, String bookStyle) {
        this.name = name;
        this.auther = auther;
        this.price = price;
        this.bookStyle = bookStyle;
    }

    /**
     * 对ToString方法进行重写，方便对书类对象的属性信息打印
     * @return
     */
    @Override
    public String toString() {
        return "book{" +
                "name='" + name + '\'' +
                ", auther='" + auther + '\'' +
                ", price=" + price +
                ", bookStyle='" + bookStyle + '\'' +
                ", isBorrowed=" + (isBorrowed?"已借出":"未借出") +
                '}';
    }

    /**
     *返回当前书对象的书名(name)
     * @return
     */
    public String getName() {
        return name;
    }

    /**
     * 设置当前书对象的书名(name)
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 返回当前书对象的作者名字(auther)
     * @return
     */
    public String getAuther() {
        return auther;
    }

    /**
     * 设置当前书对象的作者名字(auther)
     * @param auther
     */
    public void setAuther(String auther) {
        this.auther = auther;
    }

    /**
     * 返回当前书对象的价格(price)
     * @return
     */
    public double getPrice() {
        return price;
    }

    /**
     * 设置当前书对象的价格(price)
     * @param price
     */
    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 返回当前书对象的类型(bookStyle)
     * @return
     */
    public String getBookStyle() {
        return bookStyle;
    }

    /**
     * 设置当前书对象的类型(bookStyle)
     * @param bookStyle
     */
    public void setBookStyle(String bookStyle) {
        this.bookStyle = bookStyle;
    }

    /**
     * 返回当前对象的借阅状态(isBorrowed)
     * @return
     */
    public boolean getIsBorrowed() {
        return isBorrowed;
    }

    /**
     * 设置当前对象的借阅状态(isBorrowed)
     * @param borrowed true或false
     */
    public void setBorrowed(boolean borrowed) {
        isBorrowed = borrowed;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122

    书架类(BookList)

    package Book;
//抽象出存放书籍的书架类bookList
public class bookList {
    //定义一个book类型的数组存放书籍
    private book[] books=new book[10];
    private int useMount;


    /**
     * 书架的无参构造方法，当实例化书架的对象时，书架会自动初始化放上三本书；
     */
    public bookList() {
        books[0]=new book ("西游记","罗贯中",90.5,"小说");
        books[1]=new book ("红楼梦","曹雪芹",86.5,"小说");
        books[2]=new book ("java深度解析","大聪明",55.5,"科学");
        this.useMount=3;
    }

    /**
     *
     * @return 获取当前书架已存在的书籍数目
     */
    public int getUseMount() {
        return useMount;
    }

    /**
     *
     * @param useMount 修改书架中书本数目
     */
    public void setUseMount(int useMount) {
        this.useMount = useMount;
    }

    /**
     *在book数组的pos下标元素里添加书的对象
     * @param pos 放入书架的下标
     * @param book 放入的书对象
     */
    public void setBooks(int pos,book book) {
        books[pos]=book;
        this.useMount++;
    }

    /**
     *返回book数组的pos下标元素里书的对象
     * @param pos 要获取书的下标
     * @param
     * @return
     */
    public book getBooks(int pos) {

        return books[pos];
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    3.用户包

    用户父类(User)

    package User;
import Book.bookList;
import Operations.Ioperations;

public abstract class user {
    protected String name;
    protected Ioperations[] operations;
    public abstract int menu();
    public abstract void doWork(int choice, bookList bookList);
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    普通用户子类(NormalUser)

    package User;


import Book.bookList;
import Operations.*;

import java.util.Scanner;

public class NormalUser extends user {
    public int menu(){
        System.out.println("hello "+"欢迎"+this.ID+": "+this.name+" 欢迎来到图书小练习");
        System.out.println("1.查找图书");
        System.out.println("2.借阅图书");
        System.out.println("3.归还图书");
        System.out.println("0.退出系统");
        System.out.println("请输入你的操作：");
        Scanner scanner=new Scanner(System.in);
        int choice=scanner.nextInt();
        return choice;
    }

    public NormalUser(String name,String ID) {
        this.ID=ID;
        this.name=name;
        //初始化从父类user中继承的operation数组
        //这一步起到了十分关键的作用，提供了不同用户身份的不同操作方法
        this.operations=new Ioperations[]{
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()

        };
    }

    /**
     * 通过菜单中返回的选项，调用相对应下标的接口数组对象的work方法
     * @param choice 用户从菜单中选择的选项
     * @param bookList 要操作的书架对象
     */
    public void doWork(int choice, bookList bookList){
        this.operations[choice].work(bookList);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    管理员用户子类(AdminUser)

    package User;

import Book.bookList;
import Operations.*;

import java.util.Scanner;

public class AdminUser extends user{
    //重写用户父类中的menu方法
    public int menu(){
        System.out.println("hello "+"欢迎"+this.ID+": "+this.name+" 来到图书小练习");
        System.out.println("1.查找图书");
        System.out.println("2.新增图书");
        System.out.println("3.删除图书");
        System.out.println("4.显示图书");
        System.out.println("0.退出系统");
        System.out.println("请输入你的操作：");
        Scanner scanner=new Scanner(System.in);
        int choice=scanner.nextInt();
        return choice;
    }


    public AdminUser(String name,String ID) {
        this.ID=ID;
        this.name=name;
        //初始化从父类user中继承的operation数组
        //这一步起到了十分关键的作用，提供了不同用户身份的不同操作方法
        this.operations=new Ioperations[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DeletOperation(),
                new DisplayOperation()

        };
    }
    /**
     * 通过菜单中返回的选项，调用相对应下标的接口数组对象的work方法
     * @param choice 用户从菜单中选择的选项
     * @param bookList 要操作的书架对象
     */
    public void doWork(int choice, bookList bookList){
        this.operations[choice].work(bookList);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    4.操作方法包

    操作方法公共接口(Ioperations)

    package Operations;
import Book.bookList;

//定义一个操作接口(规范对书架对象的操作)
public interface Ioperations {
    //通过其他操作类对该抽象方法进行重写
    void work(bookList bookList);
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    新增图书类(AddOperation)

    package Operations;
import Book.book;
import Book.bookList;
import java.util.Scanner;

//定义新增书籍操作这个类重写实现接口中的work抽象方法
public class AddOperation implements Ioperations{
    @Override
    public void work(bookList booklist) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入书名");
        String name=scanner.nextLine();
        System.out.println("请输入作者");
        String auther=scanner.nextLine();
        System.out.println("请输入价格");
        double price=scanner.nextDouble();
        System.out.println("请输入书籍的分类");
        String style=scanner.nextLine();
        book book=new book(name,auther,price,style);
        int pos=booklist.getUseMount();
        booklist.setBooks(pos,book);
        System.out.println("添加书籍成功");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    借阅图书类(BorrowOperation)

    import Book.book;
import Book.bookList;
import java.util.Scanner;
//定义借阅书籍操作这个类重写实现接口中的work抽象方法
public class BorrowOperation implements Ioperations{
    @Override
    public void work(bookList bookList) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入你要借阅书籍的名字");
        String name=scanner.nextLine();
        int i=0;
        //用遍历的方式查询书架中是否存在输入的书名
        for (;i <bookList.getUseMount(); i++) {
            //用bookList已写的方法获取下标为i的书对象
            book book=bookList.getBooks(i);
            if(book.getName().equals(name)&&book.getIsBorrowed()==false){
                bookList.getBooks(i).setBorrowed(true);
                System.out.println("当前图书状态"+book);
                System.out.println("借阅书籍成功");
                return;
            }else if(book.getName().equals(name)&&book.getIsBorrowed()==true)
                System.out.println("很抱歉，该书已被借出了，请选择其他书籍");
            return;
        }

        System.out.println("抱歉该书不存在");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    删除图书类(DeletOperation)

    import Book.book;
import Book.bookList;

import java.util.Scanner;

public class DeletOperation implements Ioperations{
    @Override
    public void work(bookList bookList) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入你要删除的书名");
        String name=scanner.nextLine();
        //用遍历的方式查询书架中是否存在输入的书名
        int i=0;
        int used=bookList.getUseMount();
        for (;i <used; i++) {
            //用bookList已写的方法获取下标为i的书对象
            book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                System.out.println("该书找到了");
                System.out.println(book);
                for (int j = i; j < bookList.getUseMount()-1; j++) {
                    bookList.setBooks(i,bookList.getBooks(i+1));
                }
                //将书架中的书籍数减少1
                bookList.setUseMount(used-1);
                System.out.println("删除书籍成功");

                return;
            }
        }

        System.out.println("抱歉该书不存在");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    展示图书类(DisplayOperation)

    package Operations;

import Book.book;
import Book.bookList;
//定义展示书籍操作这个类重写实现接口中的work抽象方法
public class DisplayOperation implements Ioperations{
    @Override
    public void work(bookList bookList) {
        //获取当前书架中书的总数量
        int used=bookList.getUseMount();
        //遍历打印所有书籍
        System.out.println("所有书籍列表如下");
        for (int i=0; i <used ; i++) {
            book book=bookList.getBooks(i);
            System.out.println(book);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    归还图书类(ReturnOperation)

    package Operations;

import Book.book;
import Book.bookList;

import java.util.Scanner;
//定义归还书籍操作这个类重写实现接口中的work抽象方法
public class ReturnOperation implements Ioperations {
    @Override
    public void work(bookList bookList) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要归还书籍的名字");
        String name = scanner.nextLine();
        int i = 0;
        //用遍历的方式查询书架中是否存在输入的书名
        for (; i < bookList.getUseMount(); i++) {
            //用bookList已写的方法获取下标为i的书对象
            book book = bookList.getBooks(i);
            if (book.getName().equals(name)) {
                //将该书的借阅状态设置为false
                bookList.getBooks(i).setBorrowed(false);
                System.out.println("当前图书状态"+book);
                System.out.println("归还书籍成功");
                return;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    退出系统类(ExitOperation)

    package Operations;
import Book.bookList;

//定义退出图书系统操作这个类重写实现接口中的work抽象方法
public class ExitOperation implements Ioperations{
    @Override
    public void work(bookList bookList) {
        //有可能  需要销毁，或者使用到 这个数组当中的所有的数据

        int used=bookList.getUseMount();
        for (int i = 0; i < used; i++) {
            bookList.setBooks(i,null);
        }
        System.out.println("已退出大熊猫图书系统！");
        System.exit(0);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
  • 相关阅读:
    初识Dockerfile
    第二章 cadence后仿教程(Physical Verification).pdf
    新手使用gin 创建第一个接口
    计算机毕业设计ssm社区爱心活动网站be83l系统+程序+源码+lw+远程部署
    基于Python的GeoServer矢量文件批量发布
    docker搭建minio服务器，解决内网穿透后外网无法访问问题
    你是如何使用React高阶组件的？
    手把手创建属于自己的ASP.NET Croe Web API项目
    在Gradio实现分栏、分页的效果（二）
    建链时，please install openssl! use “openssl version“ command to check.
  • 原文地址：https://blog.csdn.net/qq_61797201/article/details/124176632