Java基础的小项目 javase小项目

先记录一下最近遇见的gitee方面的问题：

1. 书本类

1.1 标准的javabean类"书"

public class Book {
    //变量属性: 用包装类类型Double,Boolean
    private String bookName;
    private String author;
    private Double price;
    private String type;
    private Boolean isBorrowed = false;//图书的借阅状态
    //构造方法
    public Book() {
    }

    public Book(String bookName, String author, Double price, String type) {
        this.bookName = bookName;
        this.author = author;
        this.price = price;
        this.type = type;

    }
    //get和set方法
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public Boolean getBorrowed() {
        return isBorrowed;
    }
    public void setBorrowed(Boolean borrowed) {
        isBorrowed = borrowed;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ", isBorrowed=" + isBorrowed +
                '}';
    }
}

1.2 "书架"类

public class BookList {
   //静态常量 集合 存放书本对象
    static List<Book> books = new ArrayList<>();
    //在空参构造器中对其初始化
    public BookList(){
        // 数组 存放 所有的书
        books.add(new Book("三国演义","罗贯中",83.6,"小说"));
        books.add(new Book("水浒传","施耐庵",86.6,"小说"));
        books.add(new Book("西游记","吴承恩",87.7,"小说"));
        books.add(new Book("红楼梦","曹雪芹",88.8,"小说"));
    }
    //获取书架上的所有书本，返回值类型是Book类型的集合
    public static List<Book> getBooks(){
        return books;
    }
    //根据书本名称判断是否在books集合里存在
    public boolean isBookContains(String bookName) {
        List<Book> books = BookList.getBooks();
        for (Book book : books) {
            if (book.getBookName().contains(bookName)) {
                return true;
            }
        }
        return false;
    }
}

2. 用户类

用户主要分两类：普通用户和管理员。他们都继承父类User。

2.1 父类：用户类

public abstract class User {//抽象方法所在类一定是抽象类
    protected  String userName;
    //构造方法
    public User() {
    }
    public User(String userName){
        this.userName = userName;
    }
    //get和set方法
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }

    //抽象方法： 因为管理员和普通用户的菜单不同，所以写为抽象方法
    public abstract void menu();

    //方法： 具体的操作：接收 用户的选择，在哪个书架上进行的操作(子类的Operation会抛出异常来处理异常，父类也需要抛出异常,因为父类抛出异常大小要大于子类重写方法抛出的异常 )
    public void doOperation(int choice, BookList bookList) throws ExceptionOperation {
    };

}

2.2 子类：管理员类

public class AdminUser extends User {
    //有参构造方法
    public AdminUser(String userName){
        super(userName);
    }

    //重写父类中的抽象方法 menu
    @Override
    public void menu() {
        //用户通过键盘输入信息
        Scanner sc = new Scanner(System.in);
        System.out.println("##################################");
        System.out.println("欢迎管理员"+userName+"登录图书管理系统");
        System.out.println("              1 增加书籍           ");
        System.out.println("              2 删除书籍           ");
        System.out.println("              3 修改书籍           ");
        System.out.println("              4 查阅书籍           ");
        System.out.println("              5 显示书籍           ");
        System.out.println("              0 退出系统           ");
        System.out.println("##################################");
    }

    //重写父类中的抽象方法 doOperation
    @Override
    public void doOperation(int choice, BookList bookList) throws ExceptionOperation {
        IOperation iOperation = null;//初始化接口类型的变量值iOperation
        switch (choice){
            case 0:
                iOperation=new ExitOperation();
                break;
            case 1:
                iOperation=new AddOperation() ;
                break;
            case 2:
                iOperation=new DeleteOperation();
                break;
            case 3:
                iOperation=new UpdateOperation();
                break;
            case 4:
                iOperation= new QueryOperation();
                break;
            case 5:
                iOperation = new DisplayOperation();
                break;
            default:
                throw new ExceptionOperation("输入错误，请重新输入！");
       }
       try {//尝试执行上述这些方法操作
           iOperation.doWork(bookList);//方法操作实现了接口中的doWork方法
       }catch(ExceptionOperation e){
           System.out.println(e.getMessage());
       }catch (Exception e) {
           e.printStackTrace();
       }
    }
}

2.3 子类：普通用户类

public class NormalUser extends User {
    //有参构造方法 继承父类
    public NormalUser(String userName) {
        super(userName);
    }

    //对User类中的menu方法进行重写
    @Override
    public void menu() {
        //用户通过键盘输入信息
        Scanner sc = new Scanner(System.in);
        System.out.println("#############$$$$$$################");
        System.out.println("欢迎普通用户"+userName+"登录图书管理系统");
        System.out.println("            0 退出系统               ");
        System.out.println("            1 显示书籍               ");
        System.out.println("            2 查询书籍               ");
        System.out.println("            3 借阅书籍               ");
        System.out.println("            4 归还书籍               ");
        System.out.println("####################################");
}

    @Override
    public void doOperation(int choice, BookList bookList) throws ExceptionOperation {
        IOperation iOperation = null;
        switch(choice){
            case 0:
                iOperation = new ExitOperation();
                break;
            case 1:
                iOperation = new DisplayOperation();
                break;
            case 2:
                iOperation = new QueryOperation();
                break;
            case 3:
                iOperation = new BorrowOperation();
                break;
            case 4:
                iOperation = new ReturnOperation();
                break;
            default:
                throw new ExceptionOperation("输入错误，请重新输入！");
        }
        try {//尝试执行
            iOperation.doWork(bookList);
        }catch(ExceptionOperation e){
            System.out.println(e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 操作类

操作类主要是具体的增删改查等方法，通过重写接口中的doWork函数实现。

3.0 接口 Operation实现doWork方法

        因为不同的管理员或者是普通用户，他们要实现的菜单“增删改查”的功能是不一致的，所以定义一个抽象方法:对哪个书架上的书进行“menu"中的操作。

/**
 我们需要执行的操作有增加，删除，显示，查找等，他们都需要遵循一定的规范，
* 而这个规范就由接口来实现，在增删查改等操作中，他们的主要方式就是工作，即doWork(),
* 故接口中提供对应的doWork()方法供接口的实现类，即各种操作进行重写*/
public interface IOperation {
    public abstract void doWork(BookList bookList) throws Exception;
}

3.1 增加操作

根据获取的书本名称判断该书是否已存在，如果有则提示不能重复添加，没有则正常添加。

public class AddOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        System.out.println("您正在进行的是添加书籍操作");
        //获取要添加的书籍名称——>和书架上的书的书名进行对比——>存在则显示已有该书籍——>不存在则进行添加
        System.out.println("请输入您要添加的书名：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.next();
        //和书架上的书的书名进行对比
        if(bookList.isBookContains(bookName)){
            throw new ExceptionOperation("该书籍已存在,请勿重复添加！");
        }else{
            System.out.println("请输入要添加书本的作者：");
            String author = sc.next();
            System.out.println("请输入要添加书本的价格：");
            Double price = sc.nextDouble();
            System.out.println("请输入要添加书本的类型：");
            String type = sc.next();
            //新建一个书本对象，将这些信息传进去
            Book book = new Book(bookName,author,price,type);
            //将该书本添加到books书架上
            addBook(book);
        }
    }
    public void addBook(Book book) {//书架上添加该书本
        BookList.getBooks().add(book);
        System.out.println("书籍添加成功！");
    }
}

3.2 删除操作

根据获取的书名删除图书信息，如果有则删除成功，否则抛出异常信息。

public class DeleteOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除的书本名称：");
        String bookName = sc.next();
        if(!bookList.isBookContains(bookName)){
            System.out.println("该书籍不存在");
        }else{
            System.out.println("查找到了，请问是否要进行删除:"+bookName+"(Y/N)");
            if(sc.next().equalsIgnoreCase("y")){ //进行删除操作                //删除该书本
            deleteBook(bookName);//调用deleteBook函数
            }
        }
    }

    public void deleteBook(String bookName) throws ExceptionOperation {       
        List<Book> books = BookList.getBooks();
        for (int i = 0; i < books.size(); i++) {
            if(bookName.equals(books.get(i).getBookName())){
                books.remove(books.get(i));
                return;
            }
        }
        throw new ExceptionOperation("未查找到该书籍!");
    }
}

3.3 修改操作

根据获取的书名修改图书的价格；如果没有该书，则抛出异常信息。

public class UpdateOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        System.out.println("请输入要修改的图书名称：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.next();
        //修改图书的价格
        System.out.println("请输入要修改的图书价格：");
        Double price = sc.nextDouble();
        setPriceFun(bookName,price,bookList);//调用方法：setPriceFun
    }
    public void setPriceFun(String bookName,Double price,BookList bookList) throws ExceptionOperation {
        List<Book> books = BookList.getBooks();
        for (Book book : books) {
            if(book.getBookName().equals(bookName)){
                book.setPrice(price);
                DisplayOperation.display();
                return;
            }
        }
        //否则(没找到该书)，抛出异常信息
        throw new ExceptionOperation("价格修改失败!");
    }
}

3.4 查询操作

根据获取的图书名称判断书本集合中是否有该书，有的话打印该书信息；没有则抛出异常信息。

public class QueryOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        //查询书籍：有两种状态：要么找到了打印该书籍信息，要么没找到抛出异常信息
        System.out.println("请输入要查询的图书名称：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.next();
        //方法：displayFindBook 判断输入的图书与书籍名称集合是否相等,给出结果
        displayFindBook(bookName);
    }
    public void displayFindBook(String bookName) throws ExceptionOperation {
        List<Book> books = BookList.getBooks();
        for (Book book : books) {
            if(book.getBookName().equals(bookName)){
                System.out.println("已找到该书！");
                System.out.println(book);
                return;
            }
        }
        //否则(没找到该书)，抛出异常信息
        throw new ExceptionOperation("没有找到该书！");
    }
}

3.5 借阅图书操作

我们在这里的归还和借阅图书的功能实现比较简单，目前只根据书籍的isBorrow属性来表示是否借阅与归还成功：isBorrow为false，表示该书可以被借阅；为true，表示该书已被借阅。

根据获取的书本名称判断该书是否存在，存在且书籍的isBorrow属性值为false，则可以借阅，否则不能借阅抛出异常信息。

public class BorrowOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        System.out.println("您正在进行借阅图书的操作：");
        System.out.println("请输入要借阅的图书名称：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.next();
        //判断该图书的借阅状态是否为false,为false则可以借书，否则给出提示
        isBorrow(bookName);
    }
    public static void isBorrow(String bookName) throws ExceptionOperation {
        List<Book> books = BookList.getBooks();
        for(int i=0;i< books.size();i++){
            if(books.get(i).getBookName().equals(bookName)){ //查找到该书，说明该书还未被借出在图书馆中
                if(books.get(i).getBorrowed()){//如果为true
                    System.out.println("借书失败，该书已被借出!");
                }else{ //为默认状态false:书未被借出
                    System.out.println("借出成功!");
                    books.get(i).setBorrowed(true);//更新书籍的借阅状态
                }
                return;
            }
        }
        throw new ExceptionOperation("未查找到该书!");
    }

}

3.6 归还图书操作

根据书本名称判读该书是否存在，存在则将书籍的isBorrow属性值置为false。

public class ReturnOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        System.out.println("请输入要归还的图书名称：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.next();
       //方法： isReturn 更新书籍的归还状态
        isReturn(bookName);
    }

    public void isReturn(String bookName) throws ExceptionOperation {
        List<Book> books = BookList.getBooks();
        for (Book book : books) {//默认书籍的状态是false，表示未被借出
            if(book.getBookName().equals(bookName)){
                System.out.println("该书已归还成功!");
                book.setBorrowed(false);
                return;
            }
        }
        throw new ExceptionOperation("没有找到该书，该书归还失败！");
    }
}

3.7 展示图书操作

public class DisplayOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) {
        System.out.println("正在显示书籍：");
        display();
    }
    public static void display() {//遍历"书架"这个列表，打印书架上所有书的信息
        List<Book> books = BookList.getBooks();
        for (Book book : books) {
            System.out.println(book);
        }
    }
}

3.8 退出系统操作

public class ExitOperation implements IOperation {
    @Override
    public void doWork(BookList bookList) throws ExceptionOperation {
        System.out.println("请问您是否要退出？是:Y,否:N");
        Scanner sc = new Scanner(System.in);
        String answer = sc.next();
        if(answer.equalsIgnoreCase("Y")){
            System.out.println("退出成功！");
            System.exit(0);
        }
    }
}

3.9 操作异常 操作

public class ExceptionOperation extends Exception{

    public ExceptionOperation() {
    }

    public ExceptionOperation(String message) {
        super(message);
    }
}

4. 测试类

public class TestDemo {
    public static void main(String[] args) throws Exception {
        BookList booklist = new BookList();//新建一个书架
        User user = getUserID(); //login函数返回的是一个 User类型的用户user
        while (true){
            user.menu();//根据用户的不同，选择不同的菜单
            int choice = getChoice();//获取用户选择的操作
            user.doOperation(choice,booklist);//根据choice调用所选择的身份调用不同的doOperation方法
        }
    }
    public static int getChoice(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的选择：");
        int choice = sc.nextInt();
        return choice;
    }
    //返回用户的身份类型
    public static User getUserID() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的姓名：");
        String userNname = sc.next();
        System.out.println("请输入您的身份：0管理员 1普通用户");
        int id = sc.nextInt();
        if(id == 0){
            return new AdminUser(userNname);
        }else {
            return new NormalUser(userNname);
        }
    }
}