JAVA基础语法（复习【1205】）

一、包的引入
不同包下的类在使用的时候需要使用import进行导入
有一个JDK自带的包下的类，在使用的时候不用导入，叫做：java.lang
非java.lang包下的所有的类在不同包下使用的时候都需要进行导入，如果在同一个包下，不用进行导入！
导入的语法：
import 包名.类名 ；
…
如果说想要导入java.util下的所有的类：
import java.util.*;

导入语句写在 package 下面。

二、SCANNER
2.1，Scanner的简单实现以及使用：
在Java1.5 中，有一个非常简单的用来读入数据的类： java.util.Scanner。
使用时的代码如下：

//引入 Scanner 类
import java.util.Scanner;
public class TestScanner{
public static void main(String args[]){
//下面这行代码创建了一个 Scanner 对象
//可以理解为，这行代码为读入数据做准备
Scanner sc = new Scanner(System.in);
System.out.print("请输入一个字符串： ");
//读入一行字符串，可以使用 sc.nextLine()语句
String str = sc.nextLine();
System.out.println(str + " 收到了！ ");
System.out.print("请输入一个整数： ");
//读入整数时，使用 sc.nextInt()语句
int n = sc.nextInt();
System.out.print("请输入一个小数： ");
//读入浮点数，可以使用 sc.nextDouble()语句
double d = sc.nextDouble();
System.out.println(n * d);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
运行时，可以根据提示，在控制台上进行输入。
根据提示，可以在命令行上输入字符串、整数和小数。通过 java.util.Scanner 类，我们就实现了在命令行上或者是控制台上读入数据的功能。

如果输入的类型和读取的类型不同，会进行对应的错误提示。

2.2，简单的用户登陆判断：
要求：
//创建两个变量，一个用来指定用户名，一个用来指定密码

//创建键盘输入

//将输入的数据和用户名密码进行对比

//输出登陆结果

这是示例：
https://blog.csdn.net/weixin_43889638/article/details/84726536

三、流程控制

3.1，选择结构：
在程序设计时，经常需要使用选择结构在程序中完成逻辑判断和选择功能，这就需要使用到选择语句。
Java中的选择语句包括
if语句
if-else语句
switch语句
选择语句用来控制选择结构，对选择条件进行判，并根据判断结果选择要执行的程序语句，改变程序执行流程。

3.1.1，if/else之单分支选择结构：

语法：
if (布尔表达式){
代码块 1
}else{
代码块 2
}

if 关键字后面跟一对圆括号，圆括号中是一个布尔表达式。所谓的布尔表达式，指的是值为 boolean 类型的表达式。例如， a == 5、 b >= 3，以及(a>4)&&(b<5)等，都是布尔表达式。

有如下代码：

import java.util.Scanner;
public class TestDivide{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int a = 10;
int b = sc.nextInt();
System.out.println(a/b);
}
}
//在上述代码中，如果我们输入了0，此时程序会出现数学错误，除数为0；
对输入的数字进行判断，修改后如下：
import java.util.Scanner;
public class TestDivide{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int a = 10;
int b = sc.nextInt();
if (b != 0){
System.out.println(a/b);
}else{
System.out.println(“b不能为 0”);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
3.1.2，if/else之多分支选择结构：

语法：
if (条件 1){
条件 1 的代码块
}else if (条件 2){
条件 2 的代码块
}else if (条件 3){
条件 3 的代码块
}else{
条件 4 的代码块
}

这个结构中，由一个 if 语句开头，判断第一个条件； 中间有多个 else if 语句，每个 else if 语句中判断一个条件；最后有一个 else 语句，当所有条件都不满足时，执行这个 else 语句。

有些时候，判断的结果并不仅仅是 true 或者 false。例如，我们读入一个 0~100之间的整数，表示学生的成绩。我们要写一个程序，对成绩进行评级： 0~59 评为 E， 60~69评为 D， 70~79 评为 C， 80~89 评为 B， 90~100 评为 A。 我们要对表示成绩的这个整数区分出 5 种不同的情况；

这种类型的程序，我们需要进行多次判断。 先定义一个 int 类型的变量 score，并从控制台上读入用户的输入，代码片段如下：

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
1
2
首先，应当判断这个整数是否是大于等于 0 并且小于 60。如果满足这个条件的话，则学生的成绩是 E 级，输出 E；如果不满足这个条件的话，则说明学生的成绩大于 59。而学生成绩如果大于 59 分，则又有很多种不同的情况，需要继续判断。、

3.1.3，switch语句：

在生活中，我们可能都有过用手机开通业务的经验。在与服务台通话的过程中，可能会听到这样的部分：
“为手机充值请按 1，停开机请按 2，业务办理请按 3，人工服务请按 9，返回上一级菜单请按* ”
根据我们按键的不同， 手机服务台会进入不同的流程。这样，根据输入的值不同，进入多个不同的流程，这种程序结构称为多重分支。在 Java中，我们可以用 switch 语句来完成多重分支。这种语句最基本的语法如下：

switch(//表达式){
case value1 :
//语句块 1;
break;
case value2 :
//语句块 2;
break;
case value3 :
//语句块 3;
break;
…
case valueN :
//语句块 N;
break;
default :
//语句块;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
我们希望当执行完一个 case 的语句块之后，就应该跳出 switch 语句，而不是继续执行。为了实现这种要求，我们需要在每一个 case语句后面，增加一个语句： break。 break 语句能够跳出 switch 语句，不让程序继续向下执行。

比如说：
我们从命令行上读入一个整数，这个整数的范围是 15，分别表示成绩的等级“A”“E”。然后，根据这个整数的不同，输出该等级的成绩范围。例如，如果读入的值是 1，则表示“A”级，输出 90~100；如果读入的值时 3，则表示“C”级，输出 70~79。

3.2，循环结构：
循环是计算机程序当中最重要的一个特性之一，毕竟，当初人们发明计算机，就是想把一些重复而机械的劳动交给计算机来完成，而把一些比较需要创造力的部分交给人来完成。
比如，我们在第一章中学会了怎样输出一个“HelloWorld”。 那如果我们需要输出十个
“HelloWorld”怎么办？ 这时候，也许还能够写 10 个输出语句。但是如果我们需要输出更多个 Hello World，比如 100 万个。显然， 写 100 万个输出语句是不现实的。计算机更加擅长这种重复而机械的劳动，我们应当把这种反复的输出让计算机来完成。这就需要在编程时，掌握循环语句的使用。
循环语句的意义在于，可以让程序中的某些代码被反复的执行多次。
3.2.1，for循环：

for 循环包含循环的四个要素，语法如下：

for(初始化 ; 循环条件 ; 迭代操作){
循环体;
}
1
2
3
举例来说，我们可以写一个 for 循环用来输出 10 个 HelloWorld。我们用一个变量 i，来统计总共循环了多少次，我们把这个 i 变量称为计数器。这样，循环的初始化，就应该把计数器清零。每当进行了一次循环之后，就把计数器+1，因此迭代操作，就是 i++。而循环条件，则是判断循环的次数：如果循环已经进行了 10 次，则结束循环；如果循环没有满 10
次，则循环继续。我们在判断循环的时候，只要把计数器 i 和 10 进行比较，就能判断是否执行循环。
由上面的分析，可以写出 for 循环的代码如下：

int i ;
for( i = 0; i<10; i++){
System.out.println(i + " Hello World");
}
1
2
3
4
首先，在 01 行，程序定义了一个变量 i，这个变量用作计数器。之后，在 02 行开始进入 for 循环。在 for 循环中，首先执行 i=0 的初始化操作，把计数器清零。 要注意的是，初始化操作只执行一遍；然后，进行循环条件的判断。此时 i 值为 0， i<10 判断为真，循环继续；之后，执行循环体，输出 0 Hello World；当循环体一次执行结束，执行迭代操作 i++，此时 i 值为 1，表示循环已经完成了一次；然后， 再进行循环条件的判断，此时 i 为 1， i<10 判断为真，循环继续；执行循环体，输出 1 Hello World；执行迭代操作 i++，此时， i 的值为 2；进行循环条件的判断。由于此时 i 的值为 2， i<10 判断为真，循环继续…依次类推，直到最后一次，当 i = 9 时，输出 9 HelloWorld；执行迭代操作， i++。此时， i 的值为 10，表示已经循环了 10 次。再进行循环条件的判断。由于此时 i 的值为 10，因此 i<10 判断为假，循环退出。

3.2.2，while循环：

while 循环语法：

while(循环条件){
循环体
}
1
2
3
循环条件的含义是一样的：这是一个布尔表达式，当表达式为 true 时，循环继续；当表达式为 false 时，循环退出。

例如：
我们分别使用 while 循环来完成输出 10 个
HelloWorld 的程序

int i = 0;
while(i <10){
System.out.println(i + " Hello World");
i++;
}
1
2
3
4
5
while循环的流程图和for循环的流程图一样；

3.2.3，do/while循环：

do/while循环和while循环类似，只不过是，do/while循环会先执行一次循环体，然后进行循环判断，如果符合条件则继续循环，如果不符合条件则结束循环，也就是说do-while循环的循环体无论如何都会执行一次。流程图参照“do-while流程图”；

例如：
使用 do…while 循环来完成输出 10 个
HelloWorld 的程序。

int i = 0;
do{
System.out.println(i + " Hello World");
i++;
}while(i <10);
1
2
3
4
5
3.3，跳转语句：

3.3.1，跳转语句之break:

break 语句表示跳出当前的循环。例如：

for(int i = 0; i<=5; i++){
if (i == 3) {
break;
}
System.out.println(“i=”+i);
}
1
2
3
4
5
6
在程序的第二行进行了一个判断，当 i 为 3 时执行 break 语句。在执行 for 循环过程中，i 的值为 0~2 时，判断为假，因此会执行循环体后面的输出语句，而当 i 为 3 时， 循环执行 break 语句。此时，会跳出 for 循环。

3.3.2，跳转语句之continue:

continue 语句表示跳出本“次”循环。 所谓的本次循环，是指的， continue 语句会跳到循环体的末尾，然后执行迭代操作，之后，再进行循环条件的判断。也就是说，使用 continue语句不会跳出整个循环， 只是跳过这一轮的循环。例如下面的代码：

for(int i = 0; i<=5; i++){
if (i == 3) {
continue;
}
System.out.println(“i=”+i);
}
1
2
3
4
5
6
前面，程序正常输出 i=0, i=1, i=2。 当 i 为 3 时， 执行 continue 语句。此时，代码会跳到
for 循环循环体的末尾，跳过输出语句。然后， 执行迭代操作 i++， i 的值为 4，程序继续运行。因此，在最后的结果中，除了 i=3 被跳过之外，其他的部分都正常输出；

3.4，多重循环：

考虑下面这个练习：从命令行上读入一个正整数，根据这个正整数，输出下面的图形：
例如，当 n = 3 时，输出：

n = 4 时，输出

这个练习如何完成呢？思路如下：
对于任何一个正整数 n，都必须循环 n 次，这样才能输出 n 行。因此，必须写一个 for循环， 在循环中定义一个变量 i，让 i 变量从 1 循环到 n；而在循环中每一轮循环都输出第 i行。这样，经过 n 次循环，最终会输出 n 行。

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1; i<=n; i++){
for(int j = 1; j<=i; j++){
System.out.print("*");
}
System.out.println();
}

1
2
3
4
5
6
7
8
9
10
有了多重循环之后， break 和 continue 语句就显得更加复杂。我们首先来看一个二重循环的代码：

for(int i = 1; i<=3; i++){
for(int j = 1; j<=4; j++){
System.out.println(“i=” + i + " j= " + j);
}
}

1
2
3
4
5
6
这是一个典型的多重循环。接下来，我们在内层的循环中，增加一个 break 语句。修改后的代码片段如下：

for(int i = 1; i<=3; i++){
for(int j = 1; j<=4; j++){
if (j == 3){
break;
}
System.out.println(“i=” + i + " j= " + j);
}
}
1
2
3
4
5
6
7
8
默认情况下， break 语句只能跳出一层循环。如果 break 语句在内层循环中，则只能跳出内层循环，而无法直接跳出外层循环。与 break 语句类似， continue 语句在默认情况下，也只能对内层循环执行 continue。

那么如何跳出多重循环呢？java提供了一个标签机制，我们为不同的循环添加不同的lable，如果想要结束指定的循环，直接break或者continue到指定名称的lable即可！

outer:for(int i = 1; i<=3; i++){
for(int j = 1; j<=4; j++){
if (j == 3) {
break outer;
}
System.out.println(“i=” + i + " j= " + j);
}
}
1
2
3
4
5
6
7
8
四、数组

4.1，数组的创建：

数组的创建可以分为两种方式：
第一种方式（以int类型数组为例）：

int[] a ;		//数组声明
a = new int[3] ; 	//数组初始化

1
2
第二种方式：

int [] a = new int[3] ;
1
注意：
数组在创建的时候 [ ] 的位置可以写在类型的后
面，也可以写在变量的后面，例如：

int a[] = new int[3];
1
二者效果相同；

定义一个数组，就是一次性定义多个同类型的变量。
为数组分配完空间之后，就可以使用数组了。使用数组的时候，应当用下标来表示数组元素。例如，上面分配了长度为 3 个 int 类型的变量，这 3 个 int 变量分别可以用： a[0]、a[1]、 a[2]来表示。
需要注意的是，数组的下标从 0 开始，也就是说，如果分配了一个长度为 n 的数组，则数组的下标范围为 0~n-1。

有了下标之后，就可以操作数组元素。此时，数组的每个元素和普通的 int 变量没有区
别。例如：

a[0] = 10; //对数组元素进行赋值
a[1] = 20;
a[2] = 30;
System.out.println(a[2]); //输出数组元素
1
2
3
4
而如果对数组进行下标操作时，超出了数组下标正常的范围，则 Java 会产生一个异常：
ArrayIndexOutOfBoundsException。

4.2，遍历数组：
所谓遍历数组，指的是把数组的所有元素访问一遍，不重复也不遗漏，这是数组中最常用的操作之一。 最典型的遍历数组，就是把数组中的所有元素都打印一遍。例如，我们写一个打印数组 a 的程序：

int[] a = new int[3];
a[0] = 10;
a[1] = 20;
a[2] = 30;
for(int i = 0; i<3; i++){
System.out.print(a[i] + “\t”);
}

1
2
3
4
5
6
7
8
上面的程序就能完成打印 a 数组中每个元素的功能，利用一个 for 循环，就能够完成数组的遍历。 需要强调的是， for 循环中，循环条件是 i < 3，这表明 i变量的变化是 0~2，正好在数组的下标范围之内。 可以看到，3 正好是数组的长度，但是有的时候我们无法获取到数组的长度，此时我们可以使用java提供的“数组名.length”的方式获得数组的长度。举例来说，如果想要获得 n 数组的长度，则可以使用 n.length 这个变量来获得长度。

需要注意的是， n.length 这种写法只能读取数组的长度，而不能修改。也就是说，不能为 n.length 这种变量进行赋值，否则会产生一个编译时错误。

4.3，数组的初始化：

int[] a = new int[3];
for(int i = 0; i System.out.print(a[i] + “\t”);
}

1
2
3
4
5
注意，在分配完三个 int 变量之后，并没有为这三个变量赋值。也就是说，此时，这三个变量并没有被赋初始值而是直接进行了遍历；遍历的结果会发现，输出为三个0；因此，我们可以得出结论： 数组元素和局部变量不同，数组元素可以在没有赋初始值的情况下就使用。此时，这些数组元素也有特定的值，这就是元素的“默认值”。在为数组分配空间的时候，数组的元素会被 JVM 赋予默认值。

那么元素的默认值都是什么呢？这需要根据不同类型来看。对于基本类型来说，默认值为各种各样的 0。怎么来理解呢？ byte、 short、 int、 long 这四种整数类型，默认值为 0；float 和 double 这两种小数类型，默认值为 0.0， boolean 默认值为 false， char 默认值也为0。 注意， char 类型的 0 不是指的字符‘0’，而是指的编码为 0。对于对象类型的数组来说，默认值为 null。

有了默认值这个概念，考虑下面的代码：

int[] a = new int[3];
a[0] = 10;
a[1] = 20;
a[2] = 30;
1
2
3
4
在这段代码中，每一个数组元素都被赋值了两次：一次是默认值，另一次是初始值 10、20、 30。那有没有什么办法能够避免那一次不必要的默认值呢？
我们可以使用一个叫做“数组的显式初始化”的语法。这种语法有两种形式。第一种形式如下：

int[] a = {10, 20, 30};
1
这种语法的特点是，只能在定义数组变量的同时使用。如果代码如下：

int[] a;
a = {10, 20, 30};
1
2
上面的代码在数组定义之后没有直接进行显式初始化，而是换了一个语句又一次赋值。这样会产生一个编译时错误；

第二种语法形式如下：

int[] a = new int[]{10, 20, 30};
1
注意，这种语法下， new 关键字后面的方括号中没有数字，也就是说，显式初始化时不能规定数组长度，数组长度由后面的元素个数决定。要注意的是，这种语法形式能够用来在定义数组之后，为数组进行赋值。也就是说，下面的代码可以编译通过：

int[] a;
a = new int[]{10, 20, 30};
1
2
4.4，二维数组：

4.4.1，二维数组简介：
上面我们介绍的都是一维数组， 接下来要介绍的是 Java 中的二维数组以及多维数组。在 Java 中，所谓的多维数组指的是：数组的数组。怎么来理解这一点呢？比如说，我们日常生活中的抽屉，我们可以认为抽屉就是用来存放多个物品的，因此抽屉就是一个物品的数组。而一个柜子中，可以存放多个抽屉，因此我们可以理解为，柜子就是抽屉组成的数组。因此，柜子就可以理解为是“数组的数组”，也就是：柜子的元素是抽屉，而抽屉本身又是一个数组。那在代码方面怎么表示呢？我们首先来看二维数组的创建和遍历。

4.4.2，二维数组创建：
二维数组在创建时，也需要一个数组变量。定义数组变量，可以使用下面的代码：

int[][] a; 或者 int[] a[]; 或者 int a[][];
1
可以看出，定义数组变量在 Java 中格式是非常自由的。 需要注意的是，在定义二维数组变量的时候，同样没有分配数组空间。如果要为二维数组分配内存空间，则可以使用下面的代码：

a = new int[3][4];
1
这表示，分配一个三行四列的二维数组。怎么来理解“行”和“列”呢？我们可以这么来看：我们分配的这个二维数组就相当于一个柜子，这个柜子有三层，每层放一个抽屉。这个抽屉里面分成了四个格子，每个格子又能放一个元素。 由于二维数组是“数组的数组”，因此，二维数组的“行”，指的是这个二维数组中，包含几个元素。 由于二维数组的元素是一维数组，因此，“行”也就是二维数组中包含几个一维数组。而列，则指的是，二维数组中的每一个一维数组，各自都包含几个元素，如果要获得第 0 行第 2 列的元素，则可以使用双下标：_ a[0][2]_来获得。

4.4.3，二维数组的遍历：
遍历二维数组时，要获得行和列两个数值。首先，二维数组同样有 a.length 这样的变量，而使用 a.length 获得的长度，是二维数组元素的个数，也就是行的数目，也可以理解成：柜子里抽屉的个数。 而列的数目， 就相当于是每一个一维数组的长度，也可以理解为，是每一个抽屉的大小。对于第 i 个抽屉，我们可以使用
a[i].length 来获得它的长度。遍历二维数组的代码如下：

for(int i = 0; i for(int j = 0; j System.out.print(a[i][j] + “\t”);
}
System.out.println();
}

1
2
3
4
5
6
7
4.4.4，初始化：

int[][] a = {
{1,2,3},
{4,5,6},
{6,7,8}
};
1
2
3
4
5
可以看到，这个二维数组 a，本身有三个元素。这三个元素都是数组，因此这三个元素都要加上花括号。元素和元素之间用逗号隔开，因此，三个花括号之间，用逗号隔开。每一个花括号表示一个数组，在这三个元素中，分别表示三个数组：
第一个数组： {1， 2， 3}
第二个数组： {4， 5， 6}
第三个数组： {6， 7， 8}

与一维数组类似，二维数组也有两种显式初始化的语法。除了我们上面介绍的初始化语法之外，二维数组还能用下面的方式显式初始化：

int[][] a;
a = new int[][]{
{1,2,3},
{4,5,6}
};

1
2
3
4
5
6
引申：冒泡排序
排序，是数组操作中一个非常重要的部分。排序要完成的工作，就是把数组中的所有元素，进行位置上的调整，最终使得所有元素的排列都符合一定的顺。例如，有如下数组：

int[] a = {5,7,1,3,2};

//经过排序之后，希望 a 数组的值变为：
{1， 2， 3， 5， 7}

1
2
3
4
五、函数

函数是计算机编程中非常重要的部分，是编程中最基本的元素之一。函数表示的是一种通用的过程，这种过程能够对外界提供服务。例如，现实生活中， ATM 取款机上有不同的功能，我们可以理解为 ATM 机上具有不同的函数可以调用；我们在 ATM 机上取钱，就可以理解为我们在 ATM 机上调用了“取钱”函数。在这种关系中，我们是“取钱”函数的调用者，“取钱”函数为我们提供服务。

5.1，函数的三要素：
对于函数而言，最重要的部分就是函数的三要素：返回值、函数名、参数表。
返回值，这个概念表示调用函数之后，函数会返回什么数据给调用者；
函数名，顾名思义，这表示函数的名字；
参数表，表示调用函数时所给的参数是什么，也就是说，调用函数时需要给函数哪些“输入”。

以“取钱”函数为例，函数的返回值为“钱”，我们作为调用者调用“取钱”函数，目的就是获得这个函数的返回值“钱”；这个函数的参数表表示我们对调用“取钱”时应该给这个函数传递的参数，取钱时需要“银行卡、密码、取款金额”等一系列参数。
在 Java 中，函数（Function）也被称之为方法（Method）。 Java 中并不区分这两个概念，因此，本书中“函数”和“方法”指的是同一个意思。

5.2，函数的定义：
在 Java 中，函数定义的位置为：类的里面，其他函数的外面。

在 Java 中定义一个函数时，首先可以先写两个单词： public static。这两个单词为 Java中的修饰符。加上这两个修饰符是为了能在主函数中正常的调用。

在 public static 之后，就是函数的三要素。 假设我们要写一个 add 函数，该函数接受两个 int 类型作为参数，并且返回这两个参数的和。 这样，可以定义 add 函数如下：

public static int add(int a, int b)
1
第一个 int 为返回值类型，表示 add 函数返回一个 int 值。 add 是函数名， add 后面的圆括号是参数表。

参数表中，可以定义 0 个或多个参数。 在函数参数表中定义的参数，被称为“形式参数”，简称形参。从语法上说， 形参是特殊的局部变量。一方面，在参数表中定义形参，就好像定义局部变量一样，应当写出变量的类型和变量名。另一方面，在形参也有其作用范围，形参的作用范围就是函数的内部。例如，在上面的代码中，我们定义了 a 和 b 两个形参，这两个形参的作用范围就是 add 函数内部。如果调用一个函数时不需要参数，则参数表为空，在圆括号中什么内容都不写即可。

在 add 函数中，包括一个“return c”的语句。这个语句是 return 语句，表示函数的返回值是什么。在 add 函数中， return c 表示返回值为 c 变量的值。return 语句除了表示函数返回值之外，同样可以表示函数的流程跳转。

5.3，函数的调用：
写完 add 函数之后，就能够在主函数里面对其进行调用。例如：

int m = 10, n = 20;
int result = add(m, n);

1
2
第 2行。在这一行中，我们把 add 函数作为赋值语句的一部分，因此会先调用 add 函数，然后把 add 函数的返回值赋值给 result 变量。在调用函数时，需要给出函数名和参数表。这里， m 和 n 是传递给 add 函数的参数，被成为实际参数，简称“实参”。实参指的是，在调用函数的时候，为函数指定的参数。、

最后，函数返回时， 将计算所得的值返回。这个返回值又被赋值给 result 变量。 这样就完成了一次函数的调用。

5.4，return语句：

在函数的定义中，如果给出了返回值类型，则必须要返回一个相应类型的值。例如，由于在函数的定义中， add 函数返回值类型为 int。因此，在 add 函数的中必须要返回一个int 类型的值；return 语句返回的值，如果与函数定义中的返回值类型不同，也有可能出错。

return 语句除了能够返回值之外，还能够控制流程的跳转。具体的说，在执行 return 语句的时候，被调用的函数会终止执行，并返回到函数的调用点上。

5.5，函数的嵌套调用：

public class TestNestedCall{
public static void main(String args[]){
System.out.println(“main1”);
ma();
System.out.println(“main2”);
}
public static void ma(){
System.out.println(“ma1”);
mb();
System.out.println(“ma2”);
}
public static void mb(){
System.out.println(“mb1”);
System.out.println(“mb2”);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
在我们的这个例子中，主函数调用ma 函数， ma 调用 mb 函数，示意图如下：
main–>ma–>mb

作者：归家Com
来源：CSDN
原文：https://blog.csdn.net/weixin_43889638/article/details/84839588
版权声明：本文为博主原创文章，转载请附上博文链接！