【Java基础】Java流程控制语句_java true ? "" :

---

一、选择结构

选择语句有：if条件语句和switch条件语句。

1.if语句

if (条件表达式)
{
    语句块;
}

1
2
3
4
5

默认情况下，if 语句控制着下方紧跟的一条语句的执行。

1. 条件表达式：条件表达式可以是任意一种逻辑表达式，最后返回的结果必须是一个布尔值。取值可以是一个单纯的布尔变量或常量，也可以是使用关系或布尔运算符的表达式。如果条件为真，那么执行语句块；如果条件为假，则语句块将被绕过而不被执行。
2. 语句块：该语句块可以是一条语句也可以是多条语句。如果仅有一条语句，可省略条件语句中的大括号{}。

执行流程：

• 首先判断布尔表达式看其结果是true还是false
• 如果是true就执行语句块
• 如果是false就不执行语句块

举个例子：

比如这样的：
int num=200；
if(num>100)    //判断用户输入的数据是否大于100
System.out.println("输入的数字大于100");
又比如这样的：
String username="admin";    //用户名
String userpass="123456";    //密码
String code="0000";    //验证码
if(username!="admin"&&userpass!="123456"&&code!="0000") //比较
 {
System.out.println("登录失败！");
System.out.println("请检查输入的用户名、密码和验证码是否正确！");
 }
1
2
3
4
5
6
7
8
9
10
11
12
13

2.if…else语句

if …else 语句是指如果满足某种条件就进行某种处理，否则就进行另外一种处理。
语法格式为：

if ( 表达式)
{
    语句块1;
}
else
{
    语句块2;
}

1
2
3
4
5
6
7
8
9

执行流程

• 首先判断布尔表达式看其结果是true还是false
• 如果是true就执行语句块1
• 如果是false就执行语句块2

举个例子：

int num1=50;
int num2=34;
  //如果等于
if(num1==num2) {
System.out.println("num1等于num2");
} 
//如果大于
 if(num1>num2){
 System.out.println("num1大于num2");
 }
  //否则就是小于
else{
System.out.println("num1小于num2");
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.与三元运算符的互换

if…else语句和三元运算符效果是一样的
Java 支持使用条件表达式（又称三目运算符）表达式1 ? 表达式2 : 表达式3 来简化 if else 语句的代码。

表达式 1 的作用等同于 if 语句后面的条件，如果表达式 1 为 true， 则执行 表达式2， 否则执行 表达式3

4.if…else if…else if…else语句

if…else if…else if…else可以对多个条件进行判断，进行多种不同的处理。

if…else if 多分支语句的语法格式如下所示：

if(表达式1)
{
    语句块1;
}
else if(表达式2)
{
    语句块2;
}
...
else if(表达式n)
{
    语句块n;
}
else
{
    语句块n+1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在上述语法格式中，使用 if…else if 语句时，依次判断表达式的值，当某个分支的条件表达式的值为 true 时，则执行该分支对应的语句块，然后跳到整个 if 语句之外继续执行程序。如果所有的表达式均为 false，则执行语句块 n+1，然后继续执行后续程序，其运行流程如图 3 所示。

执行流程

• 首先判断布尔表达式1看其结果是true还是false
• 如果是true就执行语句体1
• 如果是false就继续判断布尔表达式2看其结果是true还是false
• 如果是true就执行语句体2
• 如果是false就继续判断布尔表达式…看其结果是true还是false
  …
• 如果没有任何布尔表达式为true，就执行后面的与语句体。

图3 if…else if 语句的执行流程

举个例子：

int num1=50;
int num2=34;
 //如果等于
if(num1==num2){
System.out.println("num1等于num2");
}
 //如果大于
else if(num1>num2) {
System.out.println("num1大于num2");
}  
 //否则就是小于
else{
System.out.println("num1小于num2");
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5.switch语句

if…else 语句可以用来描述一个“二岔路口”，我们只能选择其中一条路来继续走，然而生活中经常会碰到“多岔路口”的情况。switch 语句提供了 if 语句的一个变通形式，可以从多个语句块中选择其中的一个执行

基本语法形式如下所示：

switch(表达式)
{
    case 值1:
        语句块1;
        break;
    case 值2:
        语句块2;
        break;
    …
    case 值n:
        语句块n;
        break;
    default:
        语句块n+1;
    break;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

其中，switch、case、default、break 都是 Java 的关键字。

• switch：表示“开关”，这个开关就是 switch 关键字后面小括号里的值，小括号里要放一个整型变量或字符型变量。
• switch 语句中的变量类型可以是： byte、short、int、 char 或者 String；
• case：表示“情况，情形”，case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量；例如 10、‘a’。case 块可以有多个，顺序可以改变，但是每个 case 后的常量值必须各不相同。
• default：表示“默认”，即其他情况都不满足。default 后要紧跟冒号，default 块和case 块的先后顺序可以变动，不会影响程序执行结果。通常，default 块放在末尾，也可以省略不写。
• break：表示“停止”，即跳出当前结构。switch 语句在其开始处使用一个简单的表达式。表达式的结果将与结构中每个 case 子句的值进行比较。如果匹配，则执行与该 case 关联的语句块。语句块以 case 语句开头，以 break 语句结尾，然后执行 switch 语句后面的语句。如果结果与所有 case 子句均不匹配，则执行 default 后的语句，其运行流程如图 1 所示。

执行流程

• 首先计算出表达式的值
• 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
• 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

编写一个 Java 程序，根据当前的星期数字输出对应的汉字。在这里使用包含 break 的 switch 语句来判断当前的星期，实现代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String weekDate="";
4.	    Calendar calendar = Calendar.getInstance();
5.	    int week=calendar.get(Calendar.DAY_OF_WEEK)-1;
6.	    switch(week)
7.	    {
8.	        case 0:
9.	            weekDate="星期日";
10.	            break;
11.	        case 1:
12.	            weekDate="星期一";
13.	            break;
14.	        case 2:
15.	            weekDate="星期二";
16.	            break;
17.	        case 3:
18.	            weekDate="星期三";
19.	            break;
20.	        case 4:
21.	            weekDate="星期四";
22.	            break;
23.	        case 5:
24.	            weekDate="星期五";
25.	            break;
26.	        case 6:
27.	            weekDate="星期六";
28.	            break;
29.	    }
30.	    System.out.println("今天是 "+weekDate);
31.	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

本程序首先获取当前的星期值，然后使用 switch 语句判断 week 的值：0 表示星期日，1 表示星期一，2 表示星期二……以此类推，6 表示星期六。只要 week 值与 case 值相符合，则程序将执行该 case 中的语句，并跳出 switch 语句，输出结果。

运行程序，输出的结果如下：

今天是星期三
1

注意事项

• 表达式中的值要与case中的值数据类型一致。
• 在switch中的表达式只能是byte、short、int、char、Enum(枚举值)、String(字符串)。用其它的类型值编译会报错。
• break不能漏写,否则会出现case的穿透，改变逻辑。

if 语句和 switch 语句的区别

一般情况下，对于判断条件较少的，可以使用 if 条件语句，但是在实现一些多条件的判断中，最好使用 switch 语句，因为判断的分支越多，用switch效率越高。

二、循环结构

在Java语言中，有一种特殊的语句叫做循环语句，可以实现代码的重复执行，这种由循环语句形成的结构就是循环结构。

1.for循环

for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。for 语句通常使用在知道循环次数的循环中。

for 语句语法格式如下所示：

for(条件表达式1;条件表达式2;条件表达式3)
{
语句块;
}

1
2
3
4
5

for 循环中 3 个条件表达式的含义如表 1 所示。

• for 关键字后面括号中的3 个条件表达式必须用“;”隔开。for 循环中的这 3 部分以及大括号中的循环体使循环体必需的 4 个组成部分完美地结合在一起，简单明了。
• for 循环语句执行的过程为：首先执行条件表达式 1 进行初始化，然后判断条件表达式 2 的值是否为 true，如果为 true，则执行循环体语句块；否则直接退出循环。最后执行表达式 3，改变循环变量的值，至此完成一次循环。接下来进行下一次循环，直到条件表达式 2 的值为 false，才结束循环，其运行流程如图 1 所示。

举个例子：
例如，计算 5 的阶乘，使用 for 循环的实现代码如下：

1.	public static void main(String[] args)
2.	{
3.	int result=1;
4.	for(int number=1;number<=5;number++)
5.	{
6.	result*=number;
7.	}
8.	System.out.print("5 的阶乘结果是："+result);    //输出"5的阶乘结果是：120"
9.	}

1
2
3
4
5
6
7
8
9
10

上述语句的含义可以理解为，将 number 变量的值从 1 开始，每次递增 1，直到大于 5 时终止循环。在循环过程中，将number 的值与当前 result 的值进行相乘。

for 语句中的 3 个条件表达式并不是必须存在的，它们可以部分为空，也可以全为空。下面对这些情况依次进行介绍。

1．条件表达式 1 为空
for 语句中条件表达式 1 的作用可以在程序的其他位置给出，所以当条件表达式 1 为空时，for 语句后面括号内其他条件表达式执行的顺序不变。
例如，使用 for 语句的这种形式计算 1~100 所有奇数的和。

1.	public static void main(String[] args)
2.	{
3.	int result=0;
4.	int number=1;    //相当于for 语句的第1 个表达式
5.	for(;number<101;number++)
6.	{
7.	if(number%2!=0)    //如果不能整除2，说明是奇数，则进行累加
8.	result+=number;
9.	}
10.	System.out.print("100 以内所有奇数和为："+result);
11.	}
执行后的输出结果如下：

100 以内所有奇数和为：2500
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2．条件表达式 2 为空

当 for 语句中条件表达式 2 为空时，将没有循环的终止条件。此时 for 语句会认为条件表达式 2 的值总是为真，循环无限制执行下去。因此，为了使循环达到某种条件时退出，需要在语句块中进行逻辑判断，并使用 break 语句来跳出循环，否则将产生死循环。
同样是计算 1~100 所有奇数的和，使用这种方式的代码如下。

1.	public static void main(String[] args)
2.	{
3.	int result=0;
4.	for(int number=1; ;number++)
5.	{
6.	if(number>100)break;    //相当于for语句的表达式2，满足时就退出for循环
7.	if(number%2!=0)    //如果不能整除2，说明是奇数，则进行累加
8.	result+=number;
9.	}
10.	System.out.print("100 以内所有奇数和为："+result);
11.	}

1
2
3
4
5
6
7
8
9
10
11
12

3．条件表达式 3 为空
当 for 语言中条件表达式 3 为空时，也就没有设置控制变量的表达式，即每次循环之后无法改变变量的值，此时也无法保证循环正常结束。
同样是计算1~100 所有奇数的和，使用这种方式的代码如下：

1.	public static void main(String[] args)
2.	{
3.	int result=0;
4.	for(int number=1;number<101;)
5.	{
6.	if(number%2!=0)    //如果不能整除2，说明是奇数，则进行累加
7.	result+=number;
8.	number++;    //相当于for语句的条件表达式3，每次递增1
9.	}
10.	System.out.print("100 以内所有奇数和为："+result);
11.	}

1
2
3
4
5
6
7
8
9
10
11
12

如果没有循环体语句，number 变量的值为 1，永远小于 101，因此将无法结束循环，形成无限循环。在上面代码中将number 的递增语句放在for 循环体内，效果与完整 for 语句功能相同。

4．3 个条件表达式都为空

在 for 循环语句中，无论缺少哪部分条件表达式，都可以在程序的其他位置补充，从而保持 for 循环语句的完整性，使循环正常进行。
当 for 语句中循环体全为空时，即没有循环初值，不判断循环条件，循环变量不增值，此时无条件执行循环体，形成无限循环或者死循环。对于这种情况，读者在使用时应该尽量避免。

例如，计算 1~100 所有奇数的和，使用这种方式的代码如下：

1.	public static void main(String[] args)
2.	{
3.	int result=0;
4.	int number=1;    //相当于for语句的条件表达式1
5.	for(;;)
6.	{
7.	if(number>100)
8.	break;    //相当于for语句的条件表达式2
9.	if(number%2!=0)    //如果不能整除2，说明是奇数，则进行累加
10.	result+=number;
11.	number++;    //相当于for语句的条件表达式3
12.	}
13.	System.out.print("100 以内所有奇数和为： "+result);
14.	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.while循环

while 循环语句可以在一定条件下重复执行一段代码。该语句需要判断一个测试条件，如果该条件为真，则执行循环语句（循环语句可以是一条或多条），否则跳出循环。

while 循环语句的语法结构如下：

while(条件表达式)
{
    语句块;
}

1
2
3
4
5

其中语句块中的代码可以是一条或者多条语句，而条件表达式是一个有效的 boolean 表达式，它决定了是否执行循环体。当条件表达式的值为 true 时，就执行大括号中的语句块。

执行完毕，再次检查表达式是否为 true，如果还为 true，则再次执行大括号中的代码，否则就跳出循环，执行 while 循环之后的代码。图 1 表示了while 循环语句的执行流程。

举个例子：
使用 while 语句计算 10 的阶乘，其具体代码如下所示。

1.	public static void main(String[] args)
2.	{
3.	    int i=1;
4.	    int n=1;
5.	    while(i<=10)
6.	    {
7.	        n=n*i;
8.	        i++;
9.	    }
10.	    System.out.println("10的阶乘结果为："+n);
11.	}

运行程序，执行的结果如下所示：
10 的阶乘结果为：3628800
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在上述代码中，定义了两个变量 i 和 n，循环每执行一次 i 值就加 1，判断 i 的值是否小于等于 10，并利用 n=n*i 语句来实现阶乘。当 i 的值大于 10 之后，循环便不再执行并退出循环。

3.do…while循环语句

do…while 循环语句也是 Java 中运用广泛的循环语句，它由循环条件和循环体组成，但它与 while 语句略有不同。do…while 循环语句的特点是先执行循环体，然后判断循环条件是否成立。

do…while 语句的语法格式如下：

do
{
    语句块;
}while(条件表达式);

1
2
3
4
5

以上语句的执行过程是，首先执行一次循环操作，然后再判断 while 后面的条件表达式是否为 true，如果循环条件满足，循环继续执行，否则退出循环。while 语句后必须以分号表示循环结束，其运行流程如图 2 所示。

注意：
do…while 语句与 while 语句唯一的区别在于，不管表达式的结果为真还是为假，循环语句至少执行一次。因此 do…while 循环适合于至少执行一次循环体的情况。

举个例子：
编写一个程序，计算 10 的阶乘。使用 do…while 循环的实现代码如下所示。

1.	public static void main(String[] args)
2.	{
3.	    int number=1,result=1;
4.	    do
5.	    {
6.	        result*=number;
7.	        number++;
8.	    }while (number<=10);
9.	    System.out.print("10阶乘结果是："+result);
10.	}

程序运行后输出结果如下：
10 阶乘结果是：3628800

1
2
3
4
5
6
7
8
9
10
11
12
13
14

提示
while 循环和 do…while 循环的相同处是：都是循环结构，使用 while(循环条件) 表示循环条件，使用大括号将循环操作括起来；不同处如下。

• 语法不同：与 while 循环相比，do…while 循环将 while 关键字和循环条件放在后面，而且前面多了 do 关键字，后面多了一个分号：“ ；”。
• 执行次序不同：while 循环先判断，再执行。do…while 循环先执行，再判断。
• 一 开始循环条件就不满足的情况下，while 循环一次都不会执行，do…while 循环则不管什么情况下都至少执行一次。

4.foreach 循环语句

foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

foreach 循环语句的语法格式如下：

for(类型 变量名:集合)
{
    语句块;
}

1
2
3
4
5

其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素，其执行流程如图 1 所示。

举个例子：
在一个字符串数组中存储了几种编程语言，现在将这些编程语言遍历输出。

1.	public static void main(String[] args)
2.	{
3.	    String[] languages={"Java","ASP.NET","Python","C#","PHP"};
4.	    System.out.println("现在流行的编程语言有：");
5.	
6.	    //使用 foreach 循环语句遍历数组
7.	    for(String lang:languages)
8.	    {
9.	        System.out.println(lang);
10.	    }
11.	}
该程序运行后的结果如下所示：

现在流行的编程语言有：
Java
ASP.NET
Python
C#
PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在循环体执行的过程中，每循环一次，会将 languages 数组中的一个元素赋值给 lang 变量，直到遍历 languages 数组中所有元素，循环终止。

5.break语句

在 Java 中，break 语句有 3 种作用，分别是：

1. 在 switch 语句中终止一个语句序列
2. 使用 break 语句直接强行退出循环
3. 使用 break 语句实现 goto 的功能

1.在 switch 语句中终止一个语句序列
在 switch 语句中终止一个语句序列，就是在每个 case 子句块的最后添加语句“break;”
2.使用 break 语句直接强行退出循环（break 不带标签）
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。

使用 break 语句直接强行退出循环的示例如下：

public class test2 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in); // 定义变量存储小明的回答
		String answer = ""; // 一圈100米，1000米为10圈，即为循环的次数
		for (int i = 0; i < 10; i++) {
			System.out.println("跑的是第" + (i + 1) + "圈");
			System.out.println("还能坚持吗？"); // 获取小明的回答
			answer = input.next(); // 判断小明的回答是否为y？如果不是，则放弃，跳出循环
			if (!answer.equals("y")) {
				System.out.println("放弃");
				break;
			}
		}
		// 循环之后的代码
		System.out.println("加油！继续！");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果为：

尽管 for 循环被设计为从 0 执行到 10，但是当小明的回答不是 y 时，break 语句终止了程序的循环，继续执行循环体外的代码，输出“加油！继续！”。

• break 语句能用于任何 Java循环中，包括人们有意设置的无限循环。在一系列嵌套循环中使用 break 语句时，它将仅仅终止最里面的循环。例如：

public class test2 {
	public static void main(String[] args) {
		// 外循环，循环5次
		for (int i = 0; i < 5; i++) {
			System.out.print("第" + (i + 1) + "次循环：");
			// 内循环，设计为循环10次
			for (int j = 0; j < 10; j++) {
				// 判断j是否等于3，如果是，则终止循环
				if (j == 3) {
					break;
				}
				System.out.print("内循环的第" + (j + 1) + "次循环\t");
			}
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果为：

从程序运行结果来看，在内部循环中的 break 语句仅仅终止了所在的内部循环，外部循环没有受到任何的影响。

注意：一个循环中可以有一个以上的 break 语句，但是过多的 break 语句会破坏代码结构。switch 循环语句中的 break 仅影响 switch 语句，不会影响循环。

3.使用 break 语句实现 goto 的功能（break 带标签）
break label 标签语句，主要是用于跳出外层循环，而break只能跳出当前循环。
break 语句可以实现 goto 的功能，并且 Java 定义了 break 语句的一种扩展形式来处理退出嵌套很深的循环这个问题。

通过使用扩展的 break 语句，可以终止执行一个或者几个任意代码块，这些代码块不必是一个循环或一个 switch 语句的一部分。同时这种扩展的 break 语句带有标签，可以明确指定从何处重新开始执行。

break 除了具有 goto 退出深层循环嵌套作用外，还保留了一些程序结构化的特性。

标签 break 语句的通用格式如下：

break label;
1

label 是标识代码块的标签。当执行这种形式的 break 语句时，控制权被传递出指定的代码块。被加标签的代码块必须包围 break 语句，但是它不需要直接包围 break 的块。也就是说，可以使用一个加标签的 break 语句来退出一系列的嵌套快，但是不能使用 break 语句将控制权传递到不包含 break 语句的代码块。

用标签（label）可以指定一个代码块，标签可以是任何合法有效的 Java 标识符，后跟一个冒号。加上标签的代码块可以作为 break 语句的对象，使程序在加标签的块的结尾继续执行。

下面是使用带标签的break 语句的示例：

public class test2 {
	public static void main(String[] args) {
		label: for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 8; j++) {
				System.out.println(j);
				if (j % 2 != 0) {
					break label;
				}
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果为：

这里的 label 是标签的名称，可以为 Java 语言中任意合法的标识符。标签语句必须和循环匹配使用，使用时书写在对应的循环语句的上面，标签语句以冒号结束。如果需要中断标签语句对应的循环，可以采用 break 后面跟标签名的方式。
如在上面代码中，当 j 为 1 时，“j%2!=0”条件表达式成立，则 label 标签所代表的最外层循环终止。

再例如：
在闹钟定时，就可以使用到这个：

6.continue语句

continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。

continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。

注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。
举个例子：
循环录入 Java 课程的学生成绩，统计分数大于 80 分（包括等于）的学生人数。这时，需要定义变量 count 记录大于 80 分（包括等于）的学生人数，每循环一次，需要判断录入的学生分数是否大于等于 80，如果是，则执行 count+1，否则执行 continue，跳过本次循环，继续下次循环。代码如下：

public class test2 {
	public static void main(String[] args) {
		int score = 0; // 记录课程的分数
		int count = 0; // 记录成绩大于等于80分的人数
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < 5; i++) {
			System.out.println("请输入第" + (i + 1) + "位学生的Java成绩：");
			score = input.nextInt(); // 获取用户录入的学生成绩
			if (score < 80) // 判断用户录入的学生成绩是否小于80
			{
				continue; // 如果小于80，跳过本次循环，继续下次循环
			}
			count++; // 如果用户录入的分数大于等于80，则人数加1
		}
		System.out.println("Java 成绩在 80 分以上的学生人数为：" + count);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

执行结果为：

在该程序中，变量 count 表示 80 分以上的学生人数。for 循环从 0 开始循环，循环 5次，可以理解为班里只有 5 个学生，需要录入 5 个学生的成绩。

每循环一次都需要录入一次学生的成绩，同时需要判断用户录入的学生成绩是否小于 80 分，如果小于 80 分，则跳出本次循环，即“count++”不执行，大于 80 分的人数不累加，然后执行下一次循环。只有当“score<80”的条件表达式不成立时，才执行“count++”。

7.return 语句

return 语句用于终止函数的执行或退出类的方法，并把控制权返回该方法的调用者。如果这个方法带有返回类型，return 语句就必须返回这个类型的值；如果这个方法没有返回值，可以使用没有表达式的 return 语句。
return 语句的一般语法格式如下：

return 与方法相同类型的变量;
1

如果一个方法使用了 return 语句并且后面跟有该方法返回类型的值，那么调用此方法后，所得到的结果为该方法返回的值。
举个例子：
当用户输入两个 double 类型的数值后需要计算这两个数值之和，而这两个操作数是可以变动的，但是求和的功能是不变的，这时就需要定义一个方法，只要在需要求和时调用该方法即可，该方法将计算之后的结果返回。代码如下：

public class test2 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入操作数1：");
		double num1 = input.nextDouble(); // 获取用户输入的操作数1
		System.out.println("请输入操作数2：");
		double num2 = input.nextDouble(); // 获取用户输入的操作数2
		double d = sum(num1, num2);
		System.out.println(num1 + "+" + num2 + "=" + d);
	}

	/**
	 * 创建sum() 方法，返回double 类型的数值
	 * 
	 * @param i 操作数1
	 * @param j 操作数2
	 * @return 两个操作数之和
	 */
	public static double sum(double i, double j) {
		double sum = i + j;
		return sum;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

当用户输入两个 double 类型的数值后，程序调用 sum() 方法。该方法有两个参数，分别表示用户输入的操作数 1 和操作数 2。在调用该方法时，只需要将用户输入的两个数值传递过去即可，然后程序会执行 sum() 方法，对这两个数求和，并使用 return 语句将计算得出的结果返回。
在 main() 方法中，同样需要使用 double 类型的变量来接收 sum() 方法返回的值，即变量 d 为计算后的结果。

执行的结果为：

总结

各位小主，如果感觉有一点点帮助到你的话，麻烦留下赞赞一枚哦~