JAVA基础知识 流程控制及方法详解

已于 2022-07-08 01:24:38 修改
阅读量299 收藏
点赞数 3
文章标签： java 开发语言 学习 面试
于 2022-06-11 11:05:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q475476257/article/details/125232352
版权

JAVA基础知识（二）

流程控制

Java中流程控制分为三种,任何的复杂业务逻辑都可以使用流程控制来实现！

1.顺序结构：代码逐语句执行! 也叫做顺序执行,每句必走。

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:数量


    例如：
  购物满500 打 8折 -----------条件: 购物满500为true ------则打8折     
             							       		 ---单路分支
  


  购物满500 打 8折  不满 打9折  ----------条件是满足500 打 8折
​                                             不满足500 打 9折
​                                                    ---双路分支

​
​
​

分支结构

单路分支：（if结构）
1)语法:
   if(boolean){
      语句块----------有条件执行的语句
   }
2)执行过程:
   判断boolean的值:
     若为true，则执行语句块(if整个结束)
     若为false，则if直接结束

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

//2)满500打8折:
double price = 300.0; //消费金额  带数(600.0,300.0)
if(price>=500){ //满500
    price = price*0.8; //打8折
}
System.out.println("最终结算金额为:"+price);
双路分支：（if…else结构）
1)语法:
  if(boolean){
      语句块1
  }else{
      语句块2
  }
2)执行过程:
    判断boolean的值:
       若为true，则执行语句块1(整个结束)
       若为false，则执行语句块2(整个结束)
3)说明:
    语句块1和语句块2，必走其中之一-------2选1

double price = 366;//购物金额
        if(price >= 500){//如果 购物金额大于等于 500
            price *= 0.8;//打8折
            System.out.println("打完8折后,应付:"+price);
        }else {//否则
            price *= 0.9;//打9折
            System.out.println("打完9折后,应付:"+price);
        }
        System.out.println("已付款:"+price);
多路分支：（if…else if结构）
1)语法: 
if(boolean-1){   
语句块1  
}else if(boolean-2){
语句块2  
}else if(boolean-3){    
语句块3  
}else{
语句块4  
}
2)执行过程:   
判断boolean-1，若为true则执行语句块1(整个结束)，若为false则    
再判断boolean-2，若为true则执行语句块2(整个结束)，若为false则    
再判断boolean-3，若为true则执行语句块3(整个结束)，若为false则执行语句块4(整个结束)
3)说明:    
语句块1/2/3/4，必走其中之一-----------多选1

package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();
        //带数(888,-56,95,85,65,45)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }

    }

}

拓展：

Scanner

接收用户输入的数据：-----分三步

package day04;
import java.util.Scanner; //1.导入扫描仪
//Scanner结构的演示
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //2.新建一个扫描仪scan
        System.out.println("请输入年龄:");
        int age = scan.nextInt(); //3.扫描一个整数并赋值给age
        System.out.println("请输入商品价格:");
        double price = scan.nextDouble(); //3.扫描一个小数并赋值给price
        System.out.println("年龄为:"+age+"，商品价格为:"+price);
    }
}

随机生成：

int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
推导过程:
Math.random()---------------0.0到0.9999999999999999...
*1000-----------------------0.0到999.99999999999999...
+1--------------------------1.0到1000.9999999999999...
(int)-----------------------1到1000
练习:
通过控制台的方式  获取用户输入的年龄:
对年龄进行判断等级:
1.如果 age 大于等于0  并且 小于 5   输出幼年!
2.如果 age 大于等于5	并且 小于 18  输出青年!
3.如果 age 大于等于18 并且 小于 35  输出成年!
4.如果 age 大于等于35 并且 小于 50  输出中年!
5.如果 age 大于等于50 并且 小于 65  输出中老年!
6.如果 age 大于等于65 并且 小于 150 输出老年!
  否则  神仙!
switch case 多路分支结构:

适用性: 只能对整数类型进行判等,(不可以用long类型) ,若判断的值相等则走对应的代码块.JDK1.7以后支持对字符串的内容进行判断.

不能够匹配逻辑或关系运算符的内容, 只能匹配单值.

优点:判断单值的数据是否相等时,效率优于ifelseif结构.

break;代表退出当前结构的语法,若在switch case 语法结构中使用,则表示退出当前结构.

default: 默认,当若多个判断的内容都没成立时,则执行defualt 语句.

package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.取款 2.存款 3.查询余额 4.退卡");
        int command = scan.nextInt();

        switch(command){
            case 1:
                System.out.println("取款业务...");
                break;
            case 2:
                System.out.println("存款业务...");
                break;
            case 3:
                System.out.println("查询余额业务...");
                break;
            case 4:
                System.out.println("退卡业务...");
                break;
            default:
                System.out.println("输入错误");
        }
    }

}
练习
//接收用户输入的年份year和月份month，计算该年该月的天数，并输出

//参考代码：
package test;
import java.util.Scanner;
public class Day04 {
    public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
        System.out.println("请输入年份:");
        int year = scan.nextInt();
        System.out.println("请输入月份:");
        int month = scan.nextInt();
        int days = 0; //天数
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                days = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                days = 30;
                break;
            case 2:
                if((year%4==0 && year%100!=0) || year%400==0){
                    days = 29;
                }else{
                    days = 28;
                }
        }
        System.out.println(year+"年的"+month+"月共"+days+"天");
    }
}

循环结构:

循环:字面意思指的就是重复执行某段代码.反反复复的过程,称之为循环.

Java循环结构分为三种: 1. while 2.do…while 3.for(应用率最高)

循环语法的三要素:

  1. 循环变量的初始化
  2. 基于循环变量的条件
  3. 循环变量的改变(朝着目标去改变!)

循环变量：在整个循环过程中所反复改变的那个数

案例一：
  输出5次"行动是成功的阶梯"
    行动是成功的阶梯
    行动是成功的阶梯
    行动是成功的阶梯
    行动是成功的阶梯
    行动是成功的阶梯
  循环变量: 次数times
  1)int times=0;
  2)times<5
  3)times++;
    times=0/1/2/3/4/ 5时结束

案例二：
  输出9的乘法表:
    1*9=9
    2*9=18
    3*9=27
    4*9=36
    5*9=45
    6*9=54
    7*9=63
    8*9=72
    9*9=81
  循环变量:因数num
  1)int num=1;
  2)num<=9
  3)num++;
    num=1/2/3/4/5/6/7/8/9/ 10时结束
        

    1*9=9
    3*9=27
    5*9=45
    7*9=63
    9*9=81

  循环变量:因数num
  1)int num=1;
  2)num<=9
  3)num+=2;
    num=1/3/5/7/9/ 11时结束
while结构：

先判断后执行，有可能一次都不执行

1)语法:
  while(boolean){
    语句块---------------反复执行的代码
  }
2)执行过程:
    先判断boolean的值，若为true则执行语句块，
    再判断boolean的值，若为true则再执行语句块，
    再判断boolean的值，若为true则再执行语句块，
    如此反复，直到boolean的值为false时，while循环结束

//1)输出5次"行动是成功的阶梯":
int times = 0;  //1.循环变量的初始化
while(times<5){ //2.循环的条件
    System.out.println("行动是成功的阶梯");
    times++;    //3.循环变量的改变
}
System.out.println("继续执行...");
/*
 执行过程:-----带数
            times=0
 true  输出  times=1
 true  输出  times=2
 true  输出  times=3
 true  输出  times=4
 true  输出  times=5
 false while循环结束
 输出继续执行...
*/

//2)输出9的乘法表:
int num = 1;
while(num<=9){
    System.out.println(num+"*9="+num*9);
    num+=2; //num++;
}
System.out.println("继续执行...");

package day04;
import java.util.Scanner;
//猜数字游戏
public class Gueesing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //300(大),200(小),250(对)
        System.out.println("猜吧!");
        int guess = scan.nextInt(); //1.
        while(guess!=num){ //2.
            if(guess>num){
                System.out.println("太大了");
            }else{
                System.out.println("太小了");
            }
            System.out.println("猜吧!");
            guess = scan.nextInt(); //3.
        }
        System.out.println("恭喜你猜对了!");
    }

}
do…while结构：

先执行后判断，至少执行一次

当第1要素与第3要素相同时，首选do…while--------参考Guessing猜数字小游戏

1)语法:
  do{
    语句块
  }while(boolean);
2)执行过程:
    先执行语句块，再判断boolean的值，若为true则
    再执行语句块，再判断boolean的值，若为true则
    再执行语句块，再判断boolean的值，若为true则
    再执行语句块，如此反复，直到boolean的值为false时，do...while循环结束

package day04;
import java.util.Scanner;
//猜数字游戏
public class Gueesing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //假设num=250
        //300(大),200(小),250(对)
        int guess;
        do{
            System.out.println("猜吧!");
            guess = scan.nextInt(); //1+3
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
        }while(guess!=num); //2
    }
}


单词背记：
1)for:为了、循环的一种
2)continue:继续
3)result:结果
4)answer:回答
5)array/arr:数组
6)length:长度
7)multi:多
8)table:表格
9)addition:加法
10)index:下标、索引
11)out of:超出
12)bounds:界限
13)exception:异常
for结构：

应用率最高，与次数相关的循环

1)语法:
  //   1     2    3
  for(要素1;要素2;要素3){
    语句块/循环体------------反复执行的代码  4
  }
2)执行过程:
    1243243243243243243...2

for(int times=0;times<5;times++){
    System.out.println("行动是成功的阶梯");
}
//for中的循环变量num的作用域----仅在当前for中
for(int num=1;num<=9;num++){
    System.out.println(num+"*9="+num*9);
}

for(int num=1;num<=9;num+=2){
    System.out.println(num+"*9="+num*9);
}

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //总分
        for(int i=1;i<=10;i++){ //10次    (1)25+6=?
            int a = (int)(Math.random()*100); //加数a(0到99之间)
            int b = (int)(Math.random()*100); //加数b(0到99之间)
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
            System.out.println("算吧!");
            int answer = scan.nextInt(); //2)答题
            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

三种结构如何选择：

  • 先看循环是否与次数相关：
    • 若相关-----------------------------直接上for（当明确循环次数 优先考虑for循环）
    • 若无关，再看要素1与要素3的代码是否相同：
      • 若相同-----------------------直接上do…while（一定会先做一次循环体,然后再判断条件是否成立! 至少做一次.）
      • 若不同-----------------------直接上while（一定先判断while小括号中的条件是否成立!成立则执行循环体.也有可能一次都不做.）

break：跳出循环-------------可以用在switch和循环中

for(int num=1;num<=9;num++){
    if(num==4){ //在某种特定情况下，提前结束循环
        break; //跳出循环
    }
    System.out.println(num+"*9="+num*9);
}

continue：跳过循环体中剩余语句而进入下一次循环-----------只能用在循环中

//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
    if(num%3==0){
        continue; //跳过循环体中剩余语句而进入下一轮循环
    }
    System.out.println(num+"*9="+num*9);
}

//输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
    if(num%3!=0){
        System.out.println(num+"*9="+num*9);
    }
}
嵌套循环：

  • 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列

  • 执行规则：外层循环走一次，内层循环走所有次

  • 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层

  • break只能跳出当前层循环

//九九乘法表
for(int num=1;num<=9;num++){ //控制行
    for(int i=1;i<=num;i++){ //控制列
      System.out.print(i+"*"+num+"="+i*num+"\t"); //print():输出不换行
    }
    System.out.println(); //换行
}

练习

利用for循环计算：打印字符*组成的等腰三角形，输出结果如下所示：

     *
    ***
   *****
  *******
 *********
***********

参考代码：

package test;
public class Day05 {
    public static void main(String[] args) {
		for(int i=1;i<=6;i++){
            for(int j=i;j<=6;j++){ //空格
                System.out.print(" ");
            }
            for(int k=1;k<=2*i-1;k++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
增强for循环

java5引入了一种主要用于数组或集合的增强型for循环

java增强for循环语法格式如下：

for(声明语句:表达式){
//代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者返回值为数组的方法

int[] numbers = {10,20,30,40,50};
//遍历数组的元素
for(int x:numbers){
    System.out.println(x)
}

数组：

  • 是一种数据类型(引用类型)

  • 相同数据类型元素的集合

  • 定义：

    //声明整型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];

初始化：-----初始化的是数组中的元素

    int[] arr = new int[3]; //0,0,0
	int[] arr= {1,2,3,4,6,5,9,7};//定义数组
      // 下标    0 1 2 3 4 5 6 7	
    int[] arr = new int[]{1,4,7}; //1,4,7
    int[] arr;
    //arr = {1,4,7}; //编译错误，此方式只能声明同时初始化
     arr = new int[]{1,4,7}; //正确

访问：-----访问的是数组中的元素

  • 通过数组名.length可以获取数组的长度(元素的个数)

    int[] arr = new int[3];
System.out.println(arr.length); //3

    • 通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)

      int[] arr = new int[3];
System.out.println(arr[0]); //0，输出第1个元素的值
arr[0] = 100; //给arr中的第1个元素赋值为100
arr[1] = 200; //给arr中的第2个元素赋值为200
arr[2] = 300; //给arr中的第3个元素赋值为300
//arr[3] = 400; //运行时会发生数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值

遍历/迭代：从头到尾挨个走一遍

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
    arr[i] = (int)(Math.random()*100); //给每一个元素赋值为0到99的随机数
    System.out.println(arr[i]); //输出每个元素的值
}

单词背记：
1)copy:复制
2)arraycopy/copyOf:数组复制
3)max:最大值
4)min:最小值
5)sort:顺序、排序
6)method:方法
7)public static:公开静态的
8)void:空，没有返回结果的
9)return:返回
10)say:说
11)sayHi/sayHello:问好
12)getNum:获取数字
13)plus:加法
14)test:测试

数组的四个基本特点

  • 1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
  • 2.其元素必须是相同类型，不允许出现混合类型
  • 3.数组中的元素可以是任何数据类型，包括基本类型和引用类型
  • 4.数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
    数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型
    数组对象本身是在堆中的。

复制：

  • System.arraycopy(a,1,b,0,4);

    int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,b,0,4); //灵活性好
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

  • int[] b = Arrays.copyOf(a,6);
    a = Arrays.copyOf(a,a.length+1); //数组的扩容

    int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度
//----若目标数组的长度>源数组长度，则在末尾补默认值
//----若目标数组的长度<源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6);
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

//数组的扩容
int[] a = {10,20,30,40,50};
//数组的扩容(创建了一个更大的新的数组，并将数据复制进去了)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

排序：

  • Arrays.sort(arr);

    int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
    arr[i] = (int)(Math.random()*100);
    System.out.println(arr[i]);
}
Arrays.sort(arr); //对arr进行升序排列
System.out.println("排序后:");
for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
}
System.out.println("倒序输出"); //只是倒着显示，但数组中数据没有改变
for(int i=arr.length-1;i>=0;i--){
    System.out.println(arr[i]);
}

变量互换，引入一个第三方变量

	int temp=arr[1];
	arr[1]=arr[2];
	arr[2]=temp;

何谓方法？

System.out.println(),那他是什么呢？

System是类，out是对象，println是方法；整句我们可以理解为调用system类里面的标准输出对象out

中的方法println。

  • Java方法是语句的集合，它们在一起执行一个功能。

    ​ 方法是解决一类问题的步骤的有序组合

    ​ 方法包含于类或对象中

    ​ 方法在程序中被创建，在其他地方被引用

  • 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法独立，就是一个方法只完成一个功能，这样利于我们后期的扩展。

回顾：方法的命名规则？

首字母小写的驼峰命名规则。

方法的定义

  • Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含一下语法：

  • 方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

    • 修饰符：修饰符，这是可选的，告诉编译器如何调佣该方法。定义该方法的访问类型。//public , static…

    • 返回值类型：方法可能会返回值。returnValueType是方法的访问类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void(空的意思)。

    • 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

    • 参数类型：参数像是一个占位符。当方法被调用时，传递给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

      • 形式参数：在方法被调用时用于接收外界输入的数据。

      • 实参：调用方法时实际传给方法的数据。

    • 方法体：方法体包含具体的语句，定义该方法的功能。

      修饰符  返回值类型 方法名（参数类型 参数名）{
	...
	方法体
	...
	return  返回值;
}

//无参无返回值
public static void say(){
    System.out.println("大家好，我叫WKJ，今年38岁了");
}

//有参无返回值
public static void sayHi(String name){ //形参
    System.out.println("大家好，我叫"+name+"，今年38岁了");
}

//有参无返回值
public static void sayHello(String name,int age){ //形参
    System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

//无参有返回值
public static double getNum(){
    //有返回值的方法中，必须有return
    //并且return后数据的类型还必须与返回值类型匹配
    //return "abc"; //编译错误，返回值类型不匹配
    return 8.88; //1)结束方法的执行  2)返回结果给调用方
}

//有参有返回值
public static int plus(int num1,int num2){
    int num = num1+num2;
    return num; //返回的是num里面的那个数
    //return num1+num2; //返回的是num1与num2的和
}

//无参有返回值
public static int[] testArray(){
    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
    }
    return arr;
}

方法的调用：

无返回值：方法名(有参传参);
public class MethodDemo {
    public static void main(String[] args) {
        say(); //调用say()方法

        //sayHi(); //编译错误，有参则必须传参
        //sayHi(250); //编译错误，参数类型必须匹配
        sayHi("zhangsan"); //String name="zhangsan"  //实参
        sayHi("lisi"); //String name="lisi"          //实参
        sayHi("wangwu"); //String name="wangwu"      //实参

        sayHello("zhangsan",25); //实参 String name="zhangsan",int age=25
        sayHello("lisi",24); //实参
    }
}
有返回值：数据类型 变量 = 方法名(有参传参);
//方法的演示
public class MethodDemo {
    public static void main(String[] args) {
        double a = getNum(); //getNum()的值就是return后的那个数
        System.out.println(a); //8.88，模拟对返回值的后续操作

        int b = plus(5,6); //plus(5,6)的值就是return后的那个数
        System.out.println(b); //11，模拟对返回值的后续操作

        int m=5,n=6;
        int c = plus(m,n); //传递的是m和n里面的数
        System.out.println(c); //11，模拟对返回值的后续操作

        int[] d = testArray();
        System.out.println(d.length); //10，模拟对返回值的后续操作
    }
}

return：

  • return 值; //1)结束方法的执行 2)返回结果给调用方-------用在有返回值的方法中
  • return; //1)结束方法的执行------------------------------------用在无返回值的方法中
可釦--稀饭
关注
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值