Java学习笔记

已于 2023-03-29 10:09:05 修改
阅读量54 收藏
点赞数
文章标签： java 学习 jvm
于 2023-03-23 10:42:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45929711/article/details/129725979
版权
本文详细介绍了JAVA的学习内容，包括开发环境的配置，JAVA程序的编译与运行过程，JVM、JRE和JDK的区别。此外，还讲解了JAVA编程的基础，如变量、数据类型、运算符以及简单的程序结构，如条件判断和循环控制。
摘要由CSDN通过智能技术生成

JAVA学习笔记第一天：

  1. java开发环境：

    • 编译运行过程：

      • 编译期：.java源文件，经过编译，生成.class字节码文件

      • 运行期：JVM加载.class并运行.class(0和1)

        特点：跨平台、一次编译到处使用

    • 名词：

      • JVM：java虚拟机

        • 加载.class并运行.class

      • JRE：java运行环境

        • 除了包含JVM以外还包含了运行java程序所必须的环境
        • JRE = JVM + java系统类库(小零件)

      • JDK：java开发工具包

        • 除了包含JRE以外还包含了开发java程序所必须的命令工具
        • JDK = JRE + 编译、运行等命令工具

        说明：

        1. 运行java程序的最小环境为JRE
        2. 开发java程序的最小环境为JDK

  2. Idea：

    • JetBrains公司的，分社区版(免费的)和终级版(收费的)

    • 开发步骤：

      • 新建Java项目/工程------------------------小区

      • 新建Java包-----------------------------------楼+单元

      • 新建Java类-----------------------------------房子

        • main中：System.out.println(“hello world”);

          package day01; //声明包day01(楼+单元)
public class HelloWorld { //声明类HelloWorld(房子)
    //主方法，为程序的入口(房子大门口)，程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {
        //输出hello world
        //1)严格区分大小写
        //2)所有符号必须是英文模式的
        //3)每句话必须以分号结尾
        System.out.println("hello world"); //双引号中的原样输出
        System.out.println("你好 世界");
    }
}

    • 注释：解释性文本(计算机不执行)

      • 单行注释：//
      • 多行注释：/* */
      • 文档注释：/** */---------------后期讲

单词：

1)int:整型
2)long:长整型
3)double:浮点型
4)boolean:布尔型
5)char:字符型
6)true:真 
7)false:假
8)unicode：统一码、通用码、万国码
9)age:年龄
10)score:成绩
11)demo:例子
12)var:变量
13)data:数据
14)type:类型
    
内存单位换算:-----------------背下来
  1G=1024M(兆)
  1M=1024KB(千字节)
  1KB=1024B(字节)
  1B=8bit(位)

JAVA学习笔记第二天：

笔记：

  1. 变量：存数的

    • 声明：相当于开个帐户

      int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型的变量，名为b,c,d
//int a; //编译错误，变量不能同名

    • 初始化：相当于给帐户存钱

      int e = 250; //声明整型变量e并赋值为250----开户的同时存钱
int f;   //声明整型变量f-------先开户
f = 250; //给变量f赋值为250----后存钱
f = 360; //修改变量f的值为360

    • 使用：使用的是帐户里面的钱

      • 对变量的使用就是对它所存的那个数的使用

        int g = 5; //声明一个整型变量g并赋值为5
int h = g+10; //取出g的值5，加10后，再赋值给变量h
System.out.println(h);   //输出变量h的值15
System.out.println("h"); //输出h，双引号中的原样输出
g = g+10; //在g本身基础之上增10
System.out.println(g); //输出变量g的值15

      • 变量在使用之前必须声明并初始化

        //System.out.println(i); //编译错误，变量i未声明
int i;
//System.out.println(i); //编译错误，变量i未初始化

    • 命名：相当于帐户的命名规则

      • 只能包含字母、数字、_和$符，不能以数字开头

      • 严格区分大小写

      • 不能使用关键字

      • 允许中文命名，但不建议，建议"英文的见名知意"、“小驼峰命名法”

        int a1,a_5$,_3c,$b_;
//int a*b; //编译错误，不能包含*号等特殊符号
//int 1a; //编译错误，不能以数字开头
int aa = 5;
//System.out.println(aA); //编译错误，严格区分大小写
//int class; //编译错误，不能使用关键字

//int 年龄; //允许，但不建议
//int nianLing; //允许，但不建议
int age; //建议"英文的见名知意"
int score,myScore,myJavaScore; //建议"小驼峰命名法"

  2. 八种基本数据类型：byte、short、int、long、float、double、boolean、char

    • int：整型，4个字节，-21个多亿到21个多亿

      • 整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误

        int a = 25; //25为整数直接量，默认为int类型
//int b = 10000000000; //编译错误，100亿默认为int类型，但超出范围了
//int c = 25.678; //编译错误，整型变量中只能装整数

      • 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)

        System.out.println(5/2);   //2
System.out.println(2/5);   //0
System.out.println(5/2.0); //2.5

      • 运算时，若超出范围则发生溢出(溢出不是错，但需要避免)

        int d = 2147483647; //int的最大值
d = d+1;
System.out.println(d); //-2147483648，发生溢出了

    • long：长整型，8个字节，-900万万亿多到900万万亿多

      • 长整型直接量需在数字后加L或l

        long a = 125L; //125L为长整型直接量
long b = 10000000000L; //100亿L为长整型直接量
//long c = 25.678; //编译错误，长整型变量中只能装整数

      • 运算时若有可能溢出，建议在第1个数字后加L

        long d = 1000000000*2*10L;
System.out.println(d); //200亿
long e = 1000000000*3*10L;
System.out.println(e); //不是300亿
long f = 1000000000L*3*10;
System.out.println(f); //300亿

    • double：浮点型，8个字节，很大很大很大

      • 小数直接量默认为double类型，若想表示float，需在数字后加F或f

        double a = 3.14; //3.14为小数直接量，默认double型
double b = 25.678; //25.678为小数直接量，默认double型
float c = 25.678F; //25.678F为float型直接量

      • double和float型数据在参与运算时，有可能会发生舍入误差，精确场合不能使用

        double e=3.0,f=2.9;
System.out.println(e-f); //0.10000000000000009，有可能发生舍入误差

    • boolean：布尔型，1个字节

      • 只能赋值为true或false

        boolean a = true;  //true为布尔型直接量
boolean b = false; //false为布尔型直接量
//boolean c = 250; //编译错误，布尔型变量中只能存储true或false

    • char：字符型，2个字节

      • 采用Unicode编码格式，一个字符对应一个码，

        表现的形式是字符char，但本质上是码int(0到65535)

        ASCII码：‘a’—97 ‘A’—65 ‘0’—48

      • 字符型直接量需放在单引号中，只能有一个

        char c1 = '女'; //字符女
char c2 = 'f';  //字符f
char c3 = '6';  //字符6
char c4 = '*';  //字符*
//char c5 = 女; //编译错误，字符型直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '10'; //编译错误，只能有一个字符

char c8 = 65; //必须在0到65535之间
System.out.println(c8); //println()输出时会依据变量的类型来展示
                        //若c8为char型，则会以字符的形式展示
                        //若c8为int型，则会以数字的形式展示

      • 特殊符号需要通过\来转义

        char c9 = '\\';
System.out.println(c9); //\

  3. 类型间的转换：

    • 数据类型从小到大依次为：

      byte<short<int<long<float<double
      char<

    • 两种方式：

      • 自动/隐式类型转换：小类型到大类型

      • 强制类型转换：大类型到小类型

        • 语法：(要转换成为的数据类型)变量
        • 注意：强转有可能溢出或丢失精度
        int a = 5;
long b = a; //自动/隐式类型转换
int c = (int)b; //强制类型转换

long d = 5;   //自动类型转换
double e = 5; //自动类型转换

long f = 10000000000L;
int g = (int)f;
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h;
System.out.println(i); //25，强转有可能丢失精度

    • 两点规则：

      • 整数直接量可以直接赋值给byte,short,char，但不能超范围

      • byte,short,char型数据参与运算时，系统会将其一律先转换为int再运算

        byte b1 = 5;
byte b2 = 6;
//byte b3 = b1+b2; //b1+b2时,系统自动将它俩转换为int了,int结果赋给byte,需强转
byte b4 = (byte)(b1+b2);

System.out.println(2+2);     //4
System.out.println(2+'2');   //52，2加上'2'的码50
System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
System.out.println('2'); //2，此处并没有运算
System.out.println((int)'我'); //输出字符'我'的码

  4. 命名法：

    • 小驼峰命名法：第1个单词的首字母小写，其余单词的首字母大写-------变量、方法

      score,myScore,myJavaScore

    • 帕斯卡/大驼峰命名法：每个单词的首字母都大写

      Score,MyScore,MyJavaScore

  5. 内存单位换算:

    1G=1024M(兆)
1M=1024KB(千字节)
1KB=1024B(字节)
1B=8bit(位)

  6. Unicode：统一码、通用码、万国码，是世界级通用的定长(16位)字符集

JAVA学习笔记第三天：

  1. 运算符：

    • 算术：+、-、*、/、%、++、–

      • %:取模/取余，余数为0即为整除

        System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2

      • ++/–:自增1/自减1，可在变量前也可在变量后

        • 单独使用时，在前在后都一样
        • 被使用时，在前在后不一样
          • a++的值为a------------(a–的值为a)
          • ++a的值为a+1--------(–a的值为a-1)
        //演示++单独使用
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//演示++被使用
int a=5,b=5;
int c = a++; //简便记法:a++的值为5，所以c就为5
int d = ++b; //简便记法:++b的值为6，所以d就为6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

//演示--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

//演示--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c为5
int d = --b; //--b的值为4，所以d为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

    • 关系：>、<、>=、<=、==、!=

      1)>(大于)、<(小于)
  >=(大于或等于)、<=(小于或等于)
  ==(等于)、!=(不等于)
2)关系运算的结果为boolean型，
  关系成立则为true，关系不成立则为false

      int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1);   //false
System.out.println(c<b);  //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false

System.out.println(a+c>b);  //false
System.out.println(a%2==0); //false
System.out.println(c++>5); //false----c自增1变为6
System.out.println(c++>5); //true-----c自增1变为7

    • 逻辑：&&、||、!

      • 逻辑运算是建立在关系运算的基础之上的
        逻辑运算的结果也是boolean型

      • &&：短路与(并且)，两边都为真则为真，见false则false

        • 第1个条件为false时，则发生短路(后面的不执行了)
        int a=5,b=10,c=5;
boolean b1 = b>=a && b<c;
System.out.println(b1);          //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true

//演示短路:
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c);  //5，发生短路了

      • ||：短路或(或者)，有真则为真，见true则true

        • 第1个条件为true时，则发生短路(后面的不执行了)
        int a=5,b=10,c=5;
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false

//演示短路:
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c);  //5，发生短路了

      • !：逻辑非(取反)，非真则假，非假则真

        int a=5,b=10,c=5;
boolean b2 = !(a<b);
System.out.println(b2);     //!true=false
System.out.println(!(a>b)); //!false=true

    • 赋值：=、+=、-=、*=、/=、%=

      • 简单赋值运算符：=

      • 扩展赋值运算符：+=,-=,*=,/=,%=

        • 注意:扩展赋值运算符自带强转功能

          int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转，改为s=(short)(s+10);
s += 10; //相当于s=(short)(s+10);

    • 字符串连接：+

      • 若两边为数字，则做加法运算

      • 若两边出现了字符串，则做字符串连接

      • 任何类型与字符串连接，结果都会变为字符串型

        int age = 18;
System.out.println("age="); //age=
System.out.println(age);    //18
System.out.println("age="+age); //age=18
System.out.println("我的年龄是"+age); //我的年龄是18
System.out.println("我今年"+age+"岁了"); //我今年18岁了

String name = "xxx";
System.out.println("name="+name); //name=xxx
System.out.println("大家好，我叫"+name); //大家好，我叫xxx
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫xxx，今年18岁了

System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String

    • 条件/三目：?:

      • 语法：

        • boolean?数1:数2

      • 执行过程：

        • 整个条件运算是有值的，它的值要么是?号后的数1，要么是:号后的数2
        • 计算boolean的值:
          • 若为true，则整个表达式的值为?号后的数1
          • 若为false，则整个表达式的值为:号后的数2
        int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1

int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max); //max=8

  2. 分支结构(上)：基于条件执行的语句

    • if结构：1条路

      1)语法:
   if(boolean){
      语句块--------------基于条件执行的语句
   }
2)执行过程:
    判断boolean的值:
       若为true，则执行语句块(整个结束)
       若为false，则直接结束

      //1)偶数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折:
double price = 600.0; //消费金额   带数(600.0,300.0)
if(price>=500){ //满500
    price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩合法----在0和100之间(包括)
double score = -54;
if(score>=0 && score<=100){ //95,850,-54
    System.out.println("成绩合法");
}
System.out.println("继续执行...");

    • if…else结构：2条路

      1)语法:
   if(boolean){
      语句块1
   }else{
      语句块2
   }
2)执行过程:
    判断boolean的值:
      若为true，则执行语句块1(整个结束)
      若为false，则执行语句块2(整个结束)
3)说明:
    语句块1和语句块2，必走其中之一-------------2选1

      //1)偶数、奇数的判断:
int num = 5;   //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}
System.out.println("继续执行...");

//2)满500打8折，不满500打9折
double price = 300.0;  //带数(600.0,300.0)
if(price>=500){
    price *= 0.8;
}else{
    price *= 0.9;
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩是否合法--0到100(包括)之间表示合法，否则为不合法
double score = 95;
if(score>=0 && score<=100){
    System.out.println("成绩合法");
}else{
    System.out.println("成绩不合法");
}

补充：

  1. 自增/自减：

    int a=5,b=5;
int c = a++; //底层:1)记录a++的值5  2)a自增1变为6  3)将记录的a++的值5赋值给c--了解
//简便记法:a++的值为5，所以c就为5-----重点
int d = ++b; //底层:1)记录++b的值6  2)b自增1变为6  3)将记录的++b的值6赋值给d--了解
//简便记法:++b的值为6，所以d就为6-----重点
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

  2. 任何复杂的程序逻辑都可以通过三种结构来实现：

    • 顺序结构：从上往下逐行执行，每句必走
    • 分支结构：有条件的执行某语句，并非每句必走
    • 循环结构：

  3. 单词学习：

    1)Scanner/scan：扫描仪
2)import:引入、导入
3)System:系统
4)in:进入
5)new:新的
6)nextInt:下一个整数
7)nextDouble:下一个浮点数
8)switch:开关
9)case:案例
10)break:中断、退出
11)command:命令
12)by:通过
13)times:次数
14)while:当...的时候，循环的一种
15)do:做、干
16)math:数字
17)random:随机
18)guess/guessing:猜
19)game:游戏
20)level:等级
21)count:数量
22)score:分数
-尤里乌斯-
关注
java学习笔记1
09-20
Java学习笔记1 Java学习笔记1是学习Java过程中的笔记，主要记录了Eclipse开发环境中的快捷键使用、编辑功能、查找和调试等知识点。 Eclipse快捷键 Eclipse中有许多快捷键，掌握这些快捷键可以大大提高开发效率。...
Java 学习笔记
weixin_42098295的博客
05-13 2026
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7725
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记
少年左岚
01-25 1898
学习java~
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 2014
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
黑马程序员Java学习笔记（源代码+图片+笔记）——集合
weixin_65098078的博客
07-24 1079
黑马程序员Java学习笔记（源代码+图片+笔记）——集合
Java学习笔记一
u013033706的博客
10-23 1536
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1099
Java 学习笔记：面向对象
黑马java学习笔记1(阶段一 第一章1-1~1-4 08)
xiaozhuzhu__的博客
07-09 1210
黑马程序员Java学习路线：Java基础 → JavaWeb → 热门框架 → 苍穹外卖 → 服务框架 → 天机学堂 → 立可得→ 面试专题
Java学习笔记目录索引 (持续更新中)
热门推荐
Guizy
01-15 12万+
Java学习路线目录索引 一、Java基础(省略) Lambda表达式及函数式接口 二、Java数据库 MySQL 一 概念、DDL、DML、DQL、事务、约束等 数据库设计 一 多表关系、三大范式 JDBC 一 基本使用、DAO组件、连接池、JDBCTemplate 三、JavaWeb HTML相关学习 CSS — 常用属性 CSS — 选择器及三大特性 CSS — 网页的布局方式 C...........................
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
Java学习笔记(必看经典).pdf
10-20
Java是一种广泛使用的面向对象编程语言，其核心设计原则之一就是"万物皆对象"。面向对象编程（Object-Oriented Programming, OOP）是相对于面向过程编程的一种编程范式，它强调将数据和操作数据的函数封装在一起，...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 681
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 629
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 471
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 704
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 303
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
JAVA学习笔记：入门篇
"Java学习笔记初步概述" 在Java学习的初期，我们首先会接触到的是Java程序的两种核心运行机制。Java程序的执行依赖于Java虚拟机（JVM），它负责将编译后的字节码文件转化为机器语言，使得Java代码能在不同的操作...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值