while循环、方法(伟大的作品，不是靠力量而是靠坚持才完成的。)

最新推荐文章于 2023-07-10 20:51:49 发布
最新推荐文章于 2023-07-10 20:51:49 发布
阅读量522 收藏 1
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QuanHaiDin/article/details/109082877
版权

一、循环

while语句

1、格式：
初始化语句；
while(布尔表达式){
循环体语句；
初始化变量的自增；
}
2、执行流程
（1）执行初始化语句；
（2）计算布尔表达式的值，结果只有两种，如果为false，循环就不执行了，直接结束
（3）如果为true，执行循环体语句
（4）执行初始化变量的自增
（5）回到第(2)步
3、注意：
（1）条件表达式结果一定是boolean类型
（2）初始化变量的自增，也可以自减;



public class Demo_1 {
	public static void main(String[] args) {
//		while循环
//		初始化语句；
//		while(布尔表达式){
//			循环体语句；
//			初始化变量的自增；
//		}
		int i = 0;//初始化语句；
		while(i < 5) {
			System.out.println(i);
//			初始化变量的自增
//			i++;
			i+=2;
		}
	}
}

死循环

1、死循环：循环能够一直的执行下去，不会停止
2、格式：
两种
（1）for语句的死循环
for( ; ; ){
循环体语句；
}
（2）while语句的死循环（常用）
while(true){
循环体语句；
}
3、死循环的作用
（1）在格式上使用了死循环，将来可以结合跳转语句进行使用，能够结束死循环。
（2）在服务器设计中，希望服务能够永远的给我们服务下去，所以在服务器设计中需要使用死循环。



import java.util.Scanner;

public class Demo_2 {
	public static void main(String[] args) {
//		死循环
//		for语句的死循环
//		for(;;) {
//			System.out.println("for语句的死循环");
//		}
//		System.out.println("hello");注意：死循环中如果没有跳转语句，那么在死循环的后面是无法跟任何代码的
//		while语句的死循环
//		while(true) {
//			System.out.println("while语句的死循环");
//		}
//		死循环的简单使用
		Scanner sc = new Scanner(System.in);
		while (true) {
			System.out.println("请输入一个数据");
			int i = sc.nextInt();
			System.out.println(i);
			if (i == 5) {
				System.out.println("录入正确");
				break;
			} 
		}
	}
}

跳转语句

1、跳转语句：在循环的循环体语句中，结束循环，控制循环使用的语句
2、continue语句：
解释：继续
作用：结束本次循环，继续下次循环
3、break语句：
解释：中断打断
swtich语句中，break；作用：结束switch语句
在循环中的break作用，结束break所在层次的循环。



public class Demo_3 {
	public static void main(String[] args) {
//		continue语句
//		解释：继续
//		作用：结束本次循环，继续下次循环
		for (int i = 1; i <= 5; i++) {
			if (i == 3) {
				continue;
			}
			System.out.println(i);
		}
		System.out.println("----------------break-------------------");
		for (int i = 1; i <= 5; i++) {
			if (i == 3) {
				break;//将break所在循环直接给结束掉了
			}
			System.out.println(i);
		}
	}
}

计算1+2+3+4+5+…+100的和



public class Demo_4 {
//	计算1+2+3+4+5+....+100的和
	public static void main(String[] args) {
//		循环
//		定义一个变量，用来记录每次累加的结果
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
//			累加
//			sum = sum + i;
			sum += i;
//			i = 1 ,sum = 0 + 1; sum = 1
//			i = 2, sum = 0 + 1 + 2; sum = 3
//			i = 3, sum = 0 + 1 + 2 + 3,sum = 6
		}
		System.out.println(sum);
	}
}

列举所有的四叶玫瑰数和个数



public class Demo_5 {
	public static void main(String[] args) {
//		列举所有的四叶玫瑰数和个数
//		定义一个变量用来统计四叶玫瑰树的个数
		int count = 0;
		for (int i = 1000; i <= 9999; i++) {
//			取出i这个数字的各个位上的数字
//			7828
			int ge = i % 10;
//			int shi = i / 10 % 10;
			int shi = i % 100 / 10;
//			int bai = i / 100 % 10;
			int bai = i % 1000 / 100;
			int qian = i / 1000;
//			计算各个位上四次方的和
			int sum = ge * ge * ge * ge + shi * shi * shi * shi + bai * bai * bai * bai + qian * qian * qian * qian;
//			判断各个位上的和，是否和该数字本身相等
			if (i == sum) {
				System.out.println(i);
				count++;
			}
		}
		System.out.println("四叶玫瑰数的个数为:" + count);
	}
}

while循环练习

使用while循环，统计1-100范围内，有多少个数字可以被7整除



public class Demo_6 {
	public static void main(String[] args) {
//		使用while循环，统计1-100范围内，有多少个数字可以被7整除
		int i = 1;
//		统计能被7整数的个数
		int count = 0;
		while (i <= 100) {
//			判断i是否能被7整数
			if (i % 7 == 0) {
				System.out.println(i);
				count++;
			}
//			初始化变量的改变
			i++;
		}
		System.out.println("能被7整除的个数为：" + count);
	}
}

嵌套循环

1、在一次大的循环中，每次的循环内容（循环体语句）又是一个复杂的操作，就需要在大循环中，再去定义一个小循环，称为循环的嵌套（双重循环）
2、格式：
for(初始化语句1;条件判断表达式1;初始化语句改变表达式1){ //外层循环
for(初始化语句2;条件判断表达式2;初始化语句改变表达式2){ //内层循环
循环体语句；
}
}
3、执行流程



public class Demo_7 {
//		嵌套循环
	public static void main(String[] args) {
		for (int i = 1; i <= 3; i++) {//外层循环，循环体语句是内层循环
			// i = 1, j = 1 --> 3
//			嵌套循环：外层循环一次，内层循环要循环完
			for (int j = 1; j <= 3; j++) {//内层循环  
				System.out.println("i = " + i + ",  j = " + j);//内层循环的循环体语句
			}
			
		}
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TYeL9j7-1602678908472)(Day04.assets/image-20201014140859631.png)]

使用嵌套循环，打印四行五列的星星矩阵
*****
*****
*****
*****



public class Demo_8 {
	public static void main(String[] args) {
//		使用嵌套循环，打印四行五列的星星矩阵
//		外层循环控制行，内层循环控制列
//		*****
//		*****
//		*****
//		*****
		for (int i = 1; i <= 4; i++) {//外层循环控制行
//			内层循环控制列
			for(int j = 1;j <= 5;j++) {
				System.out.print("*");
			}
//			
			System.out.println();
		}
	}
}


使用嵌套循环，打印5行五列的直角三角形
*
**
***
****
*****


public class Demo_9 {
//	使用嵌套循环，打印5行五列的直角三角形
//	*            1       1列
//	**           2       2列
//	***          。。。
//	****
//	*****
	public static void main(String[] args) {
//		外层循环控制行数
		for (int i = 1; i <= 5; i++) {
//			内层循环控制列
			for (int j = 1; j <= i; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
}


使用嵌套循环，打印九九乘法表


public class Demo_10 {
	public static void main(String[] args) {
//		使用嵌套循环，打印九九乘法表
//		外层循环控制行数
		for (int i = 1; i <= 9; i++) {
//			内层循环控制列
			for (int j = 1; j <= i; j++) {
				System.out.print(j + "*" + i + "=" + i * j +"\t");
			}
			System.out.println();
		}
	}
}

二、方法

1、在java语言中，方法具有特定功能的代码段。
2、我们可以通过在程序中引用方法名称和所需的参数，实现在该程序中执行（方法的调用），可以去解决一类的问题，最终会返回一个值（不是必须的）
3、某段代码经常使用，也可以将这段代码用大括号包起来，起个名字，以后就使用这个名字来代替这段代码
4、好处：
（1）提高了代码的复用性
（2）提高了代码的封装性，大括号中的内容，其他调用看不到也无法直接访问
（3）简化了软件设计的思维难度

方法的定义

1、方法定义的格式
修饰符 返回值 方法名称（参数列表）{
方法体；
return 语句；
}
2、说明：
（1）修饰符：public static
（2）返回值类型：方法具有功能，有可能会有一些产出，需要将数据返回给调用者，调用者需要知道方法产生数据的类型的。
（3）方法名称：只要是一个合法的标识符即可。 小驼峰命名法
（4）参数列表:这段代码要完成功能，可能就需要一些资源，资源是外界的，在参数列表中，定义一些变量，告诉调用者，方法所需要的数据。
将来调用者在调用方法的时候，就需要传入参数列表中声明的数据类型的数据。有了参数列表，方法就可以接受外界的数据，并进 行使用或者处理。
（5）方法体：一些对业务逻辑的处理。对数据的处理的操作
（6）return语句：最终方法调用结束之后，可能会有数据的产出。返回给调用者，使用return语句进行返回，如果没有任何数据的产出，就可以只写一个return；或者不写。
如果没有数据的产出。返回值类型就写一个void



public class Demo_12 {
//	方法的定义
	public static void main(String[] args) {

	}

//	没有返回值，也没有参数列表，方法的定义
	public static void test() {// 就是执行一条hello这样的语句
		System.out.println("hello");
	}

//	有返回值，有参数列表
	public static String sum(int a, int b, float f, String str) {
		String d = a + b + f + str;
		return d;
	}
}

方法的调用

1、格式：直接书写方法的名字即可
方法名称（实际参数）;
2、方法调用的三种形式
（1）直接调用：针对的是方法没有返回值，表示某些内容的执行
（2）输出调用：方法具有返回值，但是这个返回值不需要后续进行处理，这时候就可以使用输出调用将方法返回的结果进行打印
（3）赋值调用：针对的是方法具有返回值，将来需要使用这个方法返回的数据，定义一个变量去接收方法返回的数据。
3、方法调用的特点
方法不调用就不执行



public class Demo_12 {
//	方法的定义
	public static void main(String[] args) {
//		方法的调用
//		直接调用
		test();
//		输出调用,将方法的结果进行打印，没有对方法产生的结果进行后续的使用或者处理
		System.out.println(sum(100, 200, 2.3f, "java"));
//		赋值调用,可以对方法产生的结果进行再次的处理或者使用
		String str = sum(888, 666, 2.3f, "java");
		str += "成都";
		System.out.println(str);
	}

//	没有返回值，也没有参数列表，方法的定义
	public static void test() {// 就是执行一条hello这样的语句
		System.out.println("hello");
	}

//	有返回值，有参数列表             方法的定义
	public static String sum(int a, int b, float f, String str) {
		String d = str + a + b + f;
		return d;
	}
}

方法的注意事项

1、方法定义：
（1）方法不能嵌套定义的
（2）方法的定义，没有任何先后的区别
（3）方法的定义都是平级的关系
（4）方法是可以嵌套调用的，甚至可以自己调用自己（递归）
2、参数列表
（1）形式参数：在定义方法的时候，在参数列表中进行的只是变量的声明（只是将变量定义出来，确不赋值），各个变量之间用逗号隔开
（2）实际参数：在调用方法的时候，不能写上变量的类型，而是写具体的数据（值），各个实际参数之间，使用逗号隔开。本质上实际参数是完成 对形式参数的赋值
3、return语句:
（1）一旦执行了return语句，就意味方法的结束。
（2）如果方法没有具体的返回内容，就可以写一个return；或者不写，这时候返回值类型必须是void
（3）return后返回的数据，该数据的类型决定返回值的类型。返回值类型要和return后返回的数据的类型保持一致.



public class Demo_13 {
	public static void main(String[] args) {
		System.out.println('h');
//		方法是谁先调用，谁先执行
		test_1();
//		test_2();

		int a = 123;
		int b = 345;
//		show(123,33);
		show(a, b);// 实际参数, 本质上相当于完成了对形式参数的赋值的过程

//		int i = 100;
//		int j ;
//		j = i;
//		System.out.println(j);
		for (int i = 1; i <= 5; i++) {
			if(i ==3) {
				break;
			}
		}
		System.out.println("hellojava");
	}

	public static int show(int a, int b) {// 形式参数，只有变量的定义，没有赋值 a = 123,b = 345

		return a + b;
	}

	public static void test_2() {
		System.out.println("test_2");
	}

	public static void test_1() {
		/*
		 * public static void test_2() { 方法不能嵌套定义，一般都是定义在主方法外面 }
		 */
		test_2();// 方法可以嵌套调用
		System.out.println("test_1");
	}

}

方法在内存中的理解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Vms0sRZ-1602678908476)(Day04.assets/image-20201014162624997.png)]

1、定义一个方法，键盘录入两个整数，获取两个整数的最大值

import java.util.Scanner;

public class Demo_15 {
//	1、定义一个方法，键盘录入两个整数，获取两个整数的最大值
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入第一个数");
		int a = sc.nextInt();
		System.out.println("请输入第二个数");
		int b = sc.nextInt();
		
		int max = getMax(a,b);
		System.out.println(max);
	}

	public static int getMax(int a,int b) {
		if (a > b) {
			return a;
		} else {
			return b;
		}
	}
}


2、定义一个方法，从外界接收数据控制要打印星星矩阵的行数和列数



public class Demo_16 {
	public static void main(String[] args) {
//		定义一个方法，从外界接收数据控制要打印星星矩阵的行数和列数
		
		printXing(100,100);
	}

	public static void printXing(int hang, int lie) {
		for (int i = 1; i <= hang; i++) {
			for (int j = 1; j <= lie; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

方法的重载

1、重载：overload，
2、方法的重载：
在同一个类中，方法名相同，参数列表不同，与返回值类型无关。
3、解释：
（1）在同一类中：不同无关类中，是不可能发生重载的
（2）方法名称：一模一样
（3）参数列表不同：参数的个数不同，参数的类型不同，参数类型的顺序不同。
（4）与返回值类型无关的。方法是否是重载，与返回值类型没有关系的。
4、方法重载的好处
（1）没有重载的时候，写一些相同逻辑的代码的时候需要记忆大量的方法名称，不方便
（2）有重载之后，相同功能逻辑的代码，都使用的是一个方法的名称，不需要去记忆大量方法的名称了。
5、当前学习过的重载：
println方法，可以打印任意数据类型的，println方法中重载了很多不同的数据类型



public class Demo_17 {
//	方法的重载
	public static void main(String[] args) {
//		getSum(1,2);
		int sum = getSum(1,3);
		System.out.println(sum);
	}
	
//	两个数的和 ---------------------------------1
	public static int getSum(int a,int b) {
		System.out.println("int");
		return a + b;
	}
	
//	public static double getSum(int a,int b) {//通过保证参数列表一致，让返回值类型不一致，发现编译报错，所以说明重载跟返回值没有关系的
//		System.out.println("int");
//		return a + b;
//	}
	
//	求三个数的和---------------------------------2
//	通过1,2，参数的个数不同，就是重载的一种体现
	public static int getSum(int a,int b,int c) {
		return a + b + c;
	}
	
//	求两个小数的和--------------------------------3
//	通过1.3，参数的类型不同，也是重载的一种体现
	public static double getSum(double a,double b) {
		System.out.println("double");
		return a + b;
	}
	
//=------------------------------------------4
	public static double getSum(int a,double d) {
		return a + d;
	}
//=------------------------------------------5
//	通过4,5发现，参数的类型的顺序不同，也是重载的一种体现
	public static double getSum(double d,int a) {
		return a + d;
	}
	
	/*
	 * public static double getSum(double dd,int aa) { return a + d; }重载跟参数列表的参数的名称是无关的，只跟类型有关
	 */
}

练习

package com.quan.day2;

public class Lianxi_6 {
	public static void main(String[] args) {
		lian(5);
		System.out.println("\n============\n");
		lian(5.0f);
		System.out.print("\n=============\n");

		char a = lian('C');
		System.out.println(a);
	}

//	1、使用嵌套循环实现倒直角三角形的打印
//	   *****
//	   ****
//	   ***
//	   **
//	   *
	public static void lian(int a) {
		for (int i = a; i >= 1; i--) {
			for (int j = i; j >= 1; j--) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

//	2、使用嵌套循环打印三角形，如下：
//			*
//	       ***
//	      *****
//	     *******
//	    *********
	public static void lian(float a) {
		int b = (int) a;
		for (int i = 1; i <= b; i++) {
			for (int j = 5 - i; j >= 1; j--) {
				System.out.print(" ");
			}
			for (int j = (i * 2) - 1; j >= 1; j--) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

//	3、封装一个方法，传入一个字符，如果是大写那么转化小写
//然后返回，	否则保持不变返回
	public static char lian(char a) {
		if (a >= 'A' && a <= 'Z') {

			return (char) (a + 32);
		}
		return a;
	}

}
Q-H-B
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
while读入方法
林笙的博客
08-25 202
1.scanf("%d", &x) != EOF while(scanf("%d", &x) != EOF) 2.~scanf("%d", &x) while(~scanf("%d", &x)) 例： #include <bits/stdc++.h> using namespace std; int x; int main() { while(~scanf("%d", &x) && x != 42) { printf("%d\
讲解C++的do while循环和循环语句的嵌套使用方法
01-20
用do-while语句构成循环 do-while语句的特点是先执行循环体，然后判断循环条件是否成立。其一般形式为： do 语句 while (表达式); 它是这样执行的：先执行一次指定的语句(即循环体)，然后判别表达式，当表达式...
while的使用方法
weixin_57234246的博客
04-22 596
if -elif语句 # if-elif语句 # if-elif=else语句，一定会有且一个条件执行。 v=5500 if v>=30000: print('有钱人') elif v>=20000: print('有钱真好') elif v>=10000: print('居然上万') elif v>=5000: print('够花') elif v >= 2000: print('养活') else : print('啃老族')
while循环 、方法
weixin_48788281的博客
09-28 604
1 循环 1.1While while 是真假循环,当某个条件为真的时候执行 语法: while( 布尔型表达式 ){ 循环体; } 先判断再执行,存在不执行情况 不执行情况: 执行情况: 1.2Dowhile for 和 while 执行次数是 0~N次,有不执行情况 而 doWhile 能够保证代码最少执行一次 先执行一次,再进行判断. 1.3Break 1 用于switch中,结束case分支,防止case穿透 2 用于循环中,结束循环 ...
while循环基本使用方法
dgh0205的博客
06-11 4187
【转载】
while的四种使用方式
weixin_33849215的博客
07-28 345
方式一：计数器控制while的循环#!/bin/bashsum=0i=0while (( i <= 100 ))do let "sum=sum+$i" let "i=i+2"doneecho $sum方式二：结束标记控制循环read -p "please input a num[1-10] " num2while [[ "$num" != 5...
MySQL存储过程中使用WHILE循环语句的方法
12-15
本文实例讲述了MySQL存储过程中使用WHILE循环语句的方法。分享给大家供大家参考。具体如下： mysql> mysql> delimiter $$ mysql> mysql> CREATE PROCEDURE myProc() -> BEGIN -> -> DECLARE i int; -> SET i=1;...
Go语言模拟while语句实现无限循环的方法
09-22
然而，我们可以通过使用`for`语句来模拟`while`语句，实现相同的功能，特别是在创建无限循环时。下面将详细解释如何在Go语言中使用`for`语句来模拟`while`语句，并通过一个实例来演示无限循环的实现。 首先，`while...
C#中for循环、while循环循环执行的方法
12-31
先给大家介绍下C#中的循环执行for循环 在这一节练习中，我们向大家介绍一下C#中的另一种重要的循环语句，for循环。 for（表达式1;表达式2;表达式3） { 循环体 } 表达式1：一般为赋值表达式，给控制变量赋初值； ...
java初学——关于while循环的一个方法
weixin_40615146的博客
03-23 282
经过过一次笔试，笔试题中一共四道大题，由于前三道均为SQL语句的题目，而且主要是增删改查，因此对最后那个非SQL语句的题目印象深刻，具体题目大意如下： A和B有数字0-100的卡片，A随机抽出一张让B猜，并且只能告诉B所猜的数字相比于该数字大了还是小了，请就这个游戏用你所擅长的语言进行编程。 具体代码如下： import java.util.Scanner; public class Dem...
while的经典用法
Googol
04-25 932
S=1+1/2+1/3+1/4+…+1/100 #include<stedio.h> main() { double sum=0; int i=1; while(i<100) { sum=sum+1.0/i; i++; } printf("%f",sum); return 0; } s=10! #includ
扎实基础深入篇（六）：while循环带动生产力
weixin_30825199的博客
01-28 194
在本篇博客中，你将学习如何让程序不断地运行，让用户能够根据需要输入信息，并在程序中使用这些信息。 为此，你需要使用wile循环让程序不断地运行，直到指定的条件不满足为止。 注意：在学习循环的路上，一定要学会刹车！ 在进入本篇博客学习之前，我们需要解决一下上篇博客留下来的作业： 创建一个名为cities的字典，其中将三个城市名用作键，对于每个城市的所属省份、人口数、是否为省会等等创建一...
while循环以及方法
m0_46954550的博客
01-08 1万+
while循环语句的基本格式： 初始化变量； while(判断语句){ 循环语句体； 控制语句体； } while循环可以与for循环等价转换 while循环与for循环的区别： 1、他们之间虽然可以做等价转换，但是在开发中如果遇到在一个范围内做循环的时候使用for循环 2、当循环的次数不知道时用while循环 3、for循环结束后，初始化语句中的变量在外部...
Python习题答案
weixin_47126200的博客
12-16 1万+
python
初识c语言（2）while循环
最新发布
m0_73433755的博客
07-10 743
通过以往的学习，我们已经掌握了if语句：if（条件）语句；当条件满足的情况下，if语句后的语句执行，否则不执行。但是这个语句只会执行一次。由于我们发现生活中很多实际的例子是：同一件事情我们需要完成很多次。那我们该怎么做呢？c语言中给我们引入了while语句，可以实现循环。
while循环的学习
m0_48697452的博客
07-20 763
今天学习的是while的循环，下面是我的学习过程和练习。
while 语句的三种控制/结束循环方式
热门推荐
XvAier的博客
09-09 2万+
while语句若一直满足条件，则会不断的重复下去。但有时，我们需要停止循环，则可以用下面的三种方式： 1.在while语句中设定条件语句，条件不满足，则循环自动停止： ie: 只输出3的倍数的循环；范围：0到20. current_number = 0 while current_number &amp;lt; 20: current_number += 1 if curren...
for循环与while循环的优缺点
qq_41269379的博客
08-14 7344
for循环 循环控制变量的初始化和修改都放在语句头部分，书写形式较简洁，且适用于循环次数已知的情况。在循环语句中定义一个局部变量，循环结束后，局部变量就被释放了。 while循环 循环控制变量的初始化一般放在while语句之前，循环控制变量的修改一般放在循环体中，形式上不如for语句简洁，但它比较适用于循环次数不易预知的情况（用某一条件控制循环）。 两种形式各有优点，但它们是等价的，...
Java中的循环结构（while）、方法
啊帅和和的博客
07-24 1225
今天涉及的内容是有关流程控制语句、跳转控制语句、数组的定义、Java中的内存分配部分的内容。 循环结构（while循环语句） while循环语句的基本格式： 基本格式： while(判断条件语句){ 循环体语句; } 扩展格式： while(判断条件语句){ 循环体语句; 控制条件语句; } 范例1： public class WhileDemo1 { public static void main(String[] args) { System.out.println("Hel
c语言-while循环
12-23
"C语言-while循环" 在C语言中，`while`循环是一种常见的流程控制结构，用于在满足特定条件时重复执行一段代码。它的基本语法结构如下： ```c while(表达式) { 需要执行的循环体语句； } ``` `while`循环的工作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值