目录
此系统主要涉及到了java基础的语法，其中包括类和对象、继承、封装、多态、包、抽象类、接口和数组等，体现了对象之间如何交互。
1.总体框架
简单示意图：
构成：
++解释：分为三步操作。++
++1.书的内容和存取书的书架。++
++2.用户登录，分为管理员登录和普通用户登录。++
++3.对书架的相关操作。++
2.book包
Books类
使用java的封装的特点用私有化的权限定义一些书的属性。这些属性创建后，需要进行初始化，可以使用构造方法，访问这些属性时可以用getter和setter，同时要打印实例化后的对象是，可以重写tostring方法。
详细见下代码，有详细的注解：
java
package book;
public class Books {
//只是写了一些简单的属性，有想法的还可以添加
private String name; //书名
private int price; //价格
private String Author; //作者
private boolean Beborrow; //判断是否被借出的标志
//构造函数，初始化成员，没有Beborrow是因为Beborrow未被初始化是默认值为false，
//表示未借出，所以不用写在构造函数中。
public Books(String name, int price, String author) {
this.name = name;
this.price = price;
this. Author = author;
}
//下面是成员变量的getter和setter函数，后期访问的时候都会使用到
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getAuthor() {
return Author;
}
public void setAuthor(String author) {
Author = author;
}
public boolean isBeborrow() {
return Beborrow;
}
public void setBeborrow(boolean beborrow) {
Beborrow = beborrow;
}
//重写过tostring方法
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
", Author='" + Author + '\'' +
", Beborrow=" + ((Beborrow==true)?"已被借出":"未被借出")+
//用三目运算符表示是否被借出
'}';
}
}booklist类
booklist是用来存储书的，相当于一个书架，这一个类包含了 书籍的数量和存储书的数组，该数组的类型是Books类型的，其中使用java的封装的特点，用私有化的权限定义booklist中 booklistsize（书的个数）这个成员。
详细见以下代码，有详细的注解：
java
package book;
public class Booklist {
private int booklistsize; //私有成员，表示书的个数
Books[] books = new Books[10]; //用来存储书的数组，类型为Books
//构造函数，初始化成员，同时让数组中先存在这三本书
public Booklist() {
this.booklistsize = booklistsize;
books[0] = new Books("三国演义",14,"罗贯中");
books[1] = new Books("西游记",11,"施耐庵");
books[2] = new Books("红楼梦",17,"曹雪芹");
this.booklistsize =3;
}
// 该函数的作用是能够得到pose位置的书，且返回类型为Books，
//这个getBooks与编译器生成的 不一样，要改变一下，后期的操作会使用到
public Books getBooks(int pose) {
return books[pose];
}
//该函数的功能是让第pose位置上有上books（意思就是在数组里面的pose位置上添加上books）
//后期会使用到
public void setBooks(Books books,int pose) {
this.books[pose] = books;
}
//因为booklistsize是私有的，体现了封装的特点，要想使用他，必须要调用getBooklistsize
//后期会使用到
public int getBooklistsize() {
return booklistsize;
}
//给booklistsize设置值，要想访问也是要调用set...
public void setBooklistsize(int booklistsize) {
this.booklistsize = booklistsize;
}
}++总结：写这个包里面的类，先写Books类再写booklist类，难点在于对封装成员的访问（使用getter和setter）以及一些函数的重写（后期在写一些类的时候可以一步一步地完善）。++
3.operation包
这个包包括一些功能操作，其中设置一个接口，通过不同的类来实现接口的操作（体现了java实现多继承的特点）。
详细见下代码，有详细的注释：
IO接口：
java
package opertion;
import book.Booklist;
public interface IO {
//不同的类来实现这个接口，其中接收的参数为booklist这个对象，用于后期对这个对象的操作
void work(Booklist booklist);
}addbooks类：
java
package opertion;
import book.Booklist;
import book.Books;
import java.awt.print.Book;
import java.util.Scanner;
//写这个操作的思路是先判断这个书架是否还可以添加书籍，可以的话就输入书籍的信息，输入后在判断
//添加的书籍是否与书架里的书籍重复，
//不重复的话就用booklist.setBooks（）函数来添加书籍
//然后booklistsize加一
public class addbooks implements IO{
@Override
public void work(Booklist booklist) {
int szie = booklist.getBooklistsize();
System.out.println("添加书籍");
//判断是否满
if(szie==9){
System.out.println("书架已满，无法添加！！");
return;
}
System.out.println("请输入书名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.println("请输入作者：");
String Author = scanner.nextLine();
System.out.println("请输入价格：");
int price = scanner.nextInt();
Books book = new Books(name,price,Author);
//判断是否重复
for(int i = 0;i<szie;i++){
//先用getBooks获取这本书，然后用getname获取这本书的名字
if(book.getName().equals(booklist.getBooks(i).getName())){
System.out.println("存在这本书，无法重复添加！！");
return;
}
booklist.setBooks(book,szie);
booklist.setBooklistsize(szie+1);
}
System.out.println("添加成功！！");
}
}borrowbooks类：
java
package opertion;
import book.Booklist;
import java.util.Scanner;
//对于借书，先执行要借书书的名字，判断是否被借阅了以及有没有这本书，如未被借阅，
//使用setBeborrow来改变Beborrow的值
public class borrowbooks implements IO{
@Override
public void work(Booklist booklist) {
System.out.println("借阅书籍！！");
for (int i = 0; i < booklist.getBooklistsize(); i++) {
System.out.println(booklist.getBooks(i));
}
System.out.println("请输入要借阅书籍的名称：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
int i = 0;
for(;i<booklist.getBooklistsize();i++){
if(name.equals(booklist.getBooks(i).getName())){
if(booklist.getBooks(i).isBeborrow()) {
System.out.println("该书籍已经被借阅了！！");
}
else {
System.out.println("借阅成功！！");
//用setBeborrow来改变Beborrow的值
booklist.getBooks(i).setBeborrow(true);
}
}
if(i ==booklist.getBooklistsize()){
System.out.println("没有该本书！！");
}
}
}
}delbooks类：
java
package opertion;
import book.Booklist;
import book.Books;
import java.util.Scanner;
//删除书的主要思路是自己所输入的书是否在书架上有，如果没有就删除该书，同时size减一
public class delbooks implements IO{
@Override
public void work(Booklist booklist) {
System.out.println("删除书籍！！");
System.out.println("请输入要删除的书籍：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
int index = 0;
int size = booklist.getBooklistsize();
int i = 0;
//先找到要删掉的书籍的位置，记下要该书的位置
for(;i<size-1;i++){
if(name.equals(booklist.getBooks(i).getName())){
i = index;
break;
}
}
if(i == size-1){
System.out.println("找不到该书籍，无法删除！！");
return;
}
//删除的步骤，后面的往前面覆盖
for(i = index;i<size-1;i++){
Books books = booklist.getBooks(i+1);
booklist.setBooks(books,i);
}
//书的个数减一
booklist.setBooklistsize(size-1);
System.out.println("删除成功！！");
}
}returnbooks类：
java
package opertion;
import book.Booklist;
import java.util.Scanner;
//主要思路和借书一样，代码跟借书的代码差不多，还书判断有没有该本书
public class returnbooks implements IO{
@Override
public void work(Booklist booklist) {
System.out.println("返还书籍！！");
System.out.println("请输入要归还书籍的名称：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
int i = 0;
for(;i<booklist.getBooklistsize();i++){
if(name.equals(booklist.getBooks(i).getName())){
System.out.println("归还成功！！");
booklist.getBooks(i).setBeborrow(false);
}
if(i ==booklist.getBooklistsize()){
System.out.println("没有该本书！！");
}
}
}
}exit类：
java
package opertion;
import book.Booklist;
//代码很简单，关键是能会运用System.exit(0)这个操作
public class exit implements IO{
@Override
public void work(Booklist booklist) {
System.out.println("退出系统！！");
System.exit(0);
}
}4.user包
user包主要包含了Adminuser，commonuser和User这几个类，其中User为抽象类，Adminuser和commonuser这两个类通过继承来实现menu（菜单）这个抽象方法，以此来展示不同的界面。
详细见下代码，有注释：
user类
java
package user;
import book.Booklist;
//抽象方法
abstract public class User {
//包含了私有的成员变量，用户名
private String name;
//构造函数
public User(String name){
this.name = name;
}
//获取名字
public String getName() {
return name;
}
//抽象方法
abstract public void menu(Booklist booklist);
}Adminuser类（难点，有解析）
java
package user;
import book.Booklist;
import opertion.*;
import java.util.Scanner;
//继承User类
public class Adminuser extends User{
//难点：接口为引用类型，定义和初始化一个接口类型的数组，
// 且成员为实现接口的类的实例，此处发生了向上转型，下面使用会用到
//利用接口类型的数组，巧妙的的解决了实现不同功能的问题
IO[] io = new IO[]{new exit(),
new delbooks(),
new addbooks()};
//构造函数，先初始化父类的，用super
public Adminuser(String name){
super(name);
}
public void menu(Booklist booklist) {
int i;
//用getname来获取封装后的name，可以用super也可以不用
System.out.println(super.getName()+" "+"你好！！"+"欢迎来到管理员界面**********");
System.out.println("1.删除书籍");
System.out.println("2.添加书籍");
System.out.println("0.退出系统");
System.out.println("请选择:");
Scanner scanner = new Scanner(System.in);
int choice = scanner.nextInt();
for (i = 0; i< io.length ; i++) {
if(i == choice){
//接上面的难点 ，向上转型，一个对象面对不同对象会有不同的作用
io[i].work(booklist);
}
}
}
}commonuser类（和上面的一样，不做解析了）
java
package user;
import book.Booklist;
import opertion.*;
import java.util.Scanner;
public class commonuser extends User{
IO[] io = new IO[]{new exit(),
new borrowbooks(),
new findbooks(),
new returnbooks()
};
public commonuser(String name){
super(name);
}
@Override
public void menu(Booklist booklist) {
int i;
System.out.println(super.getName()+" "+"你好！！"+"欢迎来到普通用户界面*********");
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();
for (i = 0; i< io.length; i++) {
if(i == choice){
io[i].work(booklist);
}
}
}
}5.Main类
Main类用于写主函数用来执行执行登录的操作。
详细代码见下，有解析：
java
import book.Booklist;
import book.Books;
import user.Adminuser;
import user.User;
import user.commonuser;
import java.util.Scanner;
public class Main {
//使用静态函数，登录操作，不用实例化直接调用
//User为返回值类型，
public static User login(){
System.out.println("请输入你的姓名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.print("请输入你的身份：1.管理员 2.普通用户 --》");
int num = scanner.nextInt();
if(num == 1){
//注意，发生向上转型，因为User为返回值类型且为父类
return new Adminuser(name);
}
else {
return new commonuser(name);
}
}
public static void main(String[] args) {
//实例化对象booklist，后面的传参都会用到
Booklist booklist = new Booklist();
User user = login();
while(true){
//体现了多态的特点，面对不同对象会发生不同的状态
user.menu(booklist);
}
}
}6.操作结果
7.总结：
写这个系统首先要有一个框架，要知道有哪个对象、对象在那个包、怎么合理的利用接口，抽象类等知识。这个系统的难点主要在利用接口类型的数组来实现不同功能以及利用向上转型实现来实现一个对象面向另一个对象所产生的不同的功能；此外还有封装，如怎样访问私有的成员等。详细请看每个代码的注释。