Day05——综合任务1、顺序表

已于 2022-04-09 20:28:43 修改
阅读量532 收藏
点赞数 1
分类专栏： Java 文章标签： java eclipse
于 2022-04-04 23:02:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Z__XY_/article/details/123957894
版权

综合任务1

需求：学生的成绩存放于一个矩阵，其中行表示学生，列表示科目。如：第 0 行表示第 0 个学生的数学、语文、英语成绩。要求：

  1. 进行学生成绩的随机生成, 区间为 [50, 100].
  2. 找出成绩最好、最差的同学。但有挂科的同学不参加评比.

分析：
① 一个成绩矩阵——一个二维数组（行号代表学生编号，列好代表各个科目）；
② 成绩随机生成，需要一个产生随机数的函数；
③ 需要计算所有没有挂科同学的成绩；
④ 从没有挂科的同学中选出成绩最好的、最差的同学。
Java知识补充
变量的作用：保存内存中的数据。
数据类型的分类：

  • 基本数据类型：包括boolean,char,byte,short,int,long,folat,double.基本数据类型的变量保存的是数据的值，可以直接在栈中分配内存。
  • 引用数据类型：包括类引用类型、接口引用类型和数组引用类型。不管何种引用类型的变量，它们引用的都是对象。引用类型的变量，在内存中存储的是对象的存储地址，变量放在栈中，对象实例放在堆中，变量保存的是堆地址。
    内存简化结构
    在这里插入图片描述
    在这里插入图片描述
    注意：将基本类型变量和引用类型变量的值赋给另一个变量的区别，引用类型变量赋值给另一个变量时，是将该变量指向堆中的地址给了新的变量，也就是说，这两个变量会指向同一个内存空间，当改变其中一个属性值时，也就是改变了另一个变量所值的属性值。

用new关键字创建对象

当一个引用类型的变量被声明后，如果没有初始化，那它就不指向任何对象。Java语言用new关键字创建对象，它有以下作用：

  • 为对象分配内存空间，将对象的实例变量自动初始化为其变量类型的默认值。
  • 如果实例变量在声明时被显示初始化，那就把初始化值赋给实例变量。
  • 调用构造方法。
  • 返回对象的引用。

用到的类

java.util.Random：获取随机数
import java.util.Arrays：提供操作数组的方法
代码中：
Random tempRandom = new Random();//创建一个Random类的实例对象，并赋给tempRandom（这是一个引用变量）
tempRandom.nextInt(51);//产生一个[0,51)的随机整数，得到的值再加上50，就能保证取得的随机数是[50,100]的整数。

Arrays.toString()将一维数组转换成字符串；
Arrays.deepToString()将多维数组转换成字符串

package day05;

import java.util.Arrays;
import java.util.Random;

public class Task1 {
	/**
	 * The entrance of the program.
	 * 
	 * @param args
	 */
	public static void main(String args[]) {
		task1();
	}// Of main

	/**
	 * Method unit test.
	 */
	private static void task1() {
		// Step 1. Generate the data with n students and m courses.
		// Set these values by myself.
		int n = 10;
		int m = 3;
		int lowerBound = 50;
		int upperBound = 101;
		int threshold = 65;

		// Here we have to use an object to generate random numbers.
		Random tempRandom = new Random();
		int[][] data = new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				data[i][j] = lowerBound + tempRandom.nextInt(upperBound - lowerBound);
			} // Of j
		} // Of i

		System.out.println("The data is:\r\n" + Arrays.deepToString(data));

		// Step 2. Compute the total score of each student.
		int[] totalScore = new int[n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (data[i][j] < threshold) {
					totalScore[i] = 0;
					break;
				} // Of if
				totalScore[i] += data[i][j];
			} // Of for j
		} // Of for i

		System.out.println("The total scores are:\r\n" + Arrays.toString(totalScore));

		// Step 3. Find the best and worst student.
		// Typical initialization for index: invalid value.
		int tempBestIndex = -1;
		int temWorstIndex = -1;
		// Typical initialization for best and worst values.
		// They must be replaced by valid values.
		int tempBestScore = 0;
		int tempWorstScore = m * upperBound + 1;
		for (int i = 0; i < n; i++) {
			// Do not consider failed students.
			if (totalScore[i] == 0) {
				continue;
			} // Of if
			if (tempBestScore < totalScore[i]) {
				tempBestScore = totalScore[i];
				tempBestIndex = i;
			} // Of if

			// Attention: This if statement cannot be combined with the last one
			if (tempWorstScore > totalScore[i]) {
				tempWorstScore = totalScore[i];
				temWorstIndex = i;
			} // Of if
		} // Of for i

		// Step 4. Output the student number and score.
		if (tempBestIndex == -1) {
			System.out.println("Cannot find the best student. All studens have failed.");
		} else {
			System.out.println("The best student is No." + tempBestIndex + " with scores: "
					+ Arrays.toString(data[tempBestIndex]));
		} // Of if

		if (temWorstIndex == -1) {
			System.out.println("Cannot find the worst student. All studens have succeeded.");
		} else {
			System.out.println("The worst student is No." + temWorstIndex + " with scores: "
					+ Arrays.toString(data[temWorstIndex]));
		} // Of if
	}// Of task1

}// Of class Task1

运行结果：
在这里插入图片描述
总结：如果要是我在平时写代码的时候，我会将Step 2.和Step 3.的代码揉到一块儿写，在计算每个同学的总分的时候并找到最大值和最小值及其索引，这样会少一次遍历，当然这也会降低代码的可读性。。。

顺序表

面向对象编程

面向过程(POP) 与 面向对象(OOP)

  • 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
  • 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
  • 面向过程：根据业务逻辑从上到下写代码。
  • 面向对象编程：将数据与函数捆绑到一起，进行封装，这样能够更快速的开发程序，减少了重复写代码的过程。

类与对象

  • 类是一个模板，模板里面可以包含多个函数，函数里实现一些功能。
  • 对象是根据模板创建的实例，通过实例对象可以执行类中的函数。
  • 类的抽象：具有相同或相似属性和行为的一系列对象的集合都可以抽象出一个类。

类（Class）由3部分组成：

  • 类的名称：类名
  • 类的属性：一组数据
  • 类的方法：允许对数据进行操作的方法（行为）

Java中的类和对象

顺序表（一）

这里的代码中，提到了构造函数、方法覆盖、final修饰符。
构造函数：当new一个类的时候，所调用的函数，这也解释了为什么构造函数为什么要和类名一致。
final修饰符：

  • 用final修饰的类不能被继承，没有子类；
  • 用final修饰的方法不能被子类的方法覆盖；
  • 用final修饰的变量表示常量，只能被赋一次值；
    说白了，用final修饰的东西不能改~

为什么能直接打印tempFirstList呢？因为 toString 这个方法很特殊,本身是在 Object类中定义的，其返回值类型为String类型，返回类名和它的引用地址，当进行String类与其他类进行连接操作时，会自动调用toString()方法，而我们在SequentialList类中覆盖了该方法，所以会返回对象的字符串形式。

package day05;

public class SequentialList {
	/**
	 * The maximal length of the list. It is a constant.
	 * 
	 */
	public static final int MAX_LENGTH = 10;

	/**
	 * The actual length not exceeding MAX_LENGTH. Attention: length is not only the
	 * member variable of Sequential list, but also the member variable of different
	 * classes.
	 */
	int length;

	/**
	 * The data stored in an array.
	 */
	int[] data;

	/**
	 * Construct an empty sequential list.
	 */
	public SequentialList() {
		length = 0;
		data = new int[MAX_LENGTH];
	}// Of the first constructor

	/**
	 * Construct a sequential list using an array.
	 * 
	 * @param paraArray The given array. Its length should not exceed MAX_LENGTH.
	 *                  For simplicity now we do not check it.
	 */
	public SequentialList(int[] paraArray) {
		data = new int[MAX_LENGTH];
		length = paraArray.length;

		// Copy data.
		for (int i = 0; i < paraArray.length; i++) {
			data[i] = paraArray[i];
		} // Of for i
	}// Of the second constructor

	/**
	 * Overrides the method claimed in Object, the superclass of any class.
	 */
	public String toString() {
		String resultString = "";

		if (length == 0) {
			return "empty";
		} // Of if

		for (int i = 0; i < length - 1; i++) {
			resultString += data[i] + ", ";
		} // Of for i

		resultString += data[length - 1];

		return resultString;
	}// Of toString

	/**
	 * Reset to empty.
	 */
	public void reset() {
		length = 0;
	}// Of reset

	public static void main(String args[]) {
		int[] tempArray = { 1, 4, 6, 9 };
		SequentialList tempFirstList = new SequentialList(tempArray);
		System.out.println("Initialized, the list is: " + tempFirstList.toString());
		System.out.println("Again, the list is: " + tempFirstList);

		tempFirstList.reset();
		System.out.println("After reset,the list is: " + tempFirstList);
	}// Of main

}// Of the SequentialList

运行效果：
在这里插入图片描述

顺序表（二）

主要完成了对顺序表的差值、插入、删除操作。
在对顺序表进行操作时，如果有明确的索引值，需要首先对索引值是否合法进行判断。插入操作首先要从后向前，依次将目标位置的元素后移一位，最后再对目标位置赋值；删除操作则是要从前向后，将元素向前移动一位，覆盖目标位置的值。
贴上与顺序表（一）不同代码的部分：

	/**
	 * Find the index of the given value. If it appears in multiple positions,
	 * simply return the first one.
	 * 
	 * @param paraValue The given value.
	 * @return The position. -1 for not found.
	 */
	public int indexOf(int paraValue) {
		int temPosition = -1;

		for (int i = 0; i < length; i++) {
			if (data[i] == paraValue) {
				temPosition = i;
				break;
			} // Of if
		} // Of for i

		return temPosition;
	}// Of indexOf

	/**
	 * Insert a value to position. If the list is already full,do nothing.
	 * 
	 * @param paraPosition The given position.
	 * @param paraValue    The given value.
	 * @return Success or not.
	 */
	public boolean insert(int paraPosition, int paraValue) {
		if (length == MAX_LENGTH) {
			System.out.println("List full.");
			return false;
		} // Of if

		if ((paraPosition < 0) || (paraPosition > length)) {
			System.out.println("The position " + paraPosition + " is out of bounds.");
			return false;
		} // Of if

		// From tail to head. The last one is moved to a new position. Because length <
		// MAX_LENGTH
		for (int i = length; i > paraPosition; i--) {
			data[i] = data[i - 1];
		} // Of for i

		data[paraPosition] = paraValue;
		length++;

		return true;
	}// Of insert

	/**
	 * Delete a value at a position.
	 * 
	 * @param paraPosition The position
	 * @return Success or not.
	 */
	public boolean delete(int paraPosition) {
		if ((paraPosition < 0) || (paraPosition >= length)) {
			System.out.println("The position " + paraPosition + " is out of bounds.");
			return false;
		} // Of if

		// From head to tail.
		for (int i = paraPosition; i < length - 1; i++) {
			data[i] = data[i + 1];
		} // Of for i

		length--;
		return true;
	}// Of delete

	/**
	 * The entrance of the program.
	 * 
	 * @param args Not used now.
	 */
	public static void main(String args[]) {
		int[] tempArray = { 1, 4, 6, 9 };
		SequentialList tempFirstList = new SequentialList(tempArray);
		System.out.println("Initialized, the list is: " + tempFirstList.toString());
		System.out.println("Again, the list is: " + tempFirstList);

		int tempValue = 4;
		int temPosition = tempFirstList.indexOf(tempValue);
		System.out.println("The position of " + tempValue + " is " + temPosition);

		tempValue = 5;
		temPosition = tempFirstList.indexOf(tempValue);
		System.out.println("The position of " + tempValue + " is " + temPosition);

		tempValue = 2;
		temPosition = 5;
		if (tempFirstList.insert(temPosition, tempValue)) {
			System.out.println("After inserting  " + tempValue + " to position  " + temPosition + ", the list is: "
					+ tempFirstList);
		} // Of if

		temPosition = 3;
		if (tempFirstList.delete(temPosition)) {
			System.out.println("After deleting data at " + temPosition + ", the list is: " + tempFirstList);
		} // Of if

		for (int i = 0; i < 8; i++) {
			if (tempFirstList.insert(i, i)) {
				System.out.println("After inserting " + i + " to position " + i + ", the list is: " + tempFirstList);
			} // Of if
		} // Of for i

		tempFirstList.reset();
		System.out.println("After reset,the list is: " + tempFirstList);
	}// Of main

运行效果：
在这里插入图片描述
总结：对顺序表的操作还算是简单，主要是要注意顺序表的索引和长度的关系以及删除和插入操作的小细节。自己下来还需要多补Java关于类与对象这块的知识~

Mysql学习总结（77）——温故Mysql数据库开发核心原则与规范
科技D人生
09-12 4622
一、核心原则 1、尽量不在数据库做运算 俗话说：别让脚趾头想事情，那是脑瓜子的职责。作为数据库开发人员，我们应该让数据库多做她所擅长的事情。尽量不在数据库做运算，复杂运算移到程序端CPU，尽可能简单应用MYSQL。 举例：在mysql中尽量不要使用如：md5()、Order by Rand()等这类运算函数 2、尽量控制单表数据量 大家都知道单表数据量过大后会影响数据查询效率，严重情况下...
【单片机】【学习日志】51单片机学习日志[Day1、2022.1.09]
m0_55251293的博客
01-09 1446
51单片机学习日志 Day1、2022.1.09 一、基本知识 1、单片机介绍： 单片机，英文Micro Controller Unit，简称MCU; 内部集成了CPU、RAM、ROM、定时器、中断系统、通讯接口等一系列电脑的常用硬件功能 单片机的任务：信息采集（依靠传感器）、处理（依靠CPU）和硬件设备（例如电机，LED等）的控制 单片机跟计算机相比，单片机算是一个袖珍版计算机，一个芯片就能构成完整的计算机系统。 在性能上，与计算机相差甚远，但单片机成本低、体积小、结构简单，在生活和工业
6-1 数据结构-顺序表-学生的成绩信息（TODO：SeqList 逆转, gCC ）
2203_75646004的博客
10-28 773
请根据上述描述，完成一个对顺序表 L 中的学生数据元素原地逆序的方法 ReverseSeqList。
用matlab做矩阵变换（理解+实践）；假设随机发给某班所有同学任意数字，生成10*5的矩阵
m0_71146724的博客
05-21 885
问题 （1）班主任来查课，并带走 最后俩排同学谈话，显示剩余同学的矩阵A1。 （2）在A中，使第i行的同学拿到的数字i显示该新矩阵A2。 （3）在A中找到其中任意三行三列的同学，使他们的数字平方，显示新3*3的矩阵A3。 （4）请找到A中编号最大的数，并显示这位同学的位置坐标，再将这个数替换为pi，显示新矩阵。 理解 (1)随机生成10*5的矩阵，rand（10，5），带走后俩排可以理解为取出矩阵 一到八列，一到五行即A1=(1:8,1:5)。 (2)第i行拿到数字i，可理解为第一行全部拿到一；
【Matlab】建立一个10行10列的矩阵，矩阵元素为[1,99]区间内的随机整数，统计该随机矩阵中大于50的元素的个数（命令文件）。
JockLiu的博客
05-20 6025
建立一个10行10列的矩阵，矩阵元素为[1,99]区间内的随机整数，统计该随机矩阵中大于50的元素的个数。 代码如下： r = floor(1 + (99-1).*rand([10 10])) sum=0; for i=1:10 for j=1:10 if r(i,j)>50 sum=sum+1; end ...
[MATLAB]建立一个10行10列的矩阵，矩阵元素为[1,99]区间内的随机整数，统计该矩阵中大于50的元素个数
热门推荐
88_Rising
05-07 1万+
a = rand(10,10) 生成10*10的包含标准均匀分布的随机矩阵，其元素在(0，1)内; a+(b-a)*rand(10,10)相当于取（a，b）内的一个随机数. 之后再向下取整，即floor()。如floor(3.2)=floor(3.9)=3, a=floor(1+98*rand(10,10)); sum=0; for i=1:10 for j=1:10 if...
【Matlab实验】 创建矩阵
阿歇的专栏
03-16 4058
http://bbs.seu.edu.cn/pc/pccon.php?id=950&nid=15236 用MATLAB函数创建矩阵 1.空阵 [ ] — 空阵，MATLAB允许输入空阵，当一项操作无结果时，返回空阵。 2.等间距线性向量 linspace — 线性等分函数生成向量，可以在首尾两端元素之间，等分建立向量，其中: linspace（n1,n2）包括n1,n2元素，生
Java面向对象程序设计——期末综合复习（第1章~第6章）
朝闻道
12-25 1060
Java面向对象程序设计——期末综合复习
C语言——实验课大作业(十个C语言实验)
2303_80517143的博客
07-16 2425
第一轮，逐个比较 (R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……第二轮，逐个比较 (R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-2], R[N-1])，次大的元素被移动到R[n-1]上。约瑟夫环问题的具体描述是：设有编号为1,2,3,..,n的n个(n>0)个人围成一个圈，从第1个人开始报数，报到m时停止报数，报m的人出圈，才从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……2.判断语句或者省略；
大模型GUI系列论文阅读 DAY1：《基于大型语言模型的图形用户界面智能体：综述》（6.6W 字长文）
feifeikon的博客
01-19 1675
大型语言模型（LargeLanguageModels,LLMs）的兴起[8][9]，特别是那些增强了多模态能力的模型[10]，为GUI自动化带来了颠覆性变化，重新定义了智能体与图形用户界面交互的方式。我们将回顾GUI智能体的发展历史，提供构建这些智能体的分步指南，汇总基本和高级技术，评审与框架、数据和模型相关的重要工具和研究，展示典型应用，并概述未来发展方向。通过这些问题，本综述旨在提供对该领域现状的全面概览，为构建LLM驱动的GUI智能体提供指导，识别关键研究空白，并提出未来工作的方向。
数据结构之顺序表实现学生信息管理（C语言版）
m0_63932570的博客
04-16 7538
今天博主呢来分享一下前周的数据结构作业，是一道用顺序表来实现学生信息管理的作业。大家不要小看这道题，博主在做的时候也是频繁踩坑（也许是博主菜呢，hhh）。今天分享出来主要就是给需要的同学或路过的同学看看。 下面是解题代码（纯手打）： ...
学生信息管理系统
weixin_43404836的博客
01-02 947
学生信息管理系统 一个期末作业，做的比较急，只有基本功能。 一、综合设计要求 为了熟练使用C++面对对象的相关知识，设计一个功能较为完善的学生信息管理系统。需要涵盖如下设计要点： 1、 设计语言：C++； 2、 设计平台为：Win32控制台应用程序或MFC对话框应用程序； 3、 开发平台：VC6.0 或 VS2010及各种版本，Ubuntu下的各种IDE设计环境，等等。 4、 程序结构：多文件结构...
数据结构 顺序表的应用——学生信息统计
Calm微笑
09-18 1万+
实验目的 ： 1 、掌握线性表的定义； 2 、掌握线性表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的的 顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置
数据结构 实验一 顺序表的操作
TXYGoodluck的博客
07-05 8343
一、顺序表的操作 任务：初始化一个顺序表并输出。 相关知识： 需要掌握： 1.结构体变量初始化 2.如何遍历顺序表。 结构体变量初始化： 定义结构体变量的同时，给结构体变量的各个成员变量赋值。 示例如下： sequenlist sq={{1,3,6,7},3}; {1,3,6,7}是给结构体中的数组赋值， 3.给成员变量 last 赋值 遍历顺序表： 给定一个顺序表L,从0~L->last,依次输出，就可以遍历完顺序表中的所有元素。 其中L是指向顺序表的指针。 示例如下： void listprint
数据结构PTA学生顺序表的建立
y0406的博客
10-14 3310
PTA学生顺序表的建立 完成对一个顺序表的建立，表中的每个元素是同学们的学号、姓名和三门课程的成绩，输入5个同学的信息，然后显示在屏幕上。（要求利用顺序表的基本操作） 输入格式: 首先收入学生人数5，然后依次输入5个学生的学号、姓名和三门课的成绩 输出格式: 输入5个学生的学号、姓名和三门课的成绩 输入样例: 5 01 张三 89 89 89 02 李四 90 90 90 03 王五 89 89 89 04 钱六 97 97 97 05 赵倩 90 90 90 输出样例: 1 张三 89.0 89.0 89
多租户 SaaS 系统中的租户隔离与连接池重建机制设计方案
nbsaas-boot基于Request-Response的企业级快速开发框架
04-22 1158
租户隔离 + 动态连接池管理 = SaaS 系统的核心能力。支持连接配置热更新（更改连接地址、密码后自动重建）租户数量大（上百/上千），无法全量预加载连接池。连接池不能长期缓存冷租户，需有缓存淘汰策略。支持租户动态接入（注册后立即生效）判断连接池上次使用时间（可封装。或自定义 Watcher 实现。不支持运行时动态切换或新增。，保证数据安全与性能隔离。在拦截器或网关处设置。每 30 分钟遍历缓存。超过1小时未访问 →。可结合 Spring。
Java 中对象的重载和方法的构造入门知识点总结
2402_84764726的博客
04-23 535
方法重载是指在同一个类中，可以有多个方法具有相同的名称，但参数列表不同。参数列表的不同可以体现在参数的类型、个数或顺序上。方法的返回类型和访问修饰符不影响方法重载。构造方法是一种特殊的方法，用于创建对象并初始化对象的属性。构造方法的名称必须与类名相同，并且没有返回类型（包括void方法重载和构造方法是 Java 面向对象编程中非常重要的概念。方法重载通过相同的方法名处理不同的参数，提高了代码的可读性和灵活性；构造方法用于创建对象并初始化对象的属性，构造方法的重载可以根据不同的需求提供多种对象初始化方式。
MySQL索引优化、SQL分析与运行原理 - Java架构师面试实战
最新发布
南客先生的博客
04-25 341
面试官：马架构，请问您对MySQL的B+树索引有什么理解？马架构：B+树是一种平衡多路查找树，所有的数据节点都存储在叶子节点上。相比于B树，B+树更适合范围查询和排序操作。面试官：那么覆盖索引是什么？马架构：覆盖索引是指查询的数据可以通过索引直接获取，而无需回表读取数据。面试官：如何选择合适的索引？马架构：需要根据查询条件、数据分布和查询频率进行综合评估。面试官：请解释SQL执行计划中的`EXPLAIN`关键字的作用。马架构：`EXPLAIN`可以帮助我们分析SQL的执行过程，包括使用的索引、扫描行数等信息
【分布式系统中的“瑞士军刀”_ Zookeeper】一、Zookeeper 快速入门和核心概念
qq_58611691的博客
04-25 1053
读完本篇文章相信已经了解了在 CentOS 7 系统中安装和配置 Zookeeper 的方法，以及 Zookeeper 的核心概念，包括 ZNode 节点、Session 会话、Watcher 监听器和 Leader - Follower 模式。同时，还通过实际的命令操作和代码示例，对这些概念有了更直观的认识。Zookeeper 作为分布式协调的重要工具，其功能远不止于此，后续还可以深入学习其在分布式锁、配置管理、服务注册与发现等方面的应用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值