码云 Java的流程控制语句
这节将带大家一起来学习一下 Java 的流程控制语句，在学习这篇文章前推荐大家先看一下《Java 中常用的运算符》一文。
Java 条件语句之 if
生活中，我们经常需要先做判断，然后才决定是否要做某件事情。例如，如果考试成绩大于 90 分，则奖励一个 IPHONE XS 。对于这种“需要先判断条件，条件满足后才执行的情况”，就可以使用 if 条件语句实现。
语法：
if(条件){
条件成立时执行的代码
}
执行过程：
例如：
int score = 92;
if(score > 90){
System.out.println("奖励一个 IPHONE XS");
}
注意哦：如果 if 条件成立时的执行语句只有一条，是可以省略大括号滴！但如果执行语句有多条，那么大括号就是不可或缺的喽~~
Java 条件语句之 if…else
if…else 语句的操作比 if 语句多了一步: 当条件成立时，则执行 if 部分的代码块； 条件不成立时，则进入 else 部分。例如，如果考试成绩大于 90 分，则奖励一个 IPHONE 5S ，否则罚做 500 个俯卧撑。
语法：
if(条件的布尔表达式){
代码块一
}else{
代码块二
}
执行过程：
例如：
int age=25;
if(age>=18){
System.out.println("成年");
}else{
System.out.println("未成年");
}
Java 条件语句之多重 if
多重 if 语句，在条件 1 不满足的情况下，才会进行条件 2 的判断；当前面的条件均不成立时，才会执行 else 块内的代码。例如，如果考试成绩大于 90 分，则奖励一个 IPHONE 5S ，如果成绩介于 70 分至 90 分之间，则奖励一个红米，否则罚做 500 个俯卧撑。
语法：
if(条件 1){
代码块 1
}else if(条件 2){
代码块 2
}else{
代码块 3
}
执行过程：
例如：
int age = 25;
if(age > 60){
System.out.println("老年");
}else if(age > 40){
System.out.println("中年");
}else if(age > 18){
System.out.println("少年");
}else{
System.out.println("童年");
}
该段代码的含义是：假设年龄大于 60 岁，则提示“老年”；如果年龄介于 40 岁至 60 岁之间，则提示“中年”；如果年龄介于 18 岁至 40 岁之间，则提示“少年”； 18 岁以下则提示“童年”。
当需要判断的条件是连续的区间时，使用多重 if 语句是非常方便滴！
Java 条件语句之嵌套 if
嵌套 if 语句，只有当外层 if 的条件成立时，才会判断内层 if 的条件。例如，活动计划的安排，如果今天是工作日，则去上班，如果今天是周末，则外出游玩；同时，如果周末天气晴朗，则去室外游乐场游玩，否则去室内游乐场游玩。
语法：
if(条件 1){
if(条件 2){
代码块 1
}else{
代码块 2
}
}else{
代码块 3
}
执行过程：
例如：
运行结果为： 去室外游乐场游玩
Java 条件语句之 switch
当需要对选项进行等值判断时，使用 switch 语句更加简洁明了。例如：根据考试的名次，给予前 4 名不同的奖品。第一名，奖励笔记本一台；第二名，奖励 IPAD 2 一个；第三名，奖励移动电源一个；最后一名奖励 U 盘一个。
语法：
switch(表达式){
case 值 1:
执行代码块 1
break;
case 值 2:
执行代码块 2
break;
case 值 3:
执行代码块 3
break;
case 值 n:
执行代码块 n
break;
default:
默认执行的代码
}
执行过程：当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码。
例如：
int num1;//保存考试的名次
switch(num){
case 1:
System.out.println("奖励笔记本一台");
break;
case 2:
System.out.println("奖励 ipad 2 一个");
break;
case 3:
System.out.println("奖励移动电源一个");
break;
default:
System.out.println("奖励 U 盘一个");
}
不得不说的几点小秘密：
1、 switch 后面小括号中表达式的值必须是整型或字符型
2、 case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2
3、 case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束 如
int num1;//保存考试的名次
switch(num){
case 1:
System.out.println("奖励笔记本一台");
case 2:
System.out.println("奖励 ipad 2 一个");
case 3:
System.out.println("奖励移动电源一个");
default:
System.out.println("奖励 U 盘一个");
}
运行结果：
奖励笔记本一台
奖励 ipad 2 一个
奖励移动电源一个
奖励 U 盘一个
4、 可以把功能相同的 case 语句合并起来，如
case 1:
case 2:
System.out.println("奖励 ipad 2 一个");
5、 default 块可以出现在任意位置，也可以省略
Java 循环语句之 while
生活中，有些时候为了完成任务，需要重复的进行某些动作。如参加 10000 米长跑，需要绕 400 米的赛道反复的跑 25 圈。在 Java 中实现功能时，也经常需要重复执行某些代码，例如，我们为了表示“浓烈的爱”，希望输出 1000 行“我爱码云笔记！”。显然，此时重复敲 1000 遍输出语句是不靠谱滴！！那么，有木有好的办法来解决呢？ 有，循环语句！
Java 常用的 3 种循环： while 、 do…while 、 for
咱们先来聊聊 while
语法：
while(判断条件){
循环操作
}
执行过程：
< 1 >、 判断 while 后面的条件是否成立( true / false )
< 2 >、 当条件成立时，执行循环内的操作代码 ，然后重复执行< 1 >、< 2 >， 直到循环条件不成立为止
特点：先判断，后执行
如上面例子：
int i = 1;
while (i <= 1000){
System.out.println("我爱码云笔记");
i++;
}
利用刚学的 while 语句我们实现以下功能：顺序输出 1 ～ 5 这 5 个数字。
实现思路：使用一个变量 i 代表 1 – 5 之间的数字，值从 1 开始，每次循环时输出 i 的值，并且对 i 的值加 1 ，只要 i 小于等于数字 5 就执行该循环
Java 代码：
public class HelloWorld {
public static void main(String[] args) {
int i = 1; // 代表 1 - 5 之间的数字
// 当变量小于等于 5 时执行循环
while ( i <= 5 ) {
// 输出变量的值，并且对变量加 1，以便于进行下次循环条件判断
System.out.println(i);
i++;
}
}
}
输出结果为：
Java 循环语句之 do…while
do…while 循环与 while 循环语法有些类似，但执行过程差别比较大。
语法：
do {
循环操作
} while(判断条件);
执行过程：
<1>、 先执行一遍循环操作，然后判断循环条件是否成立
<2>、 如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止
特点： 先执行，后判断
由此可见，do…while 语句保证循环至少被执行一次！
例如，依然输出 1000 遍“我爱码云笔记”，使用 do…while 的实现代码为：
public class HelloWorld{
public static void main(String[] args){
int i = 1;
do {
System.out.println("我爱码云笔记");
} while(i <= 1000);
}
}
光说不练是“假把式”，让我们来做个练习检验一下吧！
实现功能：计算 50 以内（包括 50 ）的偶数之和
实现思路：首先定义一个变量 sum ，用来保存所有偶数的和，然后定义一个变量 num 代表 1–50 之间的偶数，值从 2 开始，每次循环执行时将 num 的值累加保存在变量 sum 中，并且将 num 值加 2 (偶数嘛，你懂得哈~~)，只要 num 的值在 1–50 之内就重复执行该循环
Java 代码：
public class HelloWorld {
public static void main(String[] args) {
int sum = 0; // 保存 1-50 之间偶数的和
int num = 2; // 代表 1-50 之间的偶数
do {
//实现累加求和
sum = sum +num;
num = num + 2; //每执行一次将数值加 2，以进行下次循环条件判断
} while ( num <= 50 ); // 满足数值在 1-50 之间时重复执行循环
System.out.println(" 50 以内的偶数之和为：" + sum );
}
}
运行结果为： 50 以内的偶数之和为：650
Java 循环语句之 for
Java 的循环结构中除了 while 和 do…while 外，还有 for 循环，三种循环可以相互替换。
语法：
for(循环变量初始化; 循环条件; 循环变量变化){
循环操作
}
执行过程：
<1>、 执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次
<2>、 进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环
<3>、 执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断
<4>、 依次重新执行< 2 >、< 3 >、< 4 >，直到退出循环
特点：相比 while 和 do…while 语句结构更加简洁易读
例如，输出 1000 遍“我爱码云笔记”，使用 for 的实现代码为：
for(int i = 1; i <= 1000; i++){
System.out.println("我爱码云笔记");
}
需要留心的几个小细节：
1、 for 关键字后面括号中的三个表达式必须用 “;” 隔开，三个表达式都可以省略，但 “;” 不能省略。
a. 省略“循环变量初始化”，可以在 for 语句之前由赋值语句进行变量初始化操作，如:
int i = 1;//循环变量 i 在 for 之前赋值
for(; i < 10; i++){//省略初始化变量
System.out.println("I LOVE MYBJ");
}
b. 省略“循环条件”，可能会造成循环将一直执行下去，也就是我们常说的“死循环”现象，如:
for(int i = 0;; i++){//省略循环条件
System.out.println("I LOVE MYBJ");
}
在编程过程中要避免“死循环”的出现，因此，对于上面的代码可以在循环体中使用 break 强制跳出循环（关于 break 的用法会在后面介绍）。
c. 省略“循环变量变化”，可以在循环体中进行循环变量的变化，如：
for(int i = 0; i < 10;){
System.out.println("I LOVE MYBJ");
i++;//在循环体中改变变量 i 的值
}
2、 for 循环变量初始化和循环变量变化部分，可以是使用 “,” 同时初始化或改变多个循环变量的值，如：
for(int i = 1,j = 5; i <= 5; i++,j--){
System.out.println(i + "+" + j + "=" + (i + j));
}
代码中，初始化变量部分同时对两个变量 i 和 j 赋初值，循环变量变化部分也同时对两个变量进行变化，运行结果：
3、 循环条件部分可以使用逻辑运算符组合的表达式，表示复杂判断条件，但一定注意运算的优先级，如：
for(int i = 1; i < 10 && i != 5; i++){
System.out.println(i);
}
代码中，必须同时满足变量 i 小于 10 ，并且 i 不等于 5 时才会进行循环，输出变量 i 的值。
小伙伴们， for 循环的使用你掌握了吗？让我们来检验一下吧。
实现功能：计算 1 到 100 之间不能被 3 整除的数之和
实现思路：定义一个变量 sum 用来保存数据和，定义一个变量 i 代表 1–100 之间的数据，值从 1 开始。通过 for 循环判断 i 是否是 3 的倍数，符合要求的数据保存在 sum 中。
public class HelloWorld {
public static void main(String[] args) {
int sum = 0; // 保存不能被 3 整除的数之和
// 循环变量 i 初始值为 1 ,每执行一次对变量加 1，只要小于等于 100 就重复执行循环
for (int i = 1; i<=100; i++) {
// 变量 i 与 3 进行求模（取余），如果不等于 0 ，则表示不能被 3 整除
if (i % 3 != 0) {
sum = sum + i; // 累加求和
}
}
System.out.println("1 到 100 之间不能被 3 整除的数之和为：" + sum);
}
}
运行结果为： 1 到 100 之间不能被 3 整除的数之和为：3367
Java 循环跳转语句之 break
生活中，我们经常会因为某些原因中断既定的任务安排。如在参加 10000 米长跑时，才跑了 500 米就由于体力不支，需要退出比赛。在 Java 中，我们可以使用 break 语句退出指定的循环，直接执行循环后面的代码。
例如，使用循环输出 1–10 的数值，其中，如果数值大于 2 ，并且为 3 的倍数则停止输出。
实现代码：
public class HelloWorld{
public static void main(String[] args){
for(int i = 1; i < 10; i++){
//判断 i > 2 且为 3 的倍数
if((i > 2) && (i % 3 == 0)){
break;//通过 break 结束循环，执行循环后的语句
}
System.out.println(i);
}
System.out.println("结束啦");
}
}
运行结果：
好记性不如烂笔头，练习时间到！
实现功能：循环将 1 到 10 之间的整数相加，如果累加值大于 20，则跳出循环，并输出当前的累加值。
实现思路：定义一个变量 sum 保存累加值，定义一个变量 i 保存 1 至 10 之间的整数，在循环中进行累加求和，同时判断累加值是否大于 20 ，当大于 20 时输出当前的累加值并退出循环。
Java 代码：
public class HelloWorld {
public static void main(String[] args) {
// 保存累加值
int sum = 0;
// 从 1 循环到 10
for (int i = 1; i <= 10; i++) {
// 每次循环时累加求和
sum = sum + i;
// 判断累加值是否大于 20，如果满足条件则退出循环
if (sum>20) {
System.out.print("当前的累加值为:" + sum);
//退出循环
break;
}
}
}
}
运行结果为： 当前的累加值为：21
Java 循环跳转语句之 continue
continue 的作用是跳过循环体中剩余的语句执行下一次循环。
例如，打印 1–10 之间所有的偶数，使用 continue 语句实现代码为：
for(int i = 1; i <= 10; i++){
//判断 i 是否是偶数
if(i % 2 != 0){
continue;//通过 continue 结束本次循环，直接进行下次循环
}
System.out.println(i);
}
运行结果：
实现功能：求 1 到 10 之间的所有偶数的和。
实现思路：定义一个变量 sum 保存累加值，定义一个变量 i 保存 1 到 10 之间的整数，循环遍历并进行判断，如果 i 不能被 2 整除，则结束本次循环，继续执行下一次循环，否则进行累加求和。
Java 代码：
public class HelloWorld {
public static void main(String[] args) {
int sum = 0; // 保存累加值
for (int i = 1; i <= 10; i++) {
// 如果 i 为奇数,结束本次循环，进行下一次循环
if (i%2 != 0) {
continue;
}
sum = sum + i;
}
System.out.print("1 到 10 之间的所有偶数的和为：" + sum);
}
}
运行结果为： 1 到 10 之间的所有偶数的和为：30
Java 循环语句之多重循环
循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环。在二重循环中，外层循环每执行一次，内层循环要执行一圈。
如下所示：
例如：使用 * 打印长方形：
实现代码为：
//外层循环控制打印的行数
for(int i = 1; i <= 3; i++){
//内层循环控制每行打印的 * 号数
for(int j = 1; j <= 8; j++){
System.out.print("*");
}
//每行打印完毕换行
System.out.println();
}
执行流程：当 i = 1 时，外层循环条件成立，进入内层循环，开始打印第一行内容。此时， j 从 1 开始，循环 8 次，内层循环结束后换行，实现第一行 8 个 * 的输出。接下来返回外层循环 i 变为 2 ，准备打印下一行，依此类推，直到完成长方形的打印。
能搞定二重循环么？测试一下先~~~~
实现功能：使用 * 打印直角三角形
实现思路：上面的图形中，第 1 行有一个 * 号，第 2 行有两个 * 号，第 3 行有三个 * 号，所以可以使用二重循环来实现。其中，外层循环控制行数，内层循环控制每行的 * 号数。同时，我们发现一个规律，当打印每行信息时，内层循环变量的最大值和外层循环变量的值相等。
Java 代码：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("打印直角三角形");
// 外层循环控制行数
for (int i = 1; i <= 3; i++) {
// 内层循环控制每行的*号数
// 内层循环变量的最大值和外层循环变量的值相等
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
// 每打印完一行后进行换行
System.out.println();
}
}
}
运行结果：
print 和 println 的区别
println 打印的时候自带换行，下一次打印时自动换行；print 下一次打印时不换行，具体看你的需求。
编程练习
循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环。在二重循环中，外层循环每执行一次，内层循环要执行一圈。
编程任务：
判断一个数（小于 10 位）的位数。
输入 999，则输出 “它是个 3 位的数！”
Java 代码：
public class HelloWorld{
public static void main(String[] args){
int num = 999;
int count = 0;
do
{
count++;
num=num/10;
}
while(num >0);
System.out.println("它是个" + count + "位的数！");
}
}
运行结果：
它是个 3 位的数！
结束语
以上就是今天为大家带来的 Java 的流程控制语句全部内容，好记性还不如一个烂笔头，下去把文章中的代码例子亲自写几遍，加深一下记忆，时间长了慢慢就会有感觉。接下来内容更精彩，我们将会为大家带来 Java 的数组相关知识。
微信
支付宝码云笔记 » Java的流程控制语句
