流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。

所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

 

 

流程控制语句分类

顺序结构

选择结构

循环结构

 

 

顺序结构

 

顺序结构概述

是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

总的来说：写在前面的先执行，写在后面的后执行。

 

 

 

选择结构

 

选择结构也被称为分支结构。

选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，

所以产生选择，按照不同的选择执行不同的代码。

 

Java语言提供了两种选择结构语句

if语句

switch语句

 

选择结构(if语句)

if语句有三种格式

if语句第一种格式：

if(关系表达式) {

语句体

}

 

执行流程

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体

如果是false就不执行语句体

 

 

 

注意事项：
1、如果在关系表达式小括号后面加上了一个分号，说明if语句结束
默认存在一个空语句体
2、括号都是成双成对出现的
3、小括号中关系表达式的结果必须是布尔类型（boolean类型）

 

示例

 

public class IfDemo1 {
public static void main(String[] args) {
System.out.println("程序开始执行");
int a = 12;

if(a == 10) {
System.out.println("a的值是10");
}

System.out.println("over");

}
}

 

if语句第二种格式：

if(关系表达式) {

语句体1;

}else {

语句体2;

}

 

执行流程

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体1

如果是false就执行语句体2

 

 

 

 

 

举例：
上厕所案例，用键盘录入实现

 

分析：
1、导包
2、创建键盘录入对象
3、键盘录入信息
4、if判断输入的信息是男生还是女生
5、输出

 

//导包
import java.util.Scanner;
public class IfDemo2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//键盘录入信息
System.out.println("请输入你是男生还是女生（男生扣1，女生扣2）");

int i = sc.nextInt();

if(i == 1){
System.out.println("请走男生通道");
}else {
System.out.println("请走女生通道");
}

}
}

 

if语句的第二种格式与三目运算符的关系

注意事项：
1、当if-else格式中的语句体是一条输出语句的时候，不能转换成三目运算符
2、当if-else格式中的语句体不是一条的时候，也不能转换成三目运算符

 

public class IfDemo3 {
public static void main(String[] args) {
int a = 10;
int b = 20;

int res1 = (a > b)?a:b;
System.out.println(res1);

if(a > b){
res1 = a;
a++;
}else {
res1 = b;
b++;
}

System.out.println(res1);

//两者不能转换，情况1

// int res2 = (a > b)?res1=a;a++;:res1=b;b++;

//两者不能转换，情况2
// if(a < b){
// System.out.println("a比b小");
// }else {
// System.out.println("a比b大或者相等");
// }

// (a < b)?System.out.println("a比b小"):System.out.println("a比b大或者相等");

}
}

 

 

if语句的第三种格式：
if(关系表达式1){
语句体1;
}else if(关系表达式2){
语句体2;
}else if(关系表达式3){
语句体3;
}
...
else{
语句体n;
}

 

执行流程

首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式…看其结果是true还是false …

如果没有任何关系表达式为true，就执行语句体n+1。

 

 

 

 

示例

x和y的关系满足如下：
x>=3             y = 2x + 1;
-1<=x<3        y = 2x;
x<=-1            y = 2x - 1;

键盘录入x的值，判断x的范围，执行不同的公式

分析：
1、导包
2、创建键盘录入对象
3、用变量x接收键盘录入的int类型的数据
4、if语句判断执行不同的路径
5、输出

//导包

import java.util.Scanner;

public class IfTest1 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//键盘录入数据
System.out.println("请输入x的值：");
int number = sc.nextInt();
int y = 0;

if (number >= 3) {
y = 2 * number + 1;
} else if (number >= -1 & number < 3) {
y = 2 * number;
} else if (number <= -1) {
y = 2 * number - 1;
} else {
System.out.println("输入的数据有误");
}

System.out.println("y的值为：" + y);

}
}

 

 

if语句的嵌套：

示例

需求：获取三个数据中的最大值

键盘录入改进
//导包
import java.util.Scanner;
public class IfTest3 {
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();

System.out.println("请输入第三个数据：");
int c = sc.nextInt();

if(b > c){
if(b > a){
System.out.println("最大值是b:"+b);
}else {
System.out.println("最大值是a:"+a);
}
}else {
if(c > a){
System.out.println("最大值是c:"+c);
}else {
System.out.println("最大值是a:"+a);
}
}

}
}

 

 

** if  语句的第三种格式可以省略else，但是不建议省略。（省略了就不属于上面的三种格式了）

 

 

程序示例：

import java.util.Scanner;

public class IfDemo {

public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入第一个数：");
int x1 = sc.nextInt();
System.out.println("请输入第二个数：");
int x2 = sc.nextInt();

if (x1 > x2) {
System.out.println("x1是较大的数，值为：" + x1);
} else if (x2 > x1) {
System.out.println("x2是较大的数，值为：" + x2);
}

}

 

 

选择结构(switch语句)

switch语句格式：

switch(表达式) {

case 常量1：

语句体1;

break;

case 常量2：

语句体2;

break;

…

case 常量n:
语句体n;
break;

 

default：

语句体n+1;

break;

}

 

解释分析结构：
1、switch表达式的结果可以是哪些数据类型？(面试题)
表达式的结果可以是：byte,short,int,char。
在JDK1.5以后可以是枚举类型。
在JDK1.7以后可以是String。

 

名词解释：
case: 后面跟的是要和表达式的结果进行比较的值(常量)，如果说匹配到了对应的case的值，

那么就执行相对应的语句体，而且这个语句的部分可以是一条语句，也可以是多条语句。
break: 表示中断的意思，结束的意思，可以结束switch语句。
default: 表示默认的意思，当表达式的结果与所有的case的常量都不匹配的时候，

最后才执行。（与default处在switch语句体的位置无关）

 

 

 

执行流程：
1、计算表达式的值。
2、拿着这个计算好的值与case相对应的值(常量)按照顺序从上往下依次进行比较，如果有相同的值，就开始执行此位置的case中的语句体内容。
3、当语句体的内容执行完毕后，会紧接执行break语句，执行break语句就代表着咱们这个
switch选择结构的结束。(跳出switch选择)
4、当第二步从上往下去匹配case的值的时候，如果没有匹配到相应的值，就会执行default语句中语句体内容，最后跳出switch语句。

 

注意事项：
1、case后面的值不能有重复的。（重复会报错）
2、default语句可以进行省略，一般情况下，不建议删除。
3、case 后面紧跟着的只能是常量，或者常量之间的运算，不能是变量。
4、break语句可以省略，代码也不会报错，一般情况下，不建议省略，
如果你省略了，结果可能不是你想要的结果。
当匹配到break语句省略的那个case的时候，首先会执行对应的语句体，然后从匹配
到的case一直运行到有break语句为止。
5、default语句可以放在任意地方吗？
可以，因为我们的switch语句执行流程是严格按照先在所有的case中进行匹配，当所有
的case都不匹配的时候，最后再去执行default语句，这和你default语句写的顺序没有关系。

 

switch语句与if语句嵌套使用：

程序示例

import java.util.Scanner;
public class SwitchIfDemo1 {
public static void main(String[] args) {

 

//创建键盘录入对象
Scanner sc = new Scanner(System.in);

 

//可乐 3, 旺仔牛奶 5, 红牛 6, 农夫山泉 2, 脉动 4

//键盘录入数据表示身上有多少钱
System.out.println("请输入您身上带了多少钱：");
int money = sc.nextInt();

//switch语句与if语句嵌套使用

if(money>=2 & money<100){
System.out.println("欢迎光临！！！");

switch (money){
case 2:
System.out.println("购买农夫山泉");
break;
case 3:
System.out.println("购买可乐");
break;
case 4:
System.out.println("购买脉动");
break;
case 5:
System.out.println("购买旺仔牛奶");
break;
case 6:
System.out.println("购买红牛");
break;
default:
System.out.println("没有你想要的饮料");
break;
}
}else if(0
System.out.println("您带的钱太少了，下次带多一点");
}else if(money >=100){
System.out.println("随便挑");
}else {
System.out.println("你是个穷鬼，下次再来吧");
}

}
}

 

例题

模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况)

import java.util.Scanner;
public class SwitchTest1 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

System.out.println("题目：你学的怎么样？");
System.out.println("请输入你选择的选项（A/B/C/D）其中一个");
String s = sc.next();

switch (s){
case "A":
System.out.println("A选项：非常好");
break;
case "B":
System.out.println("B选项：很好");
break;
case "C":
System.out.println("C选项：优秀");
break;
case "D":
System.out.println("D选项：无与伦比");
break;
default:
System.out.println("您输入的选项有误");
break;
}

}
}

 

看程序写结果

public class SwitchTest3 {
public static void main(String[] args) {
int x = 2;
int y = 3;
switch (x) {
default:
y++; 
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y=" + y);

}
}

请问输出的y=？？

答案：y=4

程序运行步骤（原因）

1.首先输入的x的值与case后面的值做比较，没有符合的。

2.运行default的语句体y++，然后运行break。跳出switch语句。

 

看程序写结果2

public class SwitchTest4 {
public static void main(String[] args) {
int x = 2;
int y = 3;
switch(x){
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);

}
}

 

请问输出的y=？？

答案：y=6

程序运行步骤（原因）

1.首先输入的x的值与case后面的值做比较，没有符合的。

2.运行default的语句体y++，然后因为没有break。所以没有跳出switch语句。

但是程序穿透运行，按照顺序结构继续执行下面的两个y++。

 

 

循环结构：for循环、while循环、do---while循环。

 

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环

体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，

否则循环将一直执行下去，形成死循环。

 

循环语句的组成

初始化语句：

一条或者多条语句，这些语句完成一些初始化操作。

判断条件语句：

这是一个boolean 表达式，这个表达式能决定是否执行循环体。

循环体语句：

这个部分是循环体语句，也就是我们要多次做的事情。

控制条件语句：

这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

 

循环结构(for循环语句)

for循环语句格式：

for(初始化语句;判断条件语句;控制条件语句) {

循环体语句;

}

 

 

 

执行流程

A:执行初始化语句

B:执行判断条件语句，看其结果是true还是false 如果是false，循环结束。 如果是true，继续执行。

C:执行循环体语句

D:执行控制条件语句

E:回到B继续

 

程序示例

public class ForDemo1 {
public static void main(String[] args) {
   //打印10行HelloWorld
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");

System.out.println("==================用for循环改进==================");

//  int i=1; 初始化值的作用：因为我们要打印10句HelloWorld,从第一次开始，所以
//             我们需要定义一个变量int类型的变量去开始计数，表示第几次循环。
//  i<=10; 条件判断语句，这个语句使用控制是否进入循环的条件。
//  i++ 控制循环体中的条件的变化，在这里表示的是，每循环一次，i++

for(int i=1;i<=10;i++){
System.out.println("HelloWorld");
}

}
}

 

使用for循环的注意事项
1、条件判断语句只能是boolean类型
2、当循环体的语句只有一条的时候，可以省略大括号，
如果循环体的语句有多条的时候，这时候需要添加大括号，如果不添加
循环语句只针对第一条语句有效。（建议，永远不要省略大括号）
3、如果在小括号后加分号，默认有一个空语句体，后面的代码为正常的代码块，不参与循环。
4、初始化语句可以不在for循环中的小括号中体现，但是必须在使用之前定义好。
5、条件判断语句可以删除，但是删除之后，就没有了控制循环结束的条件，就变成了死循环。
6、控制条件语句删除之后，也变成了死循环，你可以删除，但是初始化的变量的值一定
要在循环体中发生变化。

 

死循环示例：
for(  ;  ;  ){ 。。。}

 

 

示例

public class ForDemo2 {
public static void main(String[] args) {

int i = 1;     //初始化语句可以不在for循环中的小括号中体现，但是必须在使用之前定义好。

for (; i <= 10; ) {              //如果在小括号后加分号，默认有一个空语句体，后面的代码为正常的代码块，不参与循环。
System.out.println("数加");
i++;                                //控制条件语句删除之后，也变成了死循环，你可以删除，但是初始化的变量的值一定要在循环体中发生变化。
}

}
}

 

例题

/*
求出1-10之间数据之和
*/
public class ForTest2 {
public static void main(String[] args) {
//定义一个变量接收和，初始值我们随便给，这里就给0，建议不到在后面再赋值，以免忘记，程序报错。
int sum = 0;

for (int i = 1; i <= 10; i++) {
// System.out.println(i);
sum = sum + i;
}

System.out.println("从1-10的和为：" + sum);

}
}

 

例题

/*
偶数：能被2整除的数，叫做偶数
奇数：不能被2整除的数，叫奇数
需求1：求出1-100之间偶数和

需求2：求出1-100之间奇数和

*/

public class ForTest3 {
public static void main(String[] args) {
int sum = 0;

for (int i = 1; i <= 100; i++) {
// System.out.println(i);
//判断是否是偶数，与2进行取模，看看余数是不是等于0
if (i % 2 == 0) {
sum = sum + i;
}
}
System.out.println("1-100的偶数之和为：" + sum);

sum = 0;
for (int i = 1; i <= 100; i++) {
//判断是否是奇数，与2进行取模，看看余数是不是等于1
if (i % 2 == 1) {
sum = sum + i;
}
}
System.out.println("1-100的奇数之和为：" + sum);
}
}

 

例题

请在控制台输出满足如下条件的五位数
个位等于万位
十位等于千位
个位+十位+千位+万位=百位

分析：
1、获取10000-99999的数据
2、获取获取个位，十位，百位，千位，万位
3、&&连接三个条件

12345 % 10 == 5      12345/10 = 1234
1234 % 10 == 4        12345/10/10 = 123
123 % 10 == 3          12345/10/10/10 = 12
12 % 10 == 2            12345/10/10/10/10 = 1
1 % 10 == 1

 

public class ForTest5 {
public static void main(String[] args) {
for(int i=10000;i<=99999;i++){
// System.out.println(i);
//获取个位
int geWei = i%10;
//获取十位
int shiWei = i/10%10;
//获取百位
int baiWei = i/10/10%10;
//获取千位
int qianWei = i/10/10/10%10;
//获取万位
int wanWei = i/10/10/10/10%10;

if(geWei==wanWei && shiWei==qianWei && geWei+shiWei+qianWei+wanWei==baiWei){
System.out.println(i);
}
}

}

}

 

循环结构(while循环语句)

while循环语句格式：

基本格式

while(判断条件语句) {

循环体语句;

}

完整格式

初始化语句;

while(判断条件语句) {

循环体语句;

控制条件语句;

}

 

 

执行流程
1、先执行初始化语句。
2、判断关系表达式的结果，
如果是true,进入while循环，执行循环体内容。
如果是false,就不进入while循环，不执行循环体内容。
3、如果进入循环体内容，执行循环体代码和控制条件语句。
4、直到关系表达式的结果为false，终止while循环。

 

死循环示例：
while(true){。。。}

 

public class WhileDemo1 {
public static void main(String[] args) {
//需求：打印10遍HelloWorld
System.out.println("===============用for循环实现===============");
for(int i=1;i<=10;i++){
System.out.println("HelloWorld");
}

System.out.println("===============用while循环实现===============");
int i=1;
while (i<=10){
System.out.println("HelloWorld");
i++;
}

System.out.println("=============死循环================");
int i1 = 0;
while (true){
System.out.println("这是死循环"+i1);
i1++;
}
}
}

 

for循环语句和while循环语句可以等价转换，但还是有些小区别的。

while循环与for循环的区别

1、使用区别：for循环结束后，在for循环中定义的初始化变量在外部无法使用。
while循环结束后，由于初始化值变量是在while循环外部定义的，所以
在while循环外部可以访问到。

2、场景区别： for循环适合针对一个范围判断进行操作。

while循环适合判断次数不明确操作。

 

示例：场景区别

每分钟监控某网页登录用户的情况，直到有非法用户登录，统计在此之前的次数

boolean flag = true;
while(flag){
if(非法用户登录){
flag = false;
}
}

 

 

循环结构(do…while循环语句)

do…while循环语句格式：

基本格式

do {

循环体语句;

}while(判断条件语句);

扩展格式     //（开发中使用扩展格式）

初始化语句;

do {

循环体语句; 控制条件语句;

} while(判断条件语句);

 

 程序示例：

public class DoWhileDemo1 {
public static void main(String[] args) {
//统计1-10之和
int sum = 0;
int i = 1;
do {
sum = sum + i;
i++;
} while (i <= 10);

System.out.println("1-10之和为：" + sum);
}
}

 

三种循环语句其实都可以完成一样的功能，也就是说可以等价转换，但还是有小区别的:

do…while循环至少会执行一次循环体。

for循环和while循环只有在条件成立的时候才会去执行循环体。

注意事项：

写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环。

 

示例：

public class DoWhileDemo3 {
public static void main(String[] args) {
int i = 0;
while (i>0){
System.out.println(i);
i--;
}
System.out.println("============do...while循环============");

do{
System.out.println(i);
i--;
}while (i>0);

}
}