• Java入门项目——读书管理系统

    Java简单实现读书管理系统

    一、前言

    相信有很多小伙伴学习完了【JavaSE】基础语法，想知道自己到底学的怎么样，或则学完不知道这么把知识点连窜起来使用，自己学到的知识会用才是真正的学到了。

    下面就来领取你的第一个Java入门项目（读书管理系统），这里我们肯定是有针对性的去完成的，里面涵盖了许多知识点，例如：数组、循环以及面向对象方面的知识，主要是封装、继承、多态、抽象类、接口、代码块等等的知识点，相信你自己去实现一遍再和小编的实现进行对比或者直接拿来进行学习一定会有所收获。

    学完【JavaSE】写的读书管理系统，编译器用到是IDEA,数据存储在内存中，这里没有用到数据库，随着学习的深入可以后面再改进的哦，实现了读书的查询、添加、删除、借阅、归还、修改。分为管理员和用户。

    码源地址（gitee）：

    二、思路及整体框架

    **

    • 思路：
      随着学习的深入，做项目无从下手，首先要弄明白有什么需求，有需求我们才去实现的嘛，然后再考虑程序的框架，先把框架搭起来，这个过程可以减少后续的很多麻烦。

    • 整体框架：
      正如上面所说的读书管理，既然有读书，那就免不了需要管理，这样我们就可以把有关读书信息的放到一个包下（Book）,在这个包下再创建有关读书的类。有用户分为管理员和普通用户，我们就可以把管理员和普通用户放到一个包（User）下，再这个包下再创建有关用户的类。有关于读书的操作，比如增加、删除读书，我们也可以单独的把它写到一个包（Operate）下，再这个包下再创建有操作读书的类。

    **

    这里为小编搭的框架：

    在这里插入图片描述

    为什么要说先搭框架呢？而不是先把一个个功能先实现呢？道理很简单，我先搭框架，我就能以一个整体的思想去实现这个项目，即使我们把所需要的包以及类全部都创建出来后，你写起来就不会那么的绕，你也一个很好功能实现顺序，会减少很多的开发时间，效率也高。

    三、代码展示

    1.有关读书包（Book）

    这里创建一个Book类来存储有关读书学习的类，所有有关读书的信息我都封装在这个类中。

    package Book;

public class Book {
	//书的属性
    private String name;
    private String author;
    private String type;
    private double price;
    private boolean isBorrowed;//表示书籍状态，是否被借阅，默认false没有借阅

    public Book(String name, String author, String type, double price) {
        this.name = name;
        this.author = author;
        this.type = type;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

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

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

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

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

    public boolean getIsBorrow() {
        return isBorrowed;
    }
	
	//重写toString方法，方便把每本读书信息打印出来
    @Override
    public String toString() {
        return "Book{" +
                "name ='" + name + '\'' +
                ", author ='" + author + '\'' +
                ", type ='" + type + '\'' +
                ", price =" + price +
                ", isBorrowed =" + (isBorrowed ? "已被借阅！" : "未被借阅") +
                '}';
    }
}


    • 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

    在这个包下我们在创建BookShelf类表示书架，用来管理我的每一本书，这里用到一个组合的思想，用Book类型的变量作为Bookshelf的成员变量。

    package Book;

public class BookShelf {
    private static final int BOOK_NUMBER = 100;//书籍容量
    private Book[] books = new Book[BOOK_NUMBER];
    private int currentNumber;//当前书籍的数量

    /**实例代码块/非静态代码块
     * 在我实例这个类的对象的时候就已经加载了着三本书
     */
    {
        books[0] = new Book("三国演义", "罗贯中", "小说", 69.9);
        books[1] = new Book("红楼梦", "曹雪芹", "小说", 49.9);
        books[2] = new Book("水浒传", "施耐庵", "小说", 59.9);

    }
    public void setCurrentNumber(int currentNumber) {
        this.currentNumber = currentNumber;
    }

    //获取书籍列表长度
    public int getCurrentNumber() {
        int index = 0;
        while (books[index] != null) {
            index++;
        }
        return index;
    }

    public void setBooks(int pos, Book book) {
        this.books[pos] = book;
    }
    
    public Book[] getBooks() {
        return books;
    }
    public Book getBook(int pos) {
        return this.books[pos];
    }
    
    //判断书籍是否存在，存在就返回下标，不存在就返回-1
    public int isExist(String name) {
        int length = this.getCurrentNumber();
        for (int i = 0; i < length; i++) {
            if (this.books[i].getName().equals(name)) {
                return i;
            }
        }
        return -1;
    }
}


    • 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

    2.有关用户包

    这里有关用户就是管理员和普通用户，由于管理员和普通用户都是用户，这里就用到继承方面的知识，让普通用户（NormalUser）和管理员（AdministerUser）这两个类继承我的用户（User）类，由于我是不希望实例用户（User）这个类的实例对象的，所以这个类需设置为抽象类为宜，再由普通用户和管理员的菜单都不一样，我们就可以把菜单方法设置为抽象方法。这样操作之后我们不仅体验到抽象类的好处还有多态的好处。

    抽象类User的实现：

    package User;

import Book.BookShelf;
import Operation.Operate;

public abstract class User {
    protected String name;
    protected Operate[] operations;
    public User(String name) {
        this.name = name;
    }
	//抽象方法，继承我的子类必须单独实现这个方法
    public abstract void menu();
    
    //用户进行读书操作的方法，无非就是choice的值对应操作的方法
    public void doWork(int choice, BookShelf bookShelf) {
        this.operations[choice].operate(bookShelf);
    }
}


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

    子类普通用户类和管理员的实现：

    package User;

import Operation.*;

public class NormalUser extends User{

    public NormalUser(String name) {
        super(name);
        super.operations = new Operate[] {
        		//直接赋值对应操作的对象，再实例这个类对象时就有这个操作功能
                new ExitOperation(),
                new BorrowOperation(),
                new ReturnOperation(),
                new SearchOperation()
        };
    }

	//重写抽象方法，属于普通用户的菜单
    @Override
    public void menu() {
        System.out.println("--------------欢迎来到普通用户管理系统--------------");
        System.out.println("--------------0.退出系统-------------------------------------");
        System.out.println("--------------1.借阅读书-------------------------------------");
        System.out.println("--------------2.归还读书-------------------------------------");
        System.out.println("--------------3.查找读书-------------------------------------");
        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
    package User;

import Operation.*;

public class AdministerUser extends User{

    public AdministerUser(String name) {
        super(name);
        super.operations = new Operation.Operate[]{
        		//直接赋值对应操作的对象，再实例这个类对象时就有这个操作功能
                new ExitOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new SearchOperation(),
                new ShowOperation(),
                new UpdateOperation()
        };
    }
	//属于管理员的菜单方法
    @Override
    public void menu() {
        System.out.println("--------------欢迎来到普通用户管理系统--------------");
        System.out.println("--------------0.退出系统-------------------------------------");
        System.out.println("--------------1.添加读书-------------------------------------");
        System.out.println("--------------2.删除读书-------------------------------------");
        System.out.println("--------------3.查找读书-------------------------------------");
        System.out.println("--------------4.显示读书-------------------------------------");
        System.out.println("--------------5.修改读书-------------------------------------");
        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

    3.有关操作书的包

    这里操作有增加、删除读书等操作，不过这些都是对书的操作，我们就可以在一个接口定义操作书的抽象方法，然后让每个操作书的类都实现这个接口，为什么这样做呢？这样可以实现多态啊，又用到多态的好处了😊😊😊。

    接口operate的实现：

    package Operation;

import Book.BookShelf;

public interface Operate {
    void operate(BookShelf bookShelf);
}


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

    添加读书类的实现：

    package Operation;

import Book.Book;
import Book.BookShelf;

import java.util.Scanner;

public class AddOperation implements Operate{
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("添加读书！");
        System.out.println("请输入书名：");
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        System.out.println("请输入作者：");
        String author = sc.nextLine();
        System.out.println("请输入书籍类型：");
        String type = sc.nextLine();
        System.out.println("请输入书籍价格：");
        double price = sc.nextDouble();
        Book book = new Book(name,author,type,price);
        //获取书籍当前该插入的位置
        int length = bookShelf.getCurrentNumber();
        bookShelf.setBooks(length,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
    • 26
    • 27
    • 28
    • 29

    删除读书类的实现：

    package Operation;

import Book.Book;
import Book.BookShelf;

import java.util.Scanner;

public class DeleteOperation implements Operate{
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("删除读书！");
        System.out.println("请输入要删除读书的名称：");
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        if(bookShelf.isExist(name) > 0) {
            int pos = bookShelf.isExist(name);
            if(pos == bookShelf.getCurrentNumber()) {
              bookShelf.setBooks(pos,null);
               bookShelf.setCurrentNumber(pos - 1);
                System.out.println("删除成功！");
            } else {
                int getTheEndBookPos = bookShelf.getCurrentNumber();
                Book book = bookShelf.getBook(getTheEndBookPos - 1);
                bookShelf.setBooks(pos,book);
                System.out.println("删除成功！");
            }
        } else {
            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

    借阅读书类的实现：

    package Operation;

import Book.BookShelf;

import java.util.Scanner;

public class BorrowOperation implements Operate {
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("借阅读书！");
        System.out.println("请输入要借阅读书的名字：");
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();

        if (bookShelf.isExist(name) >= 0 && !bookShelf.getBook(bookShelf.isExist(name)).getIsBorrow()) {
            int pos = bookShelf.isExist(name);
            bookShelf.getBook(pos).isBorrowed(true);
            System.out.println("借阅成功！");
        } else {
            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

    归还读书类的实现：

    package Operation;

import Book.BookShelf;

import java.util.Scanner;

public class ReturnOperation implements Operate{
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("归还读书！");
        System.out.println("请输入你要归还读书的名称：");
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        if(bookShelf.isExist(name) >= 0 && bookShelf.getBook(bookShelf.isExist(name)).getIsBorrow()) {
            int pos = bookShelf.isExist(name);
            bookShelf.getBook(pos).isBorrowed(false);
            System.out.println("归还成功！");
        } else {
            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

    查询读书类的实现：

    package Operation;

import Book.BookShelf;

import java.util.Scanner;

public class SearchOperation implements Operate{
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("查找读书！");
        System.out.println("请输入要查找读书的名称：");
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        if(bookShelf.isExist(name) >= 0) {
            int pos = bookShelf.isExist(name);
            System.out.println(bookShelf.getBook(pos));
            System.out.println("查找成功！");
        } else {
            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

    展示读书类的实现：

    package Operation;

import Book.BookShelf;

public class ShowOperation implements Operate{
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("显示读书！");
        int length = bookShelf.getCurrentNumber();
        for (int i = 0; i < length; i++) {
            System.out.println(bookShelf.getBook(i));
        }
        System.out.println("显示成功！");
    }
}


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

    修改读书类的实现：

    package Operation;

import Book.BookShelf;

import java.util.Scanner;

public class UpdateOperation implements Operate {
    @Override
    public void operate(BookShelf bookShelf) {
        System.out.println("修改读书！");
        System.out.println("请输入要修改读书的名称：");
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        if (bookShelf.isExist(name) > 0) {
            int pos = bookShelf.isExist(name);

            System.out.println("请输入修改的书名：");
            String newName = sc.nextLine();
            bookShelf.getBook(pos).setName(newName);

            System.out.println("请输入要修改的作者：");
            String newAuthor = sc.nextLine();
            bookShelf.getBook(pos).setAuthor(newAuthor);

            System.out.println("请输入要修改的书籍类型：");
            String newType = sc.nextLine();
            bookShelf.getBook(pos).setType(newType);

            System.out.println("请输入要修改的价格：");
            double newPrice = sc.nextDouble();
            bookShelf.getBook(pos).setPrice(newPrice);

            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
    • 36
    • 37

    总结：整体来说学完语法对于有些小伙伴来说是还可以的，但是把它们串起来使用还是有一些难度，最好是要多去实现一下入门的小项目或者直接去了解别人已经写好的项目，自己在上手写一个项目可能对知识点掌握得深刻一些。

  • 相关阅读:
    【持久层框架】- SpringData - JPA
    初识Kafka
    Java 第二阶段提升编程能力【线程（基础）】
    less和scss语法详解
    c# ManualResetEvent WaitHandle 实现同步
    大数据学习3.2 部署Hadoop
    面向对象建模的三种模型是什么，各自的主要功能有哪些，分别可用UML的哪些图来描述？
    一文搞懂 MySQL 索引数据结构
    程序员面试代码
    Cpp知识点系列-宏定义
  • 原文地址：https://blog.csdn.net/qq_59599094/article/details/127925097