【面向对象项目之图书馆管理系统】

项目需求

不同的用户有不同的菜单,然后进行操作。 

设计思路

通过需求我们可以提取图书类,书架类
图书类存放图书的基本信息,书架类存放书本及其它的数量,以及操作图书的方法等等。
接口类(用来操作书架里面的图书)-》写具体的操作实现类

其次提取出用户类,用户类分为普通用户类 管理员类

基本框架代码:

package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-16 - 11 - 16 - 20:59
 * @Description: com.bookmanagement.book
 * @version: 1.0
 */
public class Book {//书类
    private String name;//书名
    private String author;//作者
    private int price;//价格
    private String type;//类型
    private boolean isBorrowed;//是否被借出
    public Book(String name, String author, int price, String type) {//这里没构造isBorrowed是因为它的默认值是false,意味着刚开始书都是未被借出的
        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;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ", isBorrowed=" + isBorrowed +
                '}';
    }
}
package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-17 - 11 - 17 - 23:55
 * @Description: com.bookmanagement.book
 * @version: 1.0
 */
public class BookList {//书架类
    public static final int DEFAULT_SIZE = 10;
    private Book[] books = new Book[DEFAULT_SIZE];
    private int usedSize;//当前books数组当中的数量
    
    public int getUsedSize() {
        return usedSize;
    }
    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:37
 * @Description: operate
 * @version: 1.0
 */
public interface Ioperation {//图书的操作接口
    void work(BookList bookList);//操作书架类中的书数组
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:48
 * @Description: operate
 * @version: 1.0
 */
public class AddOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("新增图书!");
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:53
 * @Description: operate
 * @version: 1.0
 */
public class BrrowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅图书!");
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:50
 * @Description: operate
 * @version: 1.0
 */
public class DeleteOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("删除图书!");
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ExitOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统!");
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:49
 * @Description: operate
 * @version: 1.0
 */
public class FindOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("查找图书!");
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:52
 * @Description: operate
 * @version: 1.0
 */
public class ReturnOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("归还图书!");
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ShowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("显示图书!");
    }
}
package user;
import book.BookList;
import operate.Ioperation;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public abstract class User {
    protected String name;
    protected Ioperation[] ioperations;//操作方法的接口数组,存放操作方法的实现类
    public User(String name) {
        this.name = name;
    }
    //因为菜单在这儿不需要具体的实现,所以将菜单定义为抽象方法,自然User也变成了抽象类
    public abstract int menu();
    //通过用户的选择,来实现不同的操作,调用接口数组里面的操作实现类的方法
    public void doWork(int choice, BookList bookList) {
        this.ioperations[choice].work(bookList);//通过接口数组下标得到具体的操作实现类,再调用操作类的方法
    }
}
package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:35
 * @Description: user
 * @version: 1.0
 */
public class NormalUser extends User {
    public NormalUser(String name) {
        super(name);
        /*this.ioperations = new Ioperation[4];
        ioperations[0] = new ExitOperation();
        ioperations[1] = new FindOperation();
        ioperations[2] = new BrrowOperation();
        ioperations[3] = new ReturnOperation();*/
        //动态初始化接口数组的变量  (接口数组存放操作的实现类)
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new BrrowOperation(),
                new ReturnOperation()
        };
    }
    @Override
    public int menu() {
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}
package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public class AdminUser extends User {
    public AdminUser(String name) {
        super(name);
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new ShowOperation()
        };
    }
    @Override
    public int menu() {//因为要根据不同的输入,做不同的操作,所以返回值用int接受
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}
import book.BookList;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 9:53
 * @Description: PACKAGE_NAME
 * @version: 1.0
 */
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 (1 == choice) {
            return new AdminUser(name);
        } else {
            return new NormalUser(name);
        }
    }
    //这是一个main方法,是程序的入口:
    public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();//根据返回的不同用户,调用不同的菜单
        while (true) {
            int choice = user.menu();//接受操作数,根据操作数调用不同的操作方法
            //根据 choice 和 user 来确定调用哪个对象的哪个操作
            user.doWork(choice, bookList);
        }
    }
}

此时的框架已经搭建好了,只需要写具体操作实现类的业务逻辑。

Book类的toString方法修改:

BookList类新增getBook方法: 

ShowOperation类修改:

ExitOperation类修改: 

FindOperation类修改: 

BookList类新增setBook方法:

AddOpration类:

BookLisk类重载setBook方法:

DeleteOperation类:

 

BorrowOperation类: 

 

ReturnOperation类:

最终代码

package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-16 - 11 - 16 - 20:59
 * @Description: book
 * @version: 1.0
 */
public class Book {//书类
    private String name;//书名
    private String author;//作者
    private int price;//价格
    private String type;//类型
    private boolean isBorrowed;//是否被借出
    public Book(String name, String author, int price, String type) {//这里没构造isBorrowed是因为它的默认值是false,意味着刚开始书都是未被借出的
        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;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                //", isBorrowed=" + isBorrowed +
                (isBorrowed == false ? " 未被借出" : " 已被借出") +
                '}';
    }
}
package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-17 - 11 - 17 - 23:55
 * @Description: book
 * @version: 1.0
 */
public class BookList {//书架类
    public static final int DEFAULT_SIZE = 10;
    private Book[] books = new Book[DEFAULT_SIZE];
    private int usedSize;//当前books数组当中的数量
    public BookList() {
        books[0] = new Book("数据结构", "张三", 40, "计算机类");
        books[1] = new Book("计算机组成原理", "李四", 45, "计算机类");
        books[2] = new Book("操作系统", "王五", 50, "计算机类");
        books[3] = new Book("计算机网络", "themyth", 35, "计算机类");
        books[4] = new Book("Java程序设计", "Holis", 25, "计算机类");
        this.usedSize = 5;
    }
    //因为存放Book类的数组是被封装的,所以要提供方法来获取书,通过下标pos得到具体的一本书
    public Book getBook(int pos) {
        return this.books[pos];//返回的是下标为pos的书
    }
    //在书架的最后一本书位置后面接着存放一本书
    public void setBook(Book book) {
        this.books[usedSize] = book;//[0, usedSize - 1]这个区间是原来每本书的下标
    }
    //在书架的指定位置增加一本书
    public void setBook(int pos, Book book) {
        this.books[pos] = book;
    }
    public int getUsedSize() {
        return usedSize;
    }
    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:37
 * @Description: operate
 * @version: 1.0
 */
public interface Ioperation {//图书的操作接口
    void work(BookList bookList);//操作书架类中的书数组
}
package operate;
import book.Book;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
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++) {
            //System.out.println(bookList[i]);bookList只是一个引用,不是数组
            Book book = bookList.getBook(i);//通过下标的变换,得到不同的书
            System.out.println(book);//因为这里重写了toString,可以直接打印书的详细信息
        }
    }
}
package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ExitOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统!");
        System.exit(0);//退出JVM
    }
}
package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:49
 * @Description: operate
 * @version: 1.0
 */
public class FindOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("查找图书!");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要查找的书名:");
        String findBookName = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if (findBookName.equals(book.getName())) {
                System.out.println("找到了这本书!");
                System.out.println(book);
                return;
            }
        }
        System.out.println("查无此书!");
    }
}
package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:48
 * @Description: operate
 * @version: 1.0
 */
public class AddOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("新增图书!");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名:");
        String addBookName = 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(addBookName, author, price, type);
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpBook = bookList.getBook(i);
            if (addBookName.equals(tmpBook.getName())) {
                System.out.println("已经有这本书了,不能存入了!");
                return;
            }
        }
        bookList.setBook(book);
        //修改usedSize
        bookList.setUsedSize(currentSize + 1);
    }
}
package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:50
 * @Description: operate
 * @version: 1.0
 */
public class DeleteOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("删除图书!");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要删除的书名:");
        String deleteBookName = scanner.nextLine();
        int index = -1;
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpBook = bookList.getBook(i);
            if (deleteBookName.equals(tmpBook.getName())) {
                index = i;
                break;
            }
        }
        if (index != -1) {
            for (int j = index; j < currentSize - 1; j++) {//j <= currentSize - 2
                //bookList[j] = bookList[j + 1];
                Book book = bookList.getBook(j + 1);
                bookList.setBook(j, book);
            }
            //书本数量减少一本
            bookList.setUsedSize(currentSize - 1);
            //因为删除的是对象,要把最后一个元素置为null
            bookList.setBook(currentSize - 1, null);
            System.out.println("删除成功!");
        } else {
            System.out.println("这本书不存在,无法删除!");
        }
    }
}
package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:53
 * @Description: operate
 * @version: 1.0
 */
public class BrrowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅图书!");
        System.out.println("输入你要借阅的图书:");
        Scanner scanner = new Scanner(System.in);
        String borrowBookName = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpbook = bookList.getBook(i);
            if (borrowBookName.equals(tmpbook.getName()) && !tmpbook.isBorrowed()) {//tmpbook.isBorrowed() == false
                tmpbook.setBorrowed(true);
                System.out.println("借阅成功!");
                return;
            }
            /*if (borrowBookName.equals(bookList.getBook(i).getName()) && !bookList.getBook(i).isBorrowed()) {
                bookList.getBook(i).setBorrowed(true);
                System.out.println("借阅成功!");
            }*/
        }
        System.out.println("没有这本书!");
    }
}
package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:52
 * @Description: operate
 * @version: 1.0
 */
public class ReturnOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("归还图书!");
        System.out.println("输入你要归还的图书:");
        Scanner scanner = new Scanner(System.in);
        String returnBookName = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpbook = bookList.getBook(i);
            if (returnBookName.equals(tmpbook.getName()) && tmpbook.isBorrowed()) {//tmpbook.isBorrowed() == ture
                tmpbook.setBorrowed(false);
                System.out.println("归还成功!");
                return;
            }
        }
    }
}
package user;
import book.BookList;
import operate.Ioperation;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public abstract class User {
    protected String name;
    protected Ioperation[] ioperations;//接口数组存放操作的实现类
    public User(String name) {
        this.name = name;
    }
    //因为菜单在这儿不需要具体的实现,所以将菜单定义为抽象方法,自然User也变成了抽象类
    public abstract int menu();
    //通过用户的选择,来实现不同的操作,调用接口数组里面的操作实现类的方法
    public void doWork(int choice, BookList bookList) {
        this.ioperations[choice].work(bookList);//通过接口数组下标得到具体的操作实现类,再调用操作类的方法
    }
}
package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:35
 * @Description: user
 * @version: 1.0
 */
public class NormalUser extends User {
    public NormalUser(String name) {
        super(name);
        /*this.ioperations = new Ioperation[4];
        ioperations[0] = new ExitOperation();
        ioperations[1] = new FindOperation();
        ioperations[2] = new BrrowOperation();
        ioperations[3] = new ReturnOperation();*/
        //动态初始化接口数组的变量  (接口数组存放操作的实现类)
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new BrrowOperation(),
                new ReturnOperation()
        };
    }
    @Override
    public int menu() {
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}
package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public class AdminUser extends User {
    public AdminUser(String name) {
        super(name);
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new ShowOperation()
        };
    }
    @Override
    public int menu() {//因为要根据不同的输入,做不同的操作,所以返回值用int接受
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}
import book.BookList;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 9:53
 * @Description: PACKAGE_NAME
 * @version: 1.0
 */
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 (1 == choice) {
            return new AdminUser(name);
        } else {
            return new NormalUser(name);
        }
    }
    //这是一个main方法,是程序的入口:
    public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();//根据返回的不同用户,调用不同的菜单
        while (true) {
            int choice = user.menu();//接受操作数,根据操作数调用不同的操作方法
            //根据 choice 和 user 来确定调用哪个对象的哪个操作
            user.doWork(choice, bookList);
        }
    }
}
  • 11
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TheMythWS

你的鼓励,我的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值