Java学习——图书管理系统小项目

于 2024-09-20 19:45:29 发布
阅读量666 收藏 4
点赞数 16
文章标签： 学习 java 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80176093/article/details/142393207
版权

目录

全文逻辑

针对各部分代码解析和展示

A.主函数

B.对象，操作，书籍分为3个包

1.book

Book部分

BookList部分

2.Operation

Add部分

Borrow部分

Delete部分

Exit部分

Find部分

Return部分

Show部分

接口部分

3.User

User父类部分

Admin子类部分

Nomal部分

全文逻辑

1.一本书：书名，作者，价格

2.书架：多本书的集合

3.对象：看书用户，整理管理员

4.对于书的一些行为动作：增加，借阅，删除，退出，寻找，归还，展示

5.主函数的调用

 6.代码安排：操作，对象类型多样，便于管理将去设置成包目录的形式来安排

针对各部分代码解析和展示

A.主函数

import User.Admin;
import User.Nomal;
import User.User;
import book.BookList;

import java.util.Scanner;

public class Main {

    //书+动作都被定义好后，先进行菜单
    //static 的原因是因为它不依赖于任何实例
    //在 Java 中，非静态方法必须被某个实例调用，而静态方法（static）可以被类名直接调用的

    //类型变成父类User
    public static User login(){
        //请输入你的姓名，in是从键盘输入
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入你的姓名");
        String name =scanner.nextLine();
        System.out.println("请输入你的身份：1-> 管理员 0-> 用户 ");
        int choice=scanner.nextInt();

        if(choice == 1){
            //这样写是局部变量，不知道对象是管理员还是用户
            //Admin admin=new Admin(name);

            //所以可以考虑返回值，向上转型去接收
            //写法1
            /*Admin admin=new Admin(name);
            return admin;*/
            //写法2
            return new Admin(name);

        }else {
            //Nomal nomal=new Nomal(name);

            /*Nomal nomal=new Nomal(name);
            return nomal;*/
            return new Nomal(name);
        }
    }

    public static void main(String[] args) {

        BookList bookList=new BookList();

        //引用菜单，才能完成输入姓名等操作
        User user=login();

        //多次循环输入
        while (true){
            int choice=user.menu();
            user.doOperation(choice,bookList);
        }



        //要在User中定义才能使用该代码
        //调用菜单时有一个返回值

        //user是那个对象，choice是几？
        //当我输入1，2，3时，怎么切换到对于的操作？

        //通过chioce就知道你选的是几
        //通过user就知道你是那个对象
        //定义User里面的方法来完成之间的联系



        /*int choice=user.menu();
        System.out.println(user);*/

    }


}

B.对象，操作，书籍分为3个包

1.book

此包中包含Book（一本书）和BookList（书架）

Book部分
package book;

//一本书：名字+作者+价格+状态（是否被借阅）

public class Book {

    //定义成员
    private String name;
    private String author;
    private int price;

    //未借出（从未定义）：false；借出：ture
    private boolean Borrow;

    //因为默认是false，所以不用
    //通过将 name、author和price 这三个参数传递给构造函数来为成员变量赋值的。
    //这些参数将被用于初始化类的成员变量：this.name、this.author和this.price。
    //创建了一个对该成员变量的副本。
    public Book(String name, String author, int price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    //用于访问和修改类的成员变量（实例变量）的方法
    public String getName() {
        return name;
    }

    //如果你修改了 name 的值（private修饰提供get，set方法）
    public void setName(String name) {
        this.name = name;
    }
    //你并没有改变原始传入的 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 boolean isBorrow() {
        return Borrow;
    }

    public void setBorrow(boolean borrow) {
        Borrow = borrow;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                //", Borrow=" + Borrow +
                //修改3元表达式
                ((Borrow == true)?" 已经被借出 ":" 未被借出 ")+
                '}';
    }
}
BookList部分
package book;


public class BookList {

    //要怎么样去装多本书--数组
    //定义+分配内存
    //总共可以放10本书
    //Book是写好的一本书的类，books是参数
    private Book[] books=new Book[10];

    //怎么知道放了几本书？
    //定义一个计数器
    //成员变量不初始化默认初始化=0/false
    private int usedSize;

    //如何将数组里面放书呢？
    //调用books数组，开辟新的空间，传入Book一本书
    //this 变量，它指向了当前类(BookList)的实例
    public BookList() {
        this.books[0]=new Book("三国演义","罗贯中",10);
        this.books[1]=new Book("西游记","吴承恩",12);
        this.books[2]=new Book("红楼梦","曹雪芹",13);
        //记录下当前10个空间里面有3本书
        this.usedSize=3;
    }

    //在数组种如何找到书？
    //使用位置下标+返回
    public Book getBook(int pos){
        return books[pos];
    }

    //类型（Book）  参数对象（book），不一定非是book换成jkl也可以
    public void setBooks(int pos,Book book){
        books[pos]=book;
    }

    public int getUsedSize() {
        return usedSize;
    }

    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }


}

2.Operation

Add部分
package Operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class Add implements IOperation{

    //由于每一个动作都要这样
    //所以直接定义一个接口来方便使用
    public void work(BookList bookList){
        //声明每个变量，并且输入进去
        System.out.println("新增加图书！");
        //开辟空间
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名！");
        String name = scanner.nextLine();
        System.out.println("请输入作者！");
        String author = scanner.nextLine();
        System.out.println("请输入价格！");
        int price = scanner.nextInt();
        scanner.nextLine();

        //为这个书籍申请空间
        Book book = new Book(name,author,price);
        //记录当前未放进去时的位置总数
        int currentSize = bookList.getUsedSize();

        //判断书架里面是否有这本书
        for (int i = 0; i < currentSize; i++) {
            //验证这个下标的书
            Book book1 = bookList.getBook(i);
            //判断增加书名是否在书架里面
            if(book1.getName().equals(name)){
                System.out.println("书架存在这本书,不能进行添加！");
                return;
            }

        }

        //没有就可以把他放在最后一个位置
        bookList.setBooks(currentSize,book);
        //然后将这个位置进行后移
        bookList.setUsedSize(currentSize+1);

        System.out.println("添加成功");

    }

}
Borrow部分
package Operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class Borrow implements IOperation{

    @Override
    public void work(BookList bookList) {
        System.out.println("借阅");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名: ");
        String name = scanner.nextLine();

        int currentSize = bookList.getUsedSize();

        for (int i = 0; i < currentSize; i++) {
            Book book1=bookList.getBook(i);
            if(book1.getName().equals(name)){
                if(!book1.isBorrow()) {
                    //true可以借阅
                    book1.setBorrow(true);
                    System.out.println("借阅成功");
                }else {
                    System.out.println("已被借走");
                }
                //借出
                return;
            }
        }

        System.out.println("没有符合借阅的书");
    }
}
Delete部分
package Operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class Delete implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("删除");

        //记录在未删除书籍时，书架上还剩基本书----------------判断是否为空
        int currentSize= bookList.getUsedSize();
        if(currentSize == 0){
            System.out.println("书架为空,不能删除");
            return;
        }

        //有书，则从键盘输入要删除的书名字------------------输入删除的书名
        //开辟了scanner这个空间吗
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名: ");
        //字符串输入用nextLine
        //字符输入要nextInt
        String name = scanner.nextLine();

        //判断是否有这本书------------------------------删除（找是否有）
        int index=-1;
        //记录删除书在数组中的下标位置
        for (int i = 0; i < currentSize; i++) {
            Book book1 = bookList.getBook(i);
            //equal比较输入的书名字在书架里面是否存在
            if (book1.getName().equals(name)){
                index=i;
                break;
            }
        }

        //index !=1 有这本书，开始删除操作--------------删除（找没有）
        if(index == -1){
            System.out.println("没有你要删除的书");
            return;
        }

        //从后一位往前面盖住--------------------------开始覆盖操作
        for (int i = index; i < currentSize-1; i++) {
            Book book1 = bookList.getBook(i+1);
            bookList.setBooks(i,book1);
        }

        //当删除书后，要保持书架里面的书数量更新----------完毕后更新原来的值
        bookList.setUsedSize(currentSize-1);

    }
}
Exit部分
package Operation;

import book.BookList;

public class Exit implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出");
    }
}
Find部分
package Operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class Find implements IOperation{

    public void work(BookList bookList){
        System.out.println("查找");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名: ");
        String name = scanner.nextLine();

        int currentSize = bookList.getUsedSize();

        for (int i = 0; i < currentSize; i++) {
            Book book1=bookList.getBook(i);
            if(book1.getName().equals(name)){
                System.out.println("找到了这本书");
                System.out.println(book1);
                return;
            }
        }

        System.out.println("没有查找到这本书");

    }

}
Return部分
package Operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class Return implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("归还");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名: ");
        String name = scanner.nextLine();

        int currentSize = bookList.getUsedSize();

        for (int i = 0; i < currentSize; i++) {
            Book book1=bookList.getBook(i);
            if(book1.getName().equals(name)){
                //如果输入的书名与某一本已经借出的书籍的名称相同
                //那么就将这本书的借出状态设置为 false(未归还)
                book1.setBorrow(false);
                System.out.println("归还成功");
                //然后进行归还
                return;
            }
        }

        System.out.println("没有要归还的书");

    }
}
Show部分
package Operation;

import book.Book;
import book.BookList;

public class Show implements IOperation{

    @Override
    //                  主类型  参数对象
    public void work(BookList bookList) {
        System.out.println("展示");

        //找循环边界---BookList中的usedSize
        //而usedSize是pravite修饰的封装
        //如果需要使用就要用public int getUsedSize() {
        //        return usedSize;
        //    }去调用

        //所有先获取usedSize
        //              类声明的对象.包装的东西
        int currentSize= bookList.getUsedSize();

        for (int i = 0; i < currentSize; i++) {
            //每一本书都要输出
            //BookList(主名)里面声明的下标找到的书
            //public Book getBook(int pos){
            //        return books[pos];
            //    }
            //对应下标0，1，输出相关的书
            //public BookList() {
            //        this.books[0]=new Book("三国演义","罗贯中",10);
            //        this.books[1]=new Book("西游记","吴承恩",12);
            //        this.books[2]=new Book("红楼梦","曹雪芹",13);
            //        //记录下当前10个空间里面有3本书
            //        this.usedSize=3;
            //    }
            //Book里面包含getBook,而BookList里面包含getBook
            //bookList是BookList声明的参数对象
            //而book要打印引用的，要在Book里面重写toSting()方法
            Book book=bookList.getBook(i);
            System.out.println(book);
        }

    }
}
接口部分
package Operation;

import book.BookList;

public interface IOperation {

    void work(BookList bookList);

}

3.User

用户和管理员都是人员，所有将其共同部分设置成父类来加以调用

User父类部分
package User;

import Operation.IOperation;
import book.BookList;

public abstract class User {

    //因为用户和管理员都是使用者
    //所以可以将使用者作为父类
    //protected是在同一个包不同类可用
    //用户，管理员不是一类，但都在User这个包下面
    protected String name;


    //保存一份能被修改的数据，但原始数据不变
    public User(String name) {
        this.name = name;
    }

    //被 abstract 修饰的方法--抽象方法，该方法不用给出具体的实现体
    public abstract int menu();

    //这个数据只是定义了，但是没有初始化大小
    public IOperation[] iOperations;

    //给一个量来操作数组的位置
    //这个数组将来存储add，find等里面的内容
    public void doOperation(int choice, BookList bookList){
        iOperations[choice].work(bookList);
    }

}
Admin子类部分
package User;

import Operation.*;

import java.util.Scanner;

public class Admin extends User{

    //super相当于是子类对象中从父类继承下来部分成员的引用
    //用来调用父类的构造函数、方法或属性
    public Admin(String name) {
        super(name);
        //Admin继承User里面的所有东西，但在
        //User里面没有初始化，所有在Admin里面初始化
        this.iOperations=new IOperation[]{
                new Exit(),
                new Find(),
                new Add(),
                new Delete(),
                new Show()
        };
    }

    public int menu(){
        //调整一下格式面板
        //通过使用 this.name，你可以访问当前实例（即 Admin 实例）的 name 成员变量。
        System.out.println("*********************");
        System.out.println("hello "+ 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;

    }

}
Nomal部分
package User;

import Operation.*;

import java.util.Scanner;

public class Nomal extends User{
    public Nomal(String name) {
        super(name);
        this.iOperations=new IOperation[]{
                new Exit(),//退出
                new Find(),//查找
                new Borrow(),//借阅
                new Return()//归还
        };
    }

    public int menu(){

        System.out.println("*********************");
        System.out.println("hello "+ 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;

    }

}

对于各部分的代码已经加上理解的解析语句，希望这篇博客能给正在学习图书管理系统的读者提上一些看法。

2301_80176093
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值