图书管理系统(java版)

最新推荐文章于 2024-05-28 15:43:28 发布

码头弄点薯条

最新推荐文章于 2024-05-28 15:43:28 发布

阅读量737

点赞数 4

分类专栏： java之旅文章标签： java 开发语言 servlet

本文链接：https://blog.csdn.net/qq_61797201/article/details/124176632

版权

java之旅专栏收录该内容

8 篇文章 0 订阅

订阅专栏

项目介绍

图书管理系统,首先就是要明白不同登入系统的身份有相应不同的操作，比如说图书管理员就可以往书架中新添图书，删除图书等普通用户不能进行的操作，所以我们要针对不同用户写出相应的处理方法，理解这一点后，我们就要抽象出用户操作的目标，对此我们可将该项目所涉及到的类归结为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);
        }

    }
}

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;
    }
}

书架类(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];
    }
}

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);
}

普通用户子类(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);
    }
}

管理员用户子类(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);
    }
}

4.操作方法包

操作方法公共接口(Ioperations)

package Operations;
import Book.bookList;

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

新增图书类(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("添加书籍成功");
    }
}

借阅图书类(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("抱歉该书不存在");
    }
}

删除图书类(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("抱歉该书不存在");
    }
}

展示图书类(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);
        }

    }
}

归还图书类(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;
            }
        }
    }
}

退出系统类(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);
    }
}

码头弄点薯条

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
2
评论
图书管理系统(java版)

目录项目介绍1.图书馆入口主函数2.书包书类(Book)书架类(BookList)3.用户包用户父类(User)普通用户子类(NormalUser)管理员用户子类(AdminUser)4.操作方法包操作方法公共接口(Ioperations)新增图书类(AddOperation)借阅图书类(BorrowOperation)删除图书类(DeletOperation)展示图书类(DisplayOperation)归还图书类(ReturnOperation)退出系统类(ExitOperation)前言：学习完ja
复制链接

扫一扫