[Java SE] 图书管理系统 - 框架

1.创建3个包+一个存在main的文件

2.包：

operation：和操作相关的

1.IOperation :接口

2.AddOperation 类  等操作类

1.这些类都实现了IOperation接口

 2.每个类都对应一种操作，这个操作在类的方法work()里

3.把 work(BookList bookList）方法写在接口里

4.实现了接口的类要重写 work( BookList bookList ) 方法，用来实现各自的操作

5.所有的类对外都可以当做是IOperation接口（存放在IOperation的数组里）

package operation;      // 导入operation包 - 里面存放和搓澡相关的类

import book.BookList;              //导入book包里的BookList类

public interface IOperation {      //接口
    void work(BookList bookList);  //抽象方法，专门给各种操作类重写的
}

user：和人有关的

父类：User类型

子类：Admin类型

子类：NormalUser类型

1.Admin对象、NormalUser对象都可以传给User的引用来引用。

2.只有一个对象可以给User引用，对User的操作其实是对其中一个对象的操作

3.User类型有人继承，干脆把成员变量写成protected

4.User里有 (protected)：

    用户的名字、一个抽象菜单menu、

    一个IOperation类型的数组（这个数组里可以放各种操作类）

    一个根据用户选项执行操作的方法

package user;

import book.BookList;
import operation.IOperation;

//这是一个抽象类
public abstract class User {
    //该类要被继承，干脆成员变量就写 protected 修饰
    protected String name;

    //存各种操作类
    protected  IOperation[] iOperations;

    public User(String name) {
        this.name = name;
    }

    //抽象方法 - 显示菜单
    abstract public int menu();


    //用来调用各操作类 - 根据用户选项执行操作
    public abstract void doOperations(BookList bookList,int choice) ;

}

1.两个子类重写menu菜单 （ user.menu()即可输出对应子类的菜单 ），返回choice

2.这个IOperation类型的数组初始化放在他两个子类里，根据menu菜单new出对应的类的对象 

3.因为IOperation类型的数组被protected修饰，要在User里写一个public方法接收choice

   在主函数里这样用：user.doOperations( bookList,choice )

book：和书有关的

1.书的类型 Book

2.书单【顺序表】 BookList   

1.Book里： 书的组成

2..BookList 里：

一个Book类型的数组

一个存有效数据的useSize

 构造方法：一创建对象就给数组存三本书

                   useSize=3

3.BookList都没有人继承，干脆把那些个成员变量设为private

4.private -> 要提供set 、get方法。在操作类中对一些成员属性进行修改

3.代码 ： 

主函数：

import book.BookList;
import user.Admin;
import user.NormalUser;
import user.User;
import java.util.Scanner;

public class TestDemo {
    //创建用户
    public static User identi(int choice,String user_name){
        if(choice==1){
            return new Admin(user_name);
        }
         return new NormalUser(user_name);
    }


    public static void main(String[] args) {
        //先建一个通讯录
        BookList bookList=new BookList();

        System.out.println("请输入你的姓名");
        Scanner scanner=new Scanner(System.in);
        String user_name=scanner.nextLine();
        System.out.println("请输入你的身份 ： 1.管理员  2.用户");
        int choice=scanner.nextInt();
        //向上转型 - 创建用户
        User user= identi(choice,user_name);       
        //根据choice2来确定调用那个类
        while(true){
            //多态 - 打印菜单
            int choice2=user.menu();
           //用户的操作
            user.doOperations(bookList,choice2);
        }
    }
}

book包：

 （1）Book类  

package book;

public class Book {
    //没有人要继承BookList,干脆成员变量都用private修饰
    private String book_name;
    private String author;
    private int price;
    private  String type;
    private boolean is_borrowed=false;     //不写默认也是false

    public Book(String book_name, String author, int price, String type) {
        this.book_name = book_name;
        this.author = author;
        this.price = price;
        this.type = type;
    }

    //后面肯定要打印，重写一个toString
    @Override
    public String toString() {
        return "Book{" +
                "book_name='" + book_name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ", is_borrowed=" + is_borrowed +
                '}';
    }

    //借阅时对is_borrowed进行修改
    public boolean isIs_borrowed() {
        return is_borrowed;
    }

    public void setIs_borrowed(boolean is_borrowed) {
        this.is_borrowed = is_borrowed;
    }

    //通过地址获得名字
    public String getBook_name() {
        return book_name;
    }
}

 （2）BookList类

package book;

public class BookList {
    //没有人要继承BookList,干脆成员变量都用private修饰
    private Book []books=new Book[100];     //顺序表底层是个数组
    private int useSize;

    public BookList(){         //构造方法一般都是public?
        books[0]=new Book ("三国演义","罗贯中",100,"小说");
        books[1]=new Book ("水浒传","施耐庵",100,"小说");
        books[2]=new Book ("西游记","吴承恩",100,"小说");
        this.useSize=3;
    }

    //对数组的一些操作可以写在这里，不过现在我想写在operation的包里，便于管理
    
    //后面肯定会对useSize进行修改
    public int getUseSize() {
        return useSize;
    }

    public void setUseSize(int useSize) {
        this.useSize = useSize;
    }
    //在末尾增添一本书
    public void addBook(Book book) {
        books[useSize] = book;
    }
    
    public Book getBook(int index) {
        return books[index];
    }
    //在index位置插入一本书
    public void setBook(int index,Book book) {
        books[index] = book;
    }

operation包： 

说明：因为很多类的属性被protected/private修饰了，所以在操作类里我们要注意该如何获取/修改被修饰类的属性

 （1）IOperation接口

package operation;

import book.BookList;

public interface IOperation {
    void work(BookList bookList);    //实现了该接口的类，都必须实现该接口的所有方法
}

 一点关于接口的说明：

1.接口就是一个完全抽象的类，和抽象类一样不能产生对象，但是可以作为（实现了该接口的类的）引用，可以发生向上转型

2.只要类实现了这个接口，该类的引用都可以是该接口类型的引用。但是，这个引用只能调用接口中已有的方法，不能调用接口中没有的方法

3.所以，假如一个类实现了很多接口，他可以有很多接口类型的引用，每个引用都只能调用该接口类型中的方法，不能调用接口类型中没有的方法

（2） AddOperation类  - 增加操作

package operation;
import book.Book;
import book.BookList;
import java.util.Scanner;

public class AddOperation implements IOperation{

    @Override
    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();
        System.out.println("请输入类型");
        String type=scanner.next();          //不能写成nextLine  因为上面整形的回车会被吸收
        //创造这本书
        Book book=new Book(name,author,price,type); 
        //在bookList中传入这本书
        bookList.addBook(book);   
        //useSize要变
        bookList.setUseSize(bookList.getUseSize()+1);

        System.out.println("新增图书 - 成功");
        
    }
}

（3）BrrowOperation类 - 借阅操作

package operation;
import book.BookList;
import java.util.Scanner;

public class BorrowOperation implements IOperation{
    @Override
    public void work(BookList bookList) {

        java.util.Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要借阅的书名");
        String name=scanner.nextLine();
        //因为booklist的成员属性都被protected修饰，所以属性只能通过Booklist里的一个公共方法获取
        for (int i=0;i<bookList.getUseSize();i++){
            if(bookList.getBook(i).getBook_name().equals(name)){   //比较字符串: 字符串. equals(字符串)
                if(bookList.getBook(i).isIs_borrowed()==true){     //bookList.getBook(i) 获得书的地址 //.isIs_borrowed()看该书是否被借阅
                    System.out.println("对不起，该数已被借出");
                    return ;
                }
                bookList.getBook(i).setIs_borrowed(true);   //.setIs_borrowed(true) 把该书置为已借出
                System.out.println("借阅成功");
                return;
            }
        }
        System.out.println("找不到这本书");
    }
}

（4）DelOperation类 - 删除操作

package operation;
import book.BookList;
import java.util.Scanner;

public class DelOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要删除的书名");
        String name=scanner.nextLine();

        for (int i=0;i<bookList.getUseSize();i++){
            if(bookList.getBook(i).getBook_name().equals(name)){
                for (int j = i; j < bookList.getUseSize()-1; j++) {
                    //不可以bookList[j] - 因为bookList数组被private修饰
                    bookList.setBook(j,bookList.getBook(j+1));  
                }              
                //更改useSize
                bookList.setUseSize(bookList.getUseSize()-1);
                System.out.println("已删除");
                return ;
            }
        }
        System.out.println("找不到这本书");
    }
}

（5）DisplayOperation类 - 打印所有书目

package operation;
import book.BookList;

public class DisplayOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        for (int i=0;i<bookList.getUseSize();i++){
            System.out.println(bookList.getBook(i));
        }
    }
}

（6）ExitOperation类 - 退出程序

package operation;
import book.BookList;

public class ExitOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出");
        //System.exit(0);  0表示正常退出  //非0表示异常退出
        System.exit(0);
    }
}

（7）FindOperation类 - 查找书

package operation;
import book.BookList;
import java.util.Scanner;

public class FindOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要查找的书名");
        String  name=scanner.nextLine();

        for (int i=0;i<bookList.getUseSize();i++){
            if(bookList.getBook(i).getBook_name().equals(name)){
                System.out.println(bookList.getBook(i));
                return;
            }
        }
        System.out.println("找不到这本书");
    }
}

（8）ReturnOperation类 - 归还书

package operation;
import book.BookList;
import java.util.Scanner;

public class ReturnOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要归还的书籍");
        String name=scanner.nextLine();

        for (int i=0;i<bookList.getUseSize();i++){
            if(bookList.getBook(i).getBook_name().equals(name)){
                bookList.getBook(i).setIs_borrowed(false);
                System.out.println("归还成功");
                return;
            }
        }
        System.out.println("找不到这本书");
    }
}

user包：

（1）User类 - 父类

package user;
import book.BookList;
import operation.IOperation;

//这是一个抽象类
public abstract class User {
    //该类要被继承，干脆成员变量就写 protected 修饰
    protected String name;
    //存各种操作类
    protected  IOperation[] iOperations;

    public User(String name) {
        this.name = name;
    }
    //抽象方法 - 显示菜单
    abstract public int menu();    
    //用来调用各操作类 - 根据用户选项执行操作
    public abstract void doOperations(BookList bookList,int choice) ;

}

（2）Admin类

package user;
import book.BookList;
import operation.*;
import java.util.Scanner;

public class Admin extends User{

    public Admin(String name) {
        super(name);
        //一调用，就给这个数组初始化
        iOperations=new IOperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new DisplayOperation()
        };
    }
    //重写menu方法
    @Override
    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("4.显示所有图书");
        System.out.println("0.退出系统");
        System.out.println("=====================");
        Scanner scanner=new Scanner(System.in);
        int choice =scanner.nextInt();
        return choice;
    }
    //重写Admin用户对应的操作
    @Override
    public void doOperations(BookList bookList, int choice) {
        iOperations[choice].work(bookList);
    }
}

（3）NormalUser类

package user;
import book.BookList;
import operation.*;
import java.util.Scanner;

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        //一调用，就给这个数组初始化
        iOperations=new IOperation[]{
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation(),
        };
    }
    //重写menu方法
    @Override
    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;
    }
   //重写NormalUser对应的操作
    @Override
    public void doOperations(BookList bookList, int choice) {
        iOperations[choice].work(bookList);
    }
}

总结：每次写项目时，都来看看这个项目的思想（封装、继承、多态）