【Java开发语言 02】第二章 Java的基本语法（关键字+标识符+变量+String+运算符+十进制与二进制的转换+程序流程控制if-else,switch,while,for+数组+多维数组）

已于 2023-05-29 21:25:10 修改
阅读量747 收藏 1
点赞数 1
分类专栏： Java语法 文章标签： java 开发语言 后端
于 2022-02-07 14:33:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24990383/article/details/121665524
版权

第二章 Java的基本语法

1 关键字

  • 关键字的定义和特点
    • 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
    • 特点：关键字中所有字母都为小写
      用于定义数据类型的关键字
用于定义数据类型的关键字
classinterfaceenumbyteshort
intlongfloatdoublechar
boolenvoid
用于定义数据类型值的关键字
truefalsenull
用于定义流程控制的关键字
ifelseswitchcasedefault
whiledoforbreakcontinue
return
  • Java保留字:现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字
    byValue、cast、future、gengeic、inner、operator、outer、rest、var、goto、const

文本编辑器

在这里插入图片描述
在这里插入图片描述

有颜色和排版区分，查看代码很有用。
可批量修改

  • 竖行修改，按住Alt选中竖行后修改

2 标识符

  • 标识符：
    • Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符
    • 凡是自己可以起名字的地方都叫标识符
  • 定义合法标识符规则：
    • 由26个英文字母大小写，0-9，_或$组成
    • 数字不可以开头
    • 不可以使用关键字和保留字，但能包含关键字和保留字。
    • Java中严格区分大小写，长度无限制。
    • 标识符不能包含空格。
  • 注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

  • Java中的名称命名规范

  • Java中的名称命名规范：
    • 包名：多单词组成时所有字母都小写：xxxxyyyzzz
    • 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
    • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz （驼峰命名法）
    • 常量名：所有字母都大写。多单词时每个单词用下划线连接XXX_YYY_ZZZ

3 变量

java中变量的定制：数据类型 变量名 =变量的值，例如：Int i = 11赋值给变量i

  • 变量的概念：
    • 内存中的一个存储区域
    • 该区域有自己的名称（变量名）和类型（数据类型）
    • Java中每个变量必须先声明，后使用
    • 该区域的数据可以在同一类型范围内不断变化
  • 使用变量注意：
    • 变量的作用域：一对{}之间有效
    • 初始化值
  • 定义变量的格式：数据类型 变量名 = 初始化值
  • 变量是通过使用变量名来访问这块区域的
    变量的类型：声明的变量的数据类型就是变量的类型

3.1基本数据类型

  • 对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
    在这里插入图片描述
    在Java中，数据类型分为基本数据类型和引用数据类型，其中基本数据类型有8种，除了这8种之外其他所有的数据类型都是引用数据类型

整数类型：byte、short、int、long

  • Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
  • java的整形常量默认为int型，声明long型常量须后加‘I’或‘L’
类型占用存储空间表数范围
byte1字节= 8bit-128~127
short2字节-215 ~215 -1
int4字节-231~231-1
long8字节-263~263-1
byte b = 126
int i = 1
short s = 1
long l = 3l,这个long类型变量赋值的时候要在值的后面跟上一个字母l

bit是什么单位？
0100110，这个就是7bit

浮点类型：float、double

  • 与整数类型类似，Java浮点类型也有固定的表数范围和字段长度，不受具体OS的影响
  • Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’
  • 浮点型常量有两种表示形式：
    • 十进制数形式：如： 5.12 512.0f .512
    • 科学计数法形式：如： 5.12e2 512E2 100E-2
类型占用存储空间表数范围精度
单精度4字节-2128~21287位有效数字
双精度double8字节-21024~2102416位有效数字
double d = 1.22
float f = 1.22f,float类型变量赋值时，值后面跟上字符f

字符类型：char

  • char 型数据用来表示通常意义上“字符”（2字节）
  • 字符型常量的表现形式：
    • 字符常量是用单引号（‘’）括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
    • Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’;// '\n’表示换行符
  • char类型是可以进行运算的。因为它都对应有Unicode码。
转义字符说明
\b退格符
\n换行符
\r回车符
\t制表符
"双引号
’单引号
|反斜线

布尔类型 boolean

  • boolean类型适用于逻辑运算，一般用于程序流程控制:
    • if 条件控制语句
    • while循环控制语句
    • do-while循环控制语句
    • for循环控制语句
  • boolen类型数据只允许取值true和false，无Null
    • 不可以0或非0的整数替代false和true，这点和C语言不同
boolean b1 = true
boolean b2 = false

练习1
在这里插入图片描述

3.2 引用类型：String类（堆，栈，方法区，静态）

  • 值null可以赋值给任何引用类型(类、接口、数组)的变量，用以表示这个引用类型变量中保存的地址为空
  • String类属于引用类型，可用null赋值
  • String类是一个典型的不可变类，String对象创建出来就不可能被改变。创建出的字符串将存放在数据区，保证每个字符串常量只有一个，不会产生多个副本。

字符串就是由0到多个字母数字符号共同组成一个串，这个串要用英文的双引号括起来
引用类型，都可以用null作为值，也就是说可以在初始化的时候赋值为null

String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "ll" + "o";
System.out.println(str);

例如：int i = 0;int i1 = 0;会在内存中存储两个0的值
String s0 ="hello";String s1 = "hello";在内存中是不会存在两个hello的字符串，只存在一个
假设“hello”内存地址xxxxx，声明s0变量时给s0赋值实际上让s0变量引用“hello”的内存地址xxxxx。当我们再声明变量s1也赋值“hello”的时候实际上也是直接把已经存在的“hello”的内存地址给s1引用

在这里插入图片描述
String s3 ="he"+"llo";多级拼接

3.3 集成开发环境

之前写代码都是，创建一个java文件，用文本编辑器打开，写代码，打开dos界面，javac编译，java运行，过于麻烦。
集成开发环境就是为了解决所说的问题，里面包含文本编辑工作，自动编译，简化运行，随时进行代码的调试
比较流行的 eclipse 、IDEA、NetBeans
注意：安装的软件和jdk位数要保持一致，必须都是32位或64位
这里使用idea
https://blog.csdn.net/qq_24990383/article/details/121674868查看3 idea入门

练习2: 变量可以赋值给变量
在这里插入图片描述

3.4基本数据类型转换

  • 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：（从左到右，由小到大）
    在这里插入图片描述
  • 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。数字类型的从小到大分别是byte、short、int、long、float、double。
  • 数字类型的运算中，多个相同类型变量参与的运算，变量要先转换为相对应的数据类型的默认类型（比如两个byte类型的变量相加，会先把两个byte类型的变量转换成默认的int类型之后再计算，得到的结果是int 类型）。这种情况适用于变量的数据类型的容量比默认类型的容量小，（比如byte,short都比int小）
  • byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型

数据容量大的不可赋值给小的，可能会有损失（如图的这种异常是编译异常，只有在javac的时候可以发现（因为无语法错误））
在这里插入图片描述
byte,short,char计算时转换为int类型，再赋值给byte类型可能会有损失
在这里插入图片描述
char类型的数据在与数字进行数学运算的时候，是转换为相对应的ASCII码值然后再进行的计算
在这里插入图片描述

  • 当把任何基本类型的值和字符串值进行连接运算时（+），基本数据类型的值将自动转化为字符串类型。（当有一系列的+的运算，如果其中某个部分含有字符串，那么这个字符串前边挨着的+开始就是按照字符串拼接去看）

在这里插入图片描述

练习3
判断对错
String str1 = 4;
String str2 = 3.5f+“”;
判断输出
System.out.println(str2);
System.out.println(3+4+“Hello!”);
System.out.println(“Hello!”+3+4);
System.out.println(‘a’+1+“Hello!”);
System.out.println(“Hello!”+‘a’+1);

错误，String类型需带双引号括起字符
正确，有连接运算，3.5f被转化为字符串类型，结果为字符串 3.5
3.5
34Hello!错，正确为7Hello! 解析加法从前往后，3+4为加号
Hello!34 ，解析最开始为字符串，则为连接符加3形成一个新的字符串再去连接
a1Hello!错，正确为98Hello！ 同理为加号，‘a’的ASCII码值为97
Hello!a1
在这里插入图片描述

练习4
判断能否通过编译
1）short s = 5;
s = s - 2;
2) byte b = 3;
b = b + 4;
b = (byte)(b+4);
3)char c = ‘a’;
int i = 5;
double d = .314;
double result = c+i+d;
4)byte b = 5;
short s = 3;
short t = s+b;
错错对对错

3.5 强制类型转换

  • 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制类型转换符(),但可能造成精度降低或溢出，格外要注意。
  • 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

如：String a = “43”;int i = Integer.parselnt(a);
boolean类型不可以转换为其它的数据类型。

强转
在这里插入图片描述

4 运算符

4.1算术运算符

运算符运算范例结果
  • | 正号|+3|3
  • | 负号|b=4;-b|-4
  • | 加|5+5|10
  • |减|6-4|2
    |乘|34|12
    /|除|5/5|1(结果舍弃小数)|
    %|取模|7%5|2|
    ++|自增（前），先运算后取值|a = 2;b = ++a;|a = 3;b =3|
    ||自增（后），先取值后运算|a = 2; b = a++;|a = 3;b = 2
  • -|自减（前），先运算后取值|a = 2; b = --a|a = 1;b = 1|
    ||自减（后），先取值后运算|a = 2;b = a–;|a = 1;b=2|
    +|字符串连接|“He”+“llo”|“Hello”|

算术运算符的注意问题

  • 如果对负数取模，可以把模数负号忽略不计，如： 5%-2 = 1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
  • 对于除号/，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
    例如： int x = 3510;x = x/1000*1000;x的结果是？3000
  • "+"除字符串相加功能外，还能把非字符串转换成字符串，例如：
    System.out.println(“5+5=”+5+5);//打印结果是？5+5=55
  • 以下二者的区别：
    System.out.println(‘*’+‘\t’+‘* ’ );//数字
    System.out.pintln(“*”+’\t’+‘*’);//字符
    在这里插入图片描述

练习5：算数运算符：自增，自减
public class TestSign{
public static void main(String[] args){
int i1 =10,i2=20;
int i = i1++;
System.out.println(“i=”+i);
System.out.println(“i1=”+i1);
i = ++i1;
System.out.println(“i=”+i);
System.out.println(“i1=”+i1);
i = i2–;
System.out.println(“i=”+i);
System.out.println(“i2=”+i2);
i = --i2;
System.out.println(“i=”+i);
System.out.println(“i2=”+i2);
}
}

i = 10
i1 = 11

i = 12
i1 = 12

i = 20
i2 = 19

i= 18
i2 =18;

4.2 赋值运算符

  • 符号：
    • 当“=”两侧数据类型不一致时，可以使用自用类型转换或使用强制类型转换原则进行处理。
    • 支持连续赋值
  • 扩展赋值运算符： +=、-=、*=、/=、%=
  • 字符串的+=是字符串的拼接

上述实例：
在这里插入图片描述
在这里插入图片描述

思考1：short s = 3;
s = s+2;
s+= 2;
这两句有什么区别
思考2：
int i = 1；
i* = 0.1;
System.out.println(“i”);
i++
System.out.println(“i”);

1.前面提到过short,char,byte在计算时首先转换为int类型
在使用扩展运算符时，变量在参与运算时会把结果强制转换为当前变量的类型
2.
0(相当于 i =(int) (i*0.1))
1

public class Test2{
	public static void main(String[] args)
	{
		int i0 = 1,i1 = 3,i2 = 5;
		i0 = i1 = i2 = 8;                        //等号可以连续赋值
		System.out.print(i0+","+i1 +","+i2);     //输出正常
		System.out.print(i0+','+i1 +','+i2);     //为ascii码值相加，结果是112
		
		short s =2;
		s = s+3;//错误，s+3为int型
		//变量参与运算时候，java程序不知道具体的这个变量在做完运算后会不会查重当前变量的范围，
		//所以会先把变量转换为一个更大长度，这个例子中，short是一个短整形数据，会转化为默认的int类型
		s = (short)(s+3);
		s += 3;//同上，且不用强转
		//在使用扩展运算符时，变量在参与运算时会把结果强制转换为当前变量的类型
}

4.3比较运算符

运算符项目运算范例结果
==相等于4 ==3false
!=不等于4！=3true
<小于4<3false

|大于|4>3|true
<=|小于等于|4<=3|false
=|大于等于|4>=3|true

  • 比较运算符的结果都是boolean型，也就是要么是true，要么是false

4.4 逻辑运算符

&逻辑与（都为真才真） ， | 逻辑或（有一个真为真） ，!逻辑非（取反）
$$短路与，||短路或，^逻辑异或(两个真假性不同为真)

aba&ba\b!aa^ba&&ba\b
truetruetruetruefalsefalsetruetrue
truefalsefalsetruefalsetruefalsetrue
falsetruefalsetruetruetruefalsetrue
falsefalsefalsefalsetruefalsefalsefalse
  • 逻辑运算符用于连接布尔型表达式，在java中不可以写成3<x<6，应该写成x>3 & x<6
  • “&”和“&&”的区别
    • 单&时，左边无论真假，右边都进行运算
    • 双&时，如果左边为真，右边参与运算。如果左边为假，那么右边不参与运算。
  • “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
  • 异或^与或|的不同之处是：当左右都为true时，结果为false

练习6：写出每题的输出结果

int x = 1;
int y = 1;
if (x++ == 2 & ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//2,2

int x = 1, y =1;
if(x++ == 2 && ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//2,1

int x = 1, y =1;
if(x++ == 2 | ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//7,2

int x = 1, y =1;
if(x++ == 2 || ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//7,1

4.5 位运算符

十进制与二进制

  • 十进制，1,2，3,……，9,10逢10 进1
    进制的意思就逢几进1，进到上一位
    10进制计算
    1+8 = 9
    9+1 = 10
  • 二进制，逢2进1
    0+1 = 1
    1+1 = 10
    10+1 = 11
    11+1 = 110
    计算机内部表示数的字节单位是定长的，如8位，16位或32位。位数不够时，高位补0。
    8个二进制代码占的空间就是1bit(位) ，是计算机自己存东西用的最小单位，1Byte(字节）=8bit（位），通常我们说cpu是32（64）位的就是说它每次能处理4（8）个字节，一个英文字母占的空间，一个汉字是占两个字节
  • 负数的二进制
    以15和-15为例子
    15的二进制 00000000 00000000 00000000 00001111
    -15的二进制 11111111 11111111 11111111 11110001
    计算过程：补码（负数的二进制） = 反码+1
    正数二进制->反码->加1->（补码）->负数二进制
    负数二进制->减1->反码->原码->正数二进制
十进制转二进制

  • 正整数
    正整数转成二进制。除二取余，然后余数倒序排列，高位补零。则为该十进制数对应的二进制表示方式。除的过程中到商为0或1时为止。
    如图，规范写法（42）10 = （0010 1010）2
    在这里插入图片描述

  • 负整数
    先将对应的正数转换成二进制，再取原码的反码后加一得到补码，即为该正数对应负数的二进制。
    在这里插入图片描述

  • 正小数
    对小数点之后的数乘2，取结果的整数部分，再取结果的小数小数部分乘以2……以此类推，直到小数部分为0 或位数已满停止。把取出的整数部分依次排列得到小数的二进制。
    在这里插入图片描述

二进制转十进制
  • 正整数
    将二进制补齐位数，首位为0代表是正数，首位为1代表是负数。
    若为正数，按位取2的对应次方后相加即可得到对应十进制。

在这里插入图片描述

  • 负整数
    首位为1代表是负数，则二进制为补码，减一后取反得到原码。原码按正整数的二进制转十进制方式后，带符号即可
    在这里插入图片描述

  • 小数
    将二进制中的四位按位取2的对应次方后相加得到小数的十进制。

在这里插入图片描述

位运算符

注意：无<<<

运算符运算范例
<<左移3<<2 = 12 -> 322 = 12 ，m<<n -> m* 2^n

|右移|3>>1 = 1 -> 3/2 = 1, m>>n->m*2^-n

| 无符号右移 |3>>>1 = 1->3/2 = 1，与正数右移一致
&|与运算|6 & 3 = 2
| |或运算|6|3 = 7
^ |异或运算|6^3 = 5
~| 反码 ~6 = -7

  • 位运算是直接对二进制进行运算
  • 左移时，多出的数字砍掉不要，缺的低位补0
  • 右移时，多出的数字砍掉不要，缺的高位正数（原数字最高位为0）补0，（原数字最高位为1）负数补1
  • 无符号右移，多出的数字砍掉不要，缺的高位直接补0

练习如图
负数右移，负数无符号右移
在这里插入图片描述
正数左移，右移在这里插入图片描述
无符号右移负数在这里插入图片描述
正数左移
在这里插入图片描述
正负数按位取反
在这里插入图片描述

4.6 三目运算符

  • 格式：
    • （条件表达式）？表达式1 ： 表达式2 ；
      条件表达式为true执行表达式1，为false，运算后的结果为表达式2
      == 三目运算符本身作为一条表达式的值为表达式1或2，但是比较运算符表达式本身的结果真假性为boolean类型无法自动转化为int ==在这里插入图片描述

练习，获取两个数中的较大数：
在这里插入图片描述

获取三个数中的较大数：
1.笨蛋方法在这里插入图片描述
2.嵌套三目
在这里插入图片描述

4.7 运算符的优先级

  • 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
  • 只有单目运算度、三元运算符、赋值运算符是从右向左运算的。
  • （）是所有的运算符里优先级最高
优先级运算符结合性
1(),[]从左到右
2！, +（正）, -（负）,~（取反）,++ , --从右到左
3* ,/, %从左向右
4+（加），-（减）从左到右
5<< ， >> ， >>>从左到右
6< ， <=， >， >=从左到右
7== ， !=从左到右
8&（按位与）从左到右
9^（异或）从左到右
10\(竖单杠或)从左到右
11&&从左到右
12\\（双竖杠或）从左到右
13？；从右到左
14=， += ，-=， *= ，/= ，%=， \=(竖斜杠)， ^=， ~=， <<=， >>=， >>>=从右到左

5 程序流程控制

  • 顺序结构
    程序从上到下逐行地执行，中间没有任何判断和跳转。
  • 分支结构
    根据条件，选择性地执行某段代码
    有if……else和switch两种分支语句
  • 循环结构
    根据循环条件，重复性的执行某段代码
    有while、do……while、for三种循环语句
    注：JDK1.5之后提供了foreach循环，方便的遍历集合、数组元素。

5.1顺序结构

Java中定义成员变量时采用合法的前向引用。如：
在这里插入图片描述

5.2 分支结构if-else

if语句三种格式
1.

if(true){
		执行代码块；
}

if(条件表达式){
	执行代码块；
}
else{
	执行代码块；
}

if(条件表达式){
	执行代码块；
}
else if (条件表达式){
	执行代码块；
}
……
else{
	执行代码块；
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

练习：if语句例题1：
判断小明的期末成绩。
当成绩为100分时，奖励一辆BMW
当成绩为（80,99]时，奖励一台iphone5s
当成绩为[60,80]时，奖励一本参考书
其它时，什么奖励都没有。
在这里插入图片描述
练习：对下列代码，若有输出，指出输出结果
if-else可以嵌套使用

int x = 4;
int y = 1;
if(x > 2){
	if(y >2){
			System.out.println(x+y);
			System.out.println("atguigu");
	}
}
else{
System.out.println("x is" + x);
}

x is 4

5.3 分支结构switch

switch(变量){
case 常量1:
	语句1;
	break;
case 常量2:
	语句2;
	break;
……
case 常量N:
	语句N;
	break;
default:
	语句;
	break;

练习：输出星期

	int i = 1;
    switch(i){
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期天");
            break;
            default:
                System.out.println("输出错误");

    }

switch语句有关规矩

  • switch (表达式)中表达式的返回值必须是下述几种类型之一：byte,short,char,int,枚举,String；
  • case子句中的值必须是常量（case后面），且所有case子句中的值应是不同的；
  • default子句是可任选的，当没有匹配的case时，执行default
  • break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
  • break必须写，不然程序就从case匹配到的位置开始一直向下执行到尾

练习1：
使用switch把小写类型的char型转为大写。只转换a,b,c,d,e.其它的输出“other”

 char i = 'a';
        switch(i) {
            case 'a':
                System.out.println('A');
                break;
            case 'b':
                System.out.println('B');
                break;
            case 'c':
                System.out.println('C');
                break;
            case 'd':
                System.out.println('D');
                break;
            case 'e':
                System.out.println('E');
                break;
            default:
                System.out.println("other");
                break;
        }

练习2：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

 int score = 75;
    switch(score>=60? 0 : 1){
        case 1:
            System.out.println("不合格");
            break;
        case 0:
            System.out.println("合格");
            break;
        default:
            System.out.println("输出错误");
            break;

    }

练习3：根据用于指定月份，打印该月份所属的季节。3，4，5春季6,7，8夏季9,10,11秋季，12,1，2冬季

 int month = 1;
    switch(month){
        case 3:
        case 4:
        case 5:
            System.out.println("春季");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏季");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋季");
            break;
        case 12:
        case 1:
        case 2:
            System.out.println("冬季");
            break;
        default:
            System.out.println("输入错误");
            break;

    }

switch和if语句的对比

if和switch语句很像，具体什么场景下，应用哪个语句呢？
主要是使用if

  • 如果判断的具体数值不多，而且符合byte、short、int、char这四种类型。虽然l两个语句都可以使用，建议使用switch语句。因为效率稍高。
  • 其他情况;对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

5.4 循环结构for

  • 循环语句功能
    • 在某些条件满足的情况下，反复执行特定代码的功能
  • 循环语句的四个组成部分
    • 初始化部分（init statement)
    • 循环条件部分(test_exp)
    • 循环体部分(body_statement)
    • 迭代部分(alter_statement)
  • 循环语句部分
    • for循环
    • while循环
    • do/while循环
  • 语法格式
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

练习:输出五次hello,world

//连续输出5次hello,world
        for(int i = 0 ;i<5;i++){//初始化表达式；布尔值测试表达式；更改表达式
            System.out.println(i);
            System.out.println("Hello,world");
        }
        //初始化变量，咱们这里的变量是i，判断i<5.如果是，执行代码{},执行更改表达式i++给i重新赋值，值就变为1
        //判断变量i<5，i为1，执行代码块{}，执行更改表达式i++给i重新赋值，变为2
        //判断变量i<5，i为2，执行代码块{}，执行更改表达式i++给i重新赋值，变为3
        //……
        //判断i<5,当前的i是5，判断结果是false，不再往下执行，结束循环

练习：编写程序FooBaz.java，从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出"foo",在每个5的倍数行上打印"biz",在每个7的倍数行上打印输出"baz"。
//重点问题在换行

//写法1
int a = 1;
        for(a = 1;a<=150;a++){
            System.out.print("\n"+a);
            if(a%3 == 0){
                System.out.print("    foo");
            }
            if(a%5 == 0){
                System.out.print("   biz");
            }
            if(a%7 == 0){
                System.out.print("   baz");
            }
        }

//写法2,用String类拼接
int a = 1;
        for(a = 1;a<=150;a++){
            String str = "";
            str += i;
            if(a%3 == 0){
                str += foo;
            }
            if(a%5 == 0){
                str += biz;
            }
            if(a%7 == 0){
                str += baz;
            }
            System.out.println(str);
        }

练习：打印1~100之间所有奇数的和

 int count = 0;
        for(int i = 1;i<=100;i++){
            if(i%2 != 0){
                count += i;
            }
        }
        System.out.println(count);
        //2500

练习：打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）

 int count = 0;
        int pre = 0;
        for(int i = 1;i<=100;i++){
            if(i%7 == 0){
                count += i;
                pre++;
            }
        }
        System.out.println("个数为"+pre+"总和"+count);
        //个数为14总和735

练习：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如：153 = 111 +555+333

int a = 0, b = 0, c = 0;
        for(int i = 100;i<=999;i++){
            //取a百位,b十位，c个位
            a = i/100;//145/100 = 1
            b = (i/10)%10;//或（145-100)/10 =4
            c = i%10;//145-1*100 -4*10 = 5
            if(a*a*a+ b*b*b+c*c*c == i){
                System.out.println(i);
            }
        }
        //153  370  371   407

5.5 循环结构while

  • 语法格式
[初始化语句]
	while(布尔值测试表达式）{
		语句或语句块；
		[更改语句；]
	}
  • 应用举例
public class WhileLoop{
	public static void main(String[] args){
		int result = 0;
		int i = 1;
		while(i<=100){
			result += 1;
			i++;
		}
			System.out.println("result = "+result);
	}
}

do -while
在这里插入图片描述

练习1：求1到100之间所有偶数的和。用for和while语句分别完成。

//1到100之间偶数的和
		//for写法
		int i = 0,s = 0;
        for(i = 1;i<=100;i++){
            if(i%2 == 0){
                s += i;
            }
        }
        System.out.println(s);
        //要在for循环之外输出最后的结果，因为只有全部循环计数完毕才有1到100之间所有偶数的和
        
        //while写法
        int i = 1,s = 0;
        while(i<=100){
            if(i%2 == 0){
                s+=i;
            }
            i++;
        }
        System.out.println(s);
        
        //do-while写法
        i = 1;s = 0;
        do{
            if(i%2 == 0){
                s += i;
            }
            i++;
        }while(i<=100);
        System.out.println(s);
//2550

补充：无限循环

for(;;){
}
while(true){
}

5.7 嵌套循环

在这里插入图片描述
注意：在写嵌套循环的时候，尽量保证外层循环的循环次数小于内层的循环次数
原因:

//大小循环
        for(int i = 0;i<4;i++){
            System.out.println("大循环---"+i);
            for(int  j = 0;j<2;j++){
                System.out.println("大循环---"+i+"下的小循环---"+j);
            }
        }

在这里插入图片描述

练习1）九九乘法表

//九九乘法表
        for(int i = 1 ;i<10;i++){
            for(int j = 1; j <= i;j++){
                System.out.print(""+j +'*'+ i +'='+ j * i+"  ");

            }
            System.out.println("\n");
        }

在这里插入图片描述

2）1-100之间所有的质数

//1-100所有质数
        for(int i =1;i<=100;i++) {
            //用i除所有比它小的数字，如果能整除说明不是质数
            int k = 0;//计数，判断被整除了几次
            for (int j = 1; j <= i; j++) {//如果做j<i，k==1的判断，会遗失数字1，因为1<1会跳出
                if (i % j == 0) {
                    k++;
                }
            }
            if (k ==  2) {
                //说明j==i-1时也没有整除成功
                System.out.println(i);
            }
        }
//质数break的写法
        for(int i = 1;i<=100;i++){
            int j = 0;
            for( j = 1 ; j<i;j++ ){
                if (i%j == 0 && j!= 1){ //注意，此处排除除以数字1的情况
                    //说明不是质数
                    break;
                }
            }
            if(i == j){
                System.out.println(i);
            }
        }

5.7 特殊流程控制语句

break语句

  • break语句用于终止某个语句块的执行
{ ……
break;
……
}

前面学到switch中有break用来结束case

如下图，break用来中止循环
在这里插入图片描述
break在嵌套循环中，只跳出内层循环。终止当前所在的循环
在这里插入图片描述

  • continue语句用于跳过某个循环语句块的一次执行，进入下一次循环
    在这里插入图片描述

下图对比break和continue
break是终止本层（本层有很多次）循环，continue是终止本次循环
在这里插入图片描述
在这里插入图片描述

  • return 结束当前方法
    在这里插入图片描述
    在单层循环里使用break和return看起来效果相同，实际一个是结束所在循环，一个是结束所在方法。

在这里插入图片描述

  • 特殊流程控制语句说明

在这里插入图片描述

6 数组

想把多个数据放到一个变量？使用数组，就存放多个数据的集合

6.1 一维数组的声明

在这里插入图片描述

6.2一维数组的初始化

一维数组可以互相直接赋值
在这里插入图片描述

int[] i1 = new int[4];//声明一个能放4个int类型数据的数组
        int[] i2 = new int[]{1,2,3};
        int[] i3 = {5,6,7};
        String[] strs = new String[]{"12","d","67"};
        //数组内的元素都有i个引用的元素下标，这个的下标是个数字，数字是
        System.out.println(strs[1]);
        System.out.println("str数组的长度为"+i3.length);
        
 strs[2] = "0v0";

数组元素的默认初始化

使用动态初始化的时候，数组的元素会有默认值，数字类型的默认值是0，对象的默认类型是null
在这里插入图片描述

6.3 数组元素的引用

在这里插入图片描述

6.4 多维数组

一维数组中的每一个元素都是一个数组，这样的数组就是二维数组
在这里插入图片描述

   int[][] ii = new int[][]{
                {1,2},
                {4,2}
        };
        System.out.println(ii[1][0]);//4

        int[][] i5 = new int[2][3];
        //第一维部分的长度是2，第二维也就是第一维的每个元素的长度是三
        //{
        //{1,2,3},
        //{ 5,6,7}
        // };

        int[][] i6 = new int[2][];//只定义第一维的长度，第二维不定义

注意1：数组中，静态初始化是定义与赋值同步完成。动态初始化是先定义再赋值
特殊写法：int[] x,y[];//x为一维数组，y为二维数组
在这里插入图片描述

练习2:获取arr数组中所有元素的和。使用for的嵌套循环即可。
在这里插入图片描述

 //求和
        int[][]arr = new int[][]{
                {3,8,2},
                {2,7},
                {9,0,1,6}
        };
        int len = arr.length;
        int res = 0;
        for(int i = 0;i<len;i++){//一维数组的循环
            int[]arr0 = arr[i];//当前一维数组的该位元素的数组长度
            int llen = arr0.length;//二维数组的长度
            for(int j = 0;j<llen;j++){
                res += arr0[j];
                //System.out.println(arr[i][j]);

                //或者这种写法，同上一行
                // System.out.println(arr0[j]);
            }
        }
        System.out.println(res);//38

//方法2优化，省去中间变量
 //求和
        int[][]arr = new int[][]{
                {3,8,2},
                {2,7},
                {9,0,1,6}
        };
       
        int res = 0;
        for(int i = 0;i<arr.length;i++){//一维数组的循环
           // int[]arr0 = arr[i];//当前一维数组的该位元素的数组长度
           // int llen = arr0.length;//二维数组的长度
            for(int j = 0;j<arr[i].length;j++){
                res += arr0[j];
                //System.out.println(arr[i][j]);

                //或者这种写法，同上一行
                // System.out.println(arr0[j]);
            }
        }
        System.out.println(res);
    }
}

在这里插入图片描述

练习：
在这里插入图片描述

6.5 数组中涉及的常见算法

在这里插入图片描述
1.求一个数组中的最大值，最小值，总和，平均数

int[] i1 = new int[]{3,3,4,6,1,2,11,7,9,6};
        int max = i1[0],min = i1[0];
        for(int i = 0;i<i1.length;i++){
            max = i1[i]>max ? i1[i]:max;
        }
        System.out.println("最大值为"+max);

        for(int i = 0;i<i1.length;i++){
            min = i1[i]<min ? i1[i]:min;
        }
        System.out.println("最小值为"+min);

        int Sum = 0;
        for(int i = 0;i<i1.length;i++){
            Sum += i1[i];
        }
        System.out.println("总和为"+Sum);

        int Mean = Sum/(i1.length);
        System.out.println("平均数为"+Mean);

2.复制会在内存中产生新的一段空间，而赋值不会，这与之前的string类似

        //1.赋值数组
        int[] i2 = i1;
        //打印赋值数组i2
        System.out.println("打印i2");
        for(int i = 0;i<i2.length;i++){
            System.out.print(i2[i]+" ");
        }
        System.out.println();

        //2.复制数组
        int[] copy = new int[10];//声明了一个和i1同长度的数组
        //依次赋值
        for(int i = 0;i<i1.length;i++){
            copy[i] = i1[i];
            //把i1的每一个元素按顺序拿出来，给copy数组的每一个元素赋值
        }
        //打印复制数组copy
        System.out.println("打印copy");
        for(int i = 0;i<copy.length;i++){
            System.out.print(copy[i]+" ");
        }
        System.out.println();

		//修改两个数组的内容
        i2[3] = 34;
        copy[4] = 56;
        //打印修改i2,copy后的三个数组
        System.out.println("修改i2[3] = 34,copy[4] = 56."+'\n'+"其中i2为赋值i1的数组，copy为拷贝i1的数组");
        System.out.print("i1: ");
        for(int i = 0;i<i1.length;i++){
            System.out.print(i1[i]+" ");
        }
        System.out.println();
        System.out.print("i2: ");
        for(int i = 0;i<i2.length;i++){
            System.out.print(i2[i]+" ");
        }
        System.out.println();
        System.out.print("copy: ");
        for(int i = 0;i<copy.length;i++){
            System.out.print(copy[i]+ " ");
        }

在这里插入图片描述
2.反转数组
思路：倒序输出原数组，正序赋值给新数组
数组长度-正序=倒序

        int[] arr ={6,4,8,2,4};
        int[] copy =new int[arr.length];

        for(int i = arr.length-1;i>=0;i--){
            copy[copy.length-1-i] = arr[i];

        }
        //打印两个数组
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+ " ");
        }
        System.out.println();
        for(int i = 0;i<copy.length;i++){
            System.out.print(copy[i]+ " ");
        }

3.数组元素的排序（冒泡排序）

		//冒泡排序，每次排好一个数字的位置
        //例如，一个数组7个元素，第一次找出最大的数字放在第7位
        //第二次找出前6个位置里最大的数字放在第6位
        //……以此类推，直到找出前2个位置里最大的数字则排序完成
        int[] arr = {9,5,3,1,6,2,5,6,19};
        int tmp = 0;
        for(int i = arr.length;i>1;i--){//i的取值范围length~2
            //外循环，规定每次排序的长度，由9,8,7，……,2
            for(int j = 1; j<i; j++){//j的取值范围1~i-1
                //内循环，规定长度内，找到最大的元素排到最大号位置
                
                if(arr[j] < arr[j-1]){//1~i-1,0~i-2。依次为1，0；2，1;……8，7
                    //如果数组中的元素后者小于前者，交换元素
                    tmp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = tmp;
                }
            }
        }
        //打印排序后的数组arr
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+"  ");
        }

在这里插入图片描述

6.6 数组排序

6.7 冒泡排序

排序思想：
相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。

例1：例如4个元素的数组
[4,7,3,1]
[4,3,1,7]第一轮得到一个最大的数字，放在倒数第一位
[3,1,4,7]第二轮得到除最后一个数字之外的最大数字，放在倒数第二位
[1,3,4,7]第三轮得到除最后两个数字之外的最大数字，放在倒数第三位
例2：排序例1

int[] arr2 = new int[]{4,7,3,1};
        int pre = 0;
        for(int i = 0;i<arr2.length;i++){ //外层循环是循环轮次，轮次循环的次数是数字长度-1，我理解的是剩一个数的时候无需排序所以-1
            for(int j = 0;j < arr2.length-1-i;j++){//每一轮次的数字对比排序，每轮次的循环一次4,3,2//j的范围是0~2
                if(arr2[j] < arr2[j+1]){//若需要倒序排序，把<改为>
                //正序与倒序排序，其他的都是一致的，在判断两个相邻的元素在声明情况下做交换不一样
                //如果是正序，前面的大于后面，交换
                //如果是倒序，前面的小于后面，交换
                    pre = arr2[j];
                    arr2[j] = arr2[j+1];
                    arr2[j+1] = pre;
                }

            }
        }

6.8 数组操作常见问题

在这里插入图片描述

  • 数组下标越界异常
  • 两个元素的数组，下标范围0~1
    编译不报错，运行报错
  • 空指针异常

6.9 练习

在这里插入图片描述
思考：array1和array2是什么关系？
拓展： 修改题目，实现array2对array1数组的复制

练习代码及运行结果：

int[] array1 = {2,3,5,7,11,13,17,19};
        int[] array2 = new int[array1.length];

		//打印array1
        System.out.println("array1:");
        for(int i = 0;i<array1.length;i++){
            System.out.print(array1[i]+" ");
        }
        System.out.println();

		//赋值array2,修改索引
        array2 = array1;
        for(int i = 0;i<array2.length;i += 2){
            array2[i] = i;
        }

		//打印array2和array1
        System.out.println("array2:");
        for(int i = 0;i<array2.length;i++){
            System.out.print(array2[i]+" ");
        }
        System.out.println();

        System.out.println("array1:");
        for(int i = 0;i<array1.length;i++){
            System.out.print(array1[i]+" ");
        }
        System.out.println();

在这里插入图片描述

思考拓展
array1和array2的关系类似于一块数组空间的两个名字，直接进行数组赋值操作。并不会开辟新的数组空间，而是共用，所以其中一个数组进行修改另一个也会随之改变
在这里插入图片描述
在这里插入图片描述实现array2对array1数组的复制代码

 for(int i = 0;i<array2.length;i++){
            array2[i] = array1[i];
        }

copy上篇“赋值数组的代码”查看修改后结果

在这里插入图片描述

_esther_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java第二章知识点总结
a1239747456的博客
10-02 608
1.标识符：是以字母、下划线“_”、美元符“$”开头，后接字母、下划线、美元符、数字的字符序列。 2.常量：用保留字final来实现。final int num=100; 变量：int count;char c='a'; 将Unicode码转化为本地字符集码的过程叫做编码，而反向过程叫解码。 当程序涉及键盘输入的时候，需要进行解码；当涉及打印、屏幕输出时，往往是编码。 编码与Java中的输出流有关，解码与输入流有关。 3.Java中的算术运算主要依赖于Math类的静态方法，例如： p...
JAVA第二章
qq_45309448的博客
03-23 89
需要显示地声明，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时候就需要强制转换。Java程序必须放到一个类中。类使用clas关键字定义，在class前面还有类的修饰符。A.两种数据类型彼此兼容。B.目标类型的取值范围大于源类型的取值范围。两种数据类型在转换的过程中不需要显性地进行声明，由编译器自动完成。有三种注释分别是单行注释、多行注释、文档注释。
java学习第二章
2301_77740002的博客
07-09 105
基本数据类型分为数值{型又分为整数类型(byte,short,int,long)和浮点类型(float,double)}，字符型(char)，布尔型(boolean)。java语言中对类,方法,变量,包等要素进行命名使用的字符序列称为标识符，就是在编程中我们可以自己命名名称。文档注释 用于对类,类中变量,方法进行注释,在其他地方调用时,可以显功能说明。被java语言赋予特定含义的单词,主要用来修饰包,类,变量,方法(函数)变量名,方法名: 首字母小写,多单词组成时,第二个单词开始首字母大写。
2024年Java最新Java基础教程【第二章：Java数据类型和变量】_java中ps，Java面试问题集合
最新发布
2401_84025301的博客
05-05 871
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。最新整理面试题上述的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题最新整理电子书最新整理大厂面试文档以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
java string 变量_java中String对象和String变量
weixin_42522964的博客
02-12 546
java中String对象和String变量(2011-12-27 20:40:27)标签：最近在论坛上看到关于String s = new String("XYZ") + new String("XYZ");到底创建几个对象的讨论，觉得比较有意思，在此总结一下。在JAVA中除了8种基本类型之外，其他的都是类对象及其引用。所以 "XYZ"在JAVA中是一个String对象，对于String类对象来...
Java第二章总结
wjqksy的博客
03-06 146
Java基础语言 2.1代码注释与编码规范 2.2变量与常量 2.3标识符与关键字 2.4基本数据类型 2.5；运算符 2.1 1 注释 注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。 Java 中的 注释分为三种： 单行注释。单行注释的格式是使用 // ，从 // 开始至本行结尾的文字将作为注释文字。 // 这是单行注释文字 多行注释。多行注释的格式是使用 /* 和 */ 将一段较长的注释括起来。 /* 这是多行注释文字 这是多行注释文字 这是多
java_第二章_语法（1）
10-20
在本章节"java_第二章_语法（1）"中，我们主要探讨了Java编程语言的基础语法要素，这些是每个Java开发者必须掌握的核心概念。以下是对各个知识点的详细阐述： 1. **关键字**：Java的关键字是被Java语言预定义并具有...
JAVA数据类型和运算符
07-23
Java是一种广泛使用的面向对象的编程语言，其语法严谨且具有丰富的特性。在Java中，数据类型和运算符是编程的基础，它们定义了程序中的变量、常量以及它们之间的操作。 一、标识符与关键字 1. 标识符是程序员在编程...
125集专攻JAVA基础 JAVA零基础入门学习视频教程 动力节点JAVA视频教程.txt
09-04
北京动力节点-Java编程零基础教程-038-Java基本语法-十进制到二进制转换.avi 北京动力节点-Java编程零基础教程-039-Java基本语法-二进制到十进制转换.avi 北京动力节点-Java编程零基础教程-040-Java基本语法-八...
Java基础50题2023新版
10-13
本资源摘要信息涵盖了Java基础50题2023新版的知识点，涵盖了基础概念、环境变量配置、命令行编程、进制转换、原码补码反码、数据类型转换、算术运算符、浮点数、位运算符、表达式、读程序题、标识符命令规范、键盘...
JavaSE总结笔记，包含Java核心基础知识
12-20
进制转换在处理二进制、八进制、十进制和十六进制数字时非常有用。 总之，JavaSE的总结涵盖了从环境配置、基本语法到高级特性的广泛知识，这些构成了Java编程的基础。掌握这些要点对于进一步学习Java EE和Java ME，...
java_第二章_语法（2）
11-02
顺序结构，选择结构，循环结构，访问修饰符详解（不写、private、protected、public）、方法、方法的特性-重载、单例模式实现
Java的第二章作业答案
10-11
第二章的所有作业答案，分为理论作业和上机作业
java(第二章)ppt
05-05
Java是一种计算机程序语言，用Java既可以编写嵌入在Web网页中运行的Java Applet小程序，也可以编写独立运行的Java Application。Java是当今十分流行的网络编程语言。
java第二章总结
m0_64535103的博客
03-07 203
2.1代码注释与编码规范 1|编码规范需要程序员写出来的代码不能太复杂，需要让观看代码的读者能够看懂。 2|在编程中，可观性第一，效率第二。 3|应控制空格的数量和语句中的关键字。 2.2 变量与常量 java的整型常量值主要有如下三种形式: 1,十进制数形式 如：-54，67，0。 2,八进制数形式 如: java中的八进制常数的表示以0为开头，如0125表示十进制常数85，-013表示十进制常数-11。 3,十六进制数形式 如：java中的十六进制常数的表示以0x或0..
JAVA 第二章
llllliznc的博客
04-13 328
第二章 主要内容 标识符与关键字 java所有的组成成分都需要有名字，称作标识符，用来表示类名、变量名、方法名 标识符 用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符， 简单地说，标识符就是一个名字 。 Java语言规定 标识符由字母、下划线、美元符号和数字组成，长度不受限制。 标识符的第一个字符不能是数字字符。 标识符不能是关键字 标识符不能是true、false和null 关键字 关键字就是具有特定用途或被赋予特定意义的一些单词，不可以把关键字作为
Java学习笔记 ：第二章：Java程序设计环境
qq_41135146的博客
04-13 91
Java学习笔记 ：第二章：Java程序设计环境 1.安装Java开发工具包 1.Java术语 术语名 缩写 解释 Java Development Kit(Java 开发工具包) JDK 编写Java程序地程序员使用的软件 Java Runtime Environment(Java 运行时环境) JRE 运行Java程序的用户使用的软件 Server JRE(服务器JRE) —— 在服务器上运行Java程序的软件 Standard Edition(标准版) SE 用于桌面或者简
java第二章
StarrySkyZz
09-23 96
第二章 Java语言基础 陈述题 1.Java包含哪两大类数据类型？其中基本类型的每种类型的取值范围和默认值分别是多少？请编程验 证。 数据类型可划分为基本数据类型和引用数据类型 基本数据类型的取值范围和默认值 2.Java在什么情况会发生整型溢出？请举例说明，并给出解决方案。 int型数据的最大值+1时会发生整型溢出 public class TestJava3_4 { public static void main(String args[]) { int x =
大学课程讲义-Java基础-Java基本语法
08-14
本章主要涵盖了Java基础的几个方面，包括关键字、标识符、变量、进制、运算符、流程控制和数组。这些内容都是学习Java编程的基础，掌握好这些知识点对于进一步学习和应用Java语言非常重要。 首先是关键字。关键字是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值