首页 > 编程语言 >简略的图书系统（对刚学完的javase语法运用）

简略的图书系统（对刚学完的javase语法运用）

时间：2024-11-08 22:45:48浏览次数：6  
标签：name 简略 int 刚学 System println javase public out

目录

1，实现图书系统的思维过程（使不同的内容构架联系起来）

2，主要操作的代码

2.1，IOPeration

2.2，AddOperation

2.3，BorrowedOperation

2.4，DelOperation

2.5，ExitOperation

2.6，FindOperation

2.7，ReturnOperation

2.8，ShowOperation

2.9，Main

刚学完javase，对知识使用起来，让自己熟悉和进步，继续努力！＼(￣▽￣)／

1，实现图书系统的思维过程（使不同的内容构架联系起来）

在实现一个程序的过程，思考有哪些东西需要添加，那么首先明确，自己需要的内容：

图书系统，那么我们需要一个Book类来描述书籍的属性：

其中有书名name，作者author，价格price，类型type，还有借书一方面，读者借书时查询书籍是否被借isBorrowed；那么建立构造方法和setter和gettter方法。

public class Book {
    private String name;//书名
    private String author;//作者
    private int price;//价格
    private String type;//类型
    private boolean isBorrowed;//是否被借出   默认是false


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

    public String getName() {
        return name;
    }

    public void setName(String 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 String getType() {
        return type;
    }

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

    public boolean isBorrowed() {
        return isBorrowed;
    }

    public void setBorrowed(boolean borrowed) {
        isBorrowed = borrowed;
    }

因为书籍是用字符串引用类型的，它的类由value[]和哈希组成，所以我们要将其转化成字符串类型

 public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ((isBorrowed == true) ? "已经被借出":"未被借出")
                /*", isBorrowed=" + isBorrowed */+
                '}';
    }
}

有了Book，那么我们需要调用书籍的内容，那么我们需要一个书架来装我们的书籍，方便调用，建立一个BookList类，定义一个Book类的数组，来存放书籍，定义一个usedSize来记录当前书架上存放着多少书籍，方便我们后面的使用。

public class BookList {
    private Book[] books = new Book[10];
    private int usedSize;//计数器 来记录 当前实际放的书的书目

    public BookList(){
        //构造方法 来初始化成员
        this.books[0] = new Book("三国演义","罗贯中",10,"小说");
        this.books[1] = new Book("西游记","吴承恩",23,"小说");
        this.books[2] = new Book("红楼梦","曹雪芹",8,"小说");
        this.usedSize = 3;
    }

    public Book getBook(int pos){
        return books[pos];
    }

    public void setBook(int pos,Book book){
        books[pos] = book;
    }

    public int getUsedSize() {
        return usedSize;
    }

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

}

那么书籍的内容算想不出其他的了，它们都是关于书籍，那么建立一个book包来装Book类和BookList类。

对书籍进行操作的对象有读者和我们管理员，读者有许多操作，如查找图书，借阅图书，归还图书，管理员还需要新增图书，删除图书，显示图书。最后操作完后，我们还需要退出系统。

那么我们定义一个User包来装AdminUser （管理员）和NormalUser（读者），因为他们肯定有很多属性是相同的，建立User类，让AdminUser和NormalUser继承User类，在User类的基础上做出改变。

建立一个Main类，来实现我们的主程序。首先输入姓名和身份，然后进行操作。

Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();
        System.out.println("请输入你的身份：1-》管理员  0-》普通用户");

那么是1时，就调用到AdminUser类，反之调用NormalUser类。

int choice = scanner.nextInt();
        if(choice == 1){
            return new AdminUser(name);
        }else {
            return new NormalUser(name);
        }

在进入用户的进程后，自然要根据不同用户实现不同的操作，那么就让AdminUser和NormalUser和操作联系起来，在调用到用户时就可以进行对应的操作。

因为操作很多，不可能一一调用，那么定义一个接口，这样调用就方便了。

首先建立类和接口，AddOperation（添加图书），BorrowedOperation（借阅图书），DelOperation（删除图书），FindOperation（查询图书），ReturnOperation（归还图书），ShowOperation（显示图书）和ExitOperation（退出系统）与连接的接口IOPeration。

因为调用到用户时，根据不同用户调出不同操作界面，那么定义一个菜单，根据选项来进入不同的操作，所以菜单方法定义int类型，返回一个值来进入不同操作。

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("****************************");
            System.out.println("请输入你的操作：");
            Scanner scanner = new Scanner(System.in);
            int choice = scanner.nextInt();
            return choice;
        }


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("****************************");
        System.out.println("请输入你的操作：");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }

分别放进AdminUser类和NormalUser类中，不要忘了在User父类中定义方法。父类中不需要实现，可是使用抽象类来声明，定义方法doOperation，是对书架的书籍进行操作，因为根据菜单的选项的不同，进行不同操作，刚好可以使用下标这点，使用接口定义一个数组，这样选项不同就刚好可以调用到相应的操作。

package user;

import book.Book;
import book.BookList;
import operation.IOPeration;

public abstract class User {
    protected String name;//姓名
    public IOPeration[] ioPerations;//只是定义并没有初始化大小
    public User(String name) {
        this.name = name;
    }

    public abstract int menu();

    public void doOperation(int choice, BookList bookList){
        ioPerations[choice].work(bookList);
    }
}

AdminUser和NormalUser重写父类，这里只写一个

package user;

import operation.*;

import java.util.Scanner;

public class AdminUser extends User{
    public AdminUser(String name) {
        super(name);
        this.ioPerations = new IOPeration[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new ShowOperation()
        };
    }

    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("****************************");
        System.out.println("请输入你的操作：");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

最后就是对不同的操作内容进行完善，因为整体的构架联系已经完成了，操作内容就很简单了，这里附上代码：

2，主要操作的代码

2.1，IOPeration

package operation;

import book.BookList;

public interface IOPeration {
    void work(BookList bookList);
}

2.2，AddOperation

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class AddOperation 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();
        System.out.println("请输入类型:");
        String type = scanner.nextLine();

        Book book = new Book(name,author,price,type);

        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.setBook(currentSize,book);

        bookList.setUsedSize(currentSize+1);
    }
}

2.3，BorrowedOperation

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class BorrowedOperation 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.isBorrowed()){
                    book1.setBorrowed(true);
                    System.out.println("恭喜你成功借到了这本书！");
                }else {
                    System.out.println("这本书已经被借走了！");
                }
                return;
            }
        }

        System.out.println("没有你要借阅的图书！");
    }
}

2.4，DelOperation

import java.util.Scanner;


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

        //1.找到你要删除的书
        int currentSize = bookList.getUsedSize();
        if(currentSize == 0){
            System.out.println("书架为空，不能删除！");
            return;
        }
        int index = -1;

        for(int i = 0; i<currentSize;i++){
            Book book1 = bookList.getBook(i);
            if(book1.getName().equals(name)){
                index = i;
                break;
            }
        }
        //2.index !=-1  有这本书，开始删除
        if(index == -1){
            System.out.println("没有你要删除的书");
            return;
        }

        for(int i = index; i< currentSize-1;i++){
            Book book1 = bookList.getBook(i+1);
            bookList.setBook(i,book1);
        }

        //当书被删掉以后  需要维持usedSize
        bookList.setUsedSize(currentSize-1);
    }
}

2.5，ExitOperation

package operation;

import book.Book;
import book.BookList;

public class ExitOperation implements IOPeration{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统!");

        int currentSize = bookList.getUsedSize();

        for(int i = 0;i< currentSize;i++){
           bookList.setBook(i,null);
        }
        bookList.setUsedSize(0);

        System.exit(0);
    }
}

2.6，FindOperation

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class FindOperation 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 book = bookList.getBook(i);
            if(book.getName().equals(name)){
                System.out.println("找到了你要查找的书");
                System.out.println(book);
                return;
            }
        }

        System.out.println("不好意思，这好像没有这本书！！");
    }

}

2.7，ReturnOperation

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class ReturnOperation 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)){
                book1.setBorrowed(false);
                System.out.println("归还成功！");
                return;
            }
        }
        System.out.println("没有你要归还的图书！");
    }
}

2.8，ShowOperation

package operation;

import book.Book;
import book.BookList;

public class ShowOperation implements IOPeration{
    @Override
    public void work(BookList bookList) {
        System.out.println("显示图书!");

        int currentSize = bookList.getUsedSize();

        for(int i = 0;i< currentSize;i++){
            Book book = bookList.getBook(i);
            System.out.println(book);
        }
    }
}

2.9，Main

import book.BookList;
import user.AdminUser;
import user.NormalUser;
import user.User;

import java.util.Scanner;

public class Main {
    //可以利用返回值 的向上转型 达到返回的一致性
    public static User login(){
        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){
           /* AdminUser adminUser = new AdminUser(name);
            return adminUser;*/
            return new AdminUser(name);
        }else {
            /*NormalUser normalUser = new NormalUser(name);
            return normalUser;*/
            return new NormalUser(name);
        }

    }
    public static void main(String[] args) {
        BookList bookList = new BookList();
            User user = login();
        while(true){
            int choice = user.menu();
            //user是哪个对象？choice是几？ ---》 能够确认：我能够操作哪个对象的哪个方法？
            //通过这两个变量 可以确定了 但是怎么联系起来呢？？
            /*
             * 1.先让双方 存好 对应自己的操作
             * 2.就是调用对应的操作
             */
            user.doOperation(choice,bookList);
        /*System.out.println(choice);
        System.out.println(user);*/
        }

    }
}

标签：name,简略,int,刚学,System,println,javase,public,out
From： https://blog.csdn.net/2301_81080732/article/details/143635512

相关文章

  • 【JavaSE】认识String类，了解，进阶到熟练掌握
    #1024程序员节|征文#下面就让博主带领大家一起解决心中关于String类的疑问吧~~~1.字符串构造：第一种和第二种（有一定的区别，在常量池上）publicstaticvoidmain(String[]args){//使用常量串构造Strings1="hello";System.out.println(s1);//直接newString对象S......
  • JavaSE——多线程2：线程池详解
    一、线程池介绍        线程池（ThreadPool）是一种基于多线程处理的服务器架构，它预先创建并维护一组线程，用于处理异步任务或并发请求。线程池的设计目的是减少创建和销毁线程的开销，提高系统的响应速度和吞吐量。(一)线程池的主要核心原理创建一个池子，池子中是空的。......
  • 基于JAVASE的题
    字符集合描述：每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。每组数据一行，按字符串原有的字符顺序，输出字符集合，记重复出现并靠后的字母不输出。例如：输入：ABABc输出：ABc思路：每组输入，所以要进行while循环输入，写一个fun方法进行描写，首先实......
  • JavaSE-继承（包含Object类）
    目录继承（包含Object类）何为继承优点代码复用易于维护和扩展缺点紧密耦合缺乏灵活性常用的方法Object类Object类中的常用方法：方法重写规则方法重写规则方法重写与方法重载的区别示例代码super关键字的用法示例代码final关键字的用法示例代码继承（包含Object类）何为继承在面向对象编......
  • JavaSE——IO流5：高级流(序列化与反序列化流/对象操作流)
    目录一、序列化流/对象操作输出流——ObjectOutputStream二、反序列化流/对象操作输入流——ObjecInputStream三、序列化流和反序列化流使用细节1.Serializable接口2.序列化后的文件不可修改3.serialVersionUID4.transient修饰的不能被序列化四、用对象流读写多个对象......
  • 刚刚学了链表感觉好难（||^||)
    理念听得差不多明白了，但实现起来感觉好难，老师在上面写代码的时候一蹴而就，我自己尝试的时候一窍不通，下课花了好久才写出差不多的代码，大家有什么好方法吗？球球了（>_<)附上了写的链表代码，也欢迎大家提改进建议#define_CRT_SECURE_NO_WARNINGS#include<stdio.h>#include<stdli......
  • Java最全面试-＞Java基础-＞JavaSE-＞基础语法
    基础语法下边是我自己整理的面试题，基本已经很全面了，想要的可以私信我，我会不定期去更新思维导图哪里不会点哪里基本数据类型和方位修饰符数据类型有哪些基本数据类型byte、int、short、long、float、double、boolean、char引用数据类型类、数组、接口访问权限修饰符......
  • JavaSE JAVA基础总结（一） 我的学习笔记
    JavaSEJAVA基础总结（一）一、Java基础语法1.数据类型2.运算符3.选择结构4.循环结构5.数组6.方法7.递归二、面向对象1.面向对象编程（1）为什么要学习面向对象（2）面向过程与面向对象区别（3）对象（4）类（5）成员变量与局部变量的区别（6）构造器（7）this的关键字（8）标准JavaBean（9）静态关键字：static......
  • javase笔记5----泛型
    泛型简介泛型是一种特殊的数据类型。它是Java的一个高级特性。定义一个语法结构时，不用指明具体类型，而是先定义一个类型变量，在真正使用的时候再确定该变量的具体类型。即类型参数化。语法泛型，定义在一对尖括号中，也是一个标识符，一般用在类名后，遵循大驼峰命名法。通常都......
  • JAVASE进阶面试题大总结
    ​ 面向对象1.解释一下什么是继承在编程领域，“继承”是面向对象编程中的一个重要概念。继承是指一个类（称为子类或派生类）可以从另一个类（称为父类或基类）获取属性和方法。通过继承，子类能够重用父类的代码和功能，同时还可以添加新的属性和方法，或者修改父类中已有的方法的实现，以......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99