java程序控制语句 java程序控制结构

转载

mob64ca14154457 2023-09-11 22:42:45

文章标签 java程序控制语句 java servlet 开发语言 System 文章分类 Java 后端开发

前言

一、顺序控制结构

1、基本介绍

2、注意事项

二、分支控制结构

1、单分支语句

2、双分支语句

3、多分支语句

4、嵌套分支语句

5、switch分支结构

三、循环控制结构

1、for循环语句

2、while循环语句

3、do...while循环语句

4、多重循环控制

四、跳转控制语句

1、break

2、continue

3、return

总结

前言

在程序中有一种结构能够控制程序的走向，决定我们程序是如何执行的，是我们重要掌握的，在Java中主要有三大流程控制语句：1.顺序控制 2.分支控制 3.循环控制。在这篇文章中我们一起来学习这些控制结构。

一、顺序控制结构

1、基本介绍

顺序控制结构是最简单的一种结构，程序从上往下执行，中间没有没有任何判断和跳转。

java程序控制语句 java程序控制结构_java

2、注意事项

在顺序控制结构中只需留意一点：必须先定义后使用。Java中定义变量时采用合法的前向引用。

正确形式：

public class Test{
    int num1 = 10;
    int num2 = num1 + 5;
}

错误形式：

public class Test{
    int num2 = num1 + 5;
    int num1 = 10;
}

二、分支控制结构

分支控制结构能够让程序有选择地执行，分支控制结构有以下三种：

单分支 if
双分支 if-else
多分支 if-else if-...else

1、单分支语句

1）基本语法

if（条件表达式）{
执行代码块；(可以有多条语句)
}

当条件表达式为true时，就会指向{ }中的代码。如果为false，就不执行。特别说明：如果{ }中只有一条语句可以不加{ }，但是建议加上{ }。

其流程图为：

java程序控制语句 java程序控制结构_java程序控制语句_02

2）案例演示

编写程序输入一个人的年龄，如果输入的年龄大于等于18，就输出：你已经是个成年人。

import java.util.Scanner;
public class Test {
 	//编写一个main方法
 	public static void main(String[] args) {
 		/*
 		//思路分析
		1. 接收输入的年龄, 应该定义一个 Scanner 对象
		2. 把年龄保存到一个变量 int age
		3. 使用 if 判断， 输出对应信息
 		 */

 		Scanner myscanner = new Scanner(System.in);

 		System.out.println("请输入一个人的年龄：");
 		int age = myscanner.nextInt();
 		if(age >= 18){
 			System.out.println("你是一个成年人");
 		}
 	}
}

2、双分支语句

1）基本语法

if（条件表达式）{
执行代码块1；
}
else{
执行代码块2；
}

当条件表达式成立，则执行代码块1，否则执行代码块2。如果代码块1或代码块2只有一条语句，{}可以省略不写，建议写上。

其流程图为：

java程序控制语句 java程序控制结构_java程序控制语句_03

2）案例演示

编写程序输入一个人的年龄，如果输入的年龄大于等于18，就输出：你已经是个成年人；若年龄小于18，则输出你未成年。

import java.util.Scanner;
public class Arr01 {
 	//编写一个main方法
 	public static void main(String[] args) {
 		/*
 		//思路分析
		1. 接收输入的年龄, 应该定义一个 Scanner 对象
		2. 把年龄保存到一个变量 int age
		3. 使用 if-else 判断， 输出对应信息
 		 */

 		Scanner myscanner = new Scanner(System.in);

 		System.out.println("请输入一个人的年龄：");
 		int age = myscanner.nextInt();
 		if(age >= 18){
 			System.out.println("你是一个成年人");
 		}
 		else{
 			System.out.println("你未成年");
 		}
 	}
}

3、多分支语句

1）基本语法

if (条件表达式) {
执行代码块1;
}
else if (条件表达式) {
执行代码块2;
}
... ...
else{
执行代码块n;
}

当条件表达式1成立时即执行代码块1，如果表达式1不成立，再去判断表达式2是否成立，若成立即执行代码块2，不成立即去判断判断表达式3，以此类推。对于多分支来说，可以没有最后的else语句，如果所有条件表达式都不成立，则一个执行入口都没有；若有else，当所有的条件表达式都不成立时，则默认执行else代码块，注意，只能有一个执行人口。

其流程图为：

java程序控制语句 java程序控制结构_servlet_04

2）案例演示

题目描述
企业发放的奖金根据利润提成。利润低于或等于100000元的，奖金可提10%;
利润高于100000元，低于200000元（100000<I≤200000）时，低于100000元的部分按10％提成，高于100000元的部分，可提成 7.5%;
200000<I≤400000时，低于200000元部分仍按上述办法提成，（下同），高于200000元的部分按5％提成；
400000<I≤600000元时，高于400000元的部分按3％提成；
600000<I≤1000000时，高于600000元的部分按1.5%提成；
I>1000000时，超过1000000元的部分按1%提成。从键盘输入当月利润I,求应发奖金总数。

import java.util.Scanner;
public class Test {
 	//编写一个main方法
 	public static void main(String[] args) {

 		Scanner myscanner = new Scanner(System.in);

 		System.out.println("请输入当月利润：");
 		double i = myscanner.nextDouble();
 		if (i <= 100000) {
	        //利润低于或等于100000元时
	        i = i * 0.1;
    	}
    	else if (100000 < i && i <= 200000) {
	        //利润高于100000元，低于200000元时
	        i = (100000 * 0.1) + (i - 100000) * 0.075;
	    }
    	else if (200000 < i && i <= 400000) {
	        //200000<i≤400000时
	        i = (100000 * 0.1) + 100000 * 0.075 + (i - 200000) * 0.05;
	    }
	    else if (400000 < i && i <= 600000) {
	        //400000<i≤600000元时
	        i = (100000 * 0.1) + 100000 * 0.075 + 200000 * 0.05 + (i - 400000) * 0.03;
	    }
    	else if (600000 < i && i <= 1000000) {
	        //600000<i≤1000000时
	        i = (100000 * 0.1) + 100000 * 0.075 + 200000 * 0.05 + 200000 * 0.03 + (i - 600000) * 0.015;
	    }
    	else {
	        //i>1000000时
	        i = (100000 * 0.1) + 100000 * 0.075 + 200000 * 0.05 + 200000 * 0.03 + 400000 * 0.015 + (i - 1000000) * 0.01;
    	}

    	System.out.println("奖金为：" + i);
 	}
}

思路分析
1. 接收输入的利润, 应该定义一个 Scanner 对象
2. 把利润保存到一个变量 double i
3. 使用 if-else多分支判断，输出对应信息

4、嵌套分支语句

1）基本语法

if（条件表达式1）{
if（条件表达式2）{
//if - else.....
}else{
//if - else
}
}

在一个分支结构中又完整地嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支，一个小建议：最好不要超过三层。

java程序控制语句 java程序控制结构_java程序控制语句_05

2）案例演示

设计一个出票系统：输入月份及年龄，输出票价
4-10月旺季：
成人（18-60）：60
儿童（<18）：半价
老人（>60）：1/3
淡季：
成人：40
其他：20

import java.util.Scanner;
public class Test { 

	//编写一个main方法
	public static void main(String[] args) {
		Scanner myscanner = new Scanner(System.in);
		System.out.println("请输入月份：");
		int mouth = myscanner.nextInt();
		System.out.println("请输入年龄：");
		int age = myscanner.nextInt();

		if(mouth >= 1 && mouth <= 12){

			if(mouth >= 4 && mouth <=10){
				if(age >= 18 && age <= 60){
					System.out.println("票价为:60元");
			    }
				else if(age > 60){
					System.out.println("票价为:20元");
				}
				else if(age < 18){
					System.out.println("票价为:30元");
				}
			}
			else {
				if(age >=18 && age <=60){
					System.out.println("票价为:40元");
				}
				else{
					System.out.println("票价为:20元");
				}
			}
		}
		else{
			System.out.println("请输入正确的月份");
		}
	}
}

5、switch分支结构

1）基本语法

switch(表达式){
case 常量1:
语句块1;
break;
case 常量2:
语句块2;
break;
...
case 常量n:
语句块n;
break;
default:
default语句块;
break;
}

switch关键字，表示switch分支
其中表达式对应一个值
case 常量1：当()中表达式的值等于常量1则执行语句块1
break：表示退出switch语句
如果case 常量1和表达式的值匹配，就执行语句块1，如果没有匹配就继续匹配case 常量2
如果一个都没有匹配的case，执行default。

其流程图为：

java程序控制语句 java程序控制结构_java_06

2）案例演示

请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
a 表示星期一， b 表示星期二 … 根据用户的输入显示相应的信息.要求使用 switch 语句完成

import java.util.Scanner;
public class Test {
	//编写一个 main 方法
	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个字符(a-g)");
		char c1 = myScanner.next().charAt(0);//
		//在 java 中， 只要是有值返回， 就是一个表达式
		switch(c1) {
			case 'a' :
			System.out.println("今天星期一");
			break;
			case 'b' :
			System.out.println("今天星期二");
			break;
			case 'c' :
			System.out.println("今天星期三");
			break;
			//.....
			default:
			System.out.println("你输入的字符不正确， 没有匹配的");
		}
		System.out.println("退出了 switch ,继续执行程序");
	}
}

思路分析
1. 接收一个字符 , 创建 Scanner 对象
2. 使用 switch 来完成匹配,并输出对应信息代码

3）注意事项

表达式数据类型应该与case后的常量类型保持一致，或者是可以自动转成可以相互比较的类型—比如：输入的是字符，而常量是int
switch(表达式)中表达式的返回值必须是：(byte、short、int、char、enum[枚举]、String)

//错误	
        double c = 1.1;
		switch(c){
			case 1.1:
				System.out.println("hello world");
				break;
		}

case子句中的值必须是常量，而不能是变量
default子句是可选的，当没有匹配的case时，执行default
break语句用来执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾，除非遇到break

4）switch和if的比较

如果判断的具体数值不多，而且符合 byte、 short 、 int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。

其他情况：对区间判断，对结果为 boolean 类型判断，使用 if， if 的使用范围更广

三、循环控制结构

在我们实际开发中有时需要代码重复多次做一件事情，比如输出10个“hello world”，若次数比较少时还好，可以写10条“System.out.println("hello world");”，但需要我们输出100个“hello world”呢？如果再使用之前的方法明显是不可行的。做重复的事情，就需要交给Java中的循环控制结构。Java中的循环控制结构有以下三种：

for循环
while循环
do...while循环

1、for循环语句

1）基本语法

for (循环变量初始化; 循环条件; 循环变量迭代) {
循环操作(可以多条语句);
}

for关键字表示循环控制
for循环有四要素：(1)循环变量初始化 (2)循环条件 (3)循环操作 (4)循环变量迭代
循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
如果循环操作(语句)只有一条语句，可以省略 {}, 建议不要省略

其流程图为：

java程序控制语句 java程序控制结构_开发语言_07

2）案例演示

案例一：

分析下面代码输出结果：
int count = 3;
for (int i = 0, j = 0; i < count; i++, j+=2) {
System.out.println("i=" + i + " j=" + j);
}
输出结果为：i=2，j=4

案例二：

打印 1~100 之间所有是 9 的倍数的整数，统计个数及总和

import java.util.Scanner;
public class Test {
	//编写一个 main 方法
	public static void main(String[] args) {

		int count = 0; //统计 9 的倍数个数 变量
		int sum = 0; //总和
		int start = 10;
		int end = 200;
		int t = 5; // 倍数
		for(int i = start; i <= end; i++) {
			if( i % t == 0) {
				System.out.println("i=" + i);
				count++;
				sum += i;//累积
			}
		}
		System.out.println("count=" + count);
		System.out.println("sum=" + sum);
	}
}

3）注意事项

循环条件是返回一个布尔值的表达式
for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

2、while循环语句

1）基本语法

循环变量初始化;
while (循环条件) {
循环体(语句);
循环变量迭代;
}

对于while循环来说，它与for循环一样也有四要素，只是四要素的位置与for循环不同。循环条件是返回一个布尔值的表达式，并且while循环是先判断再执行语句。

其流程图为：

java程序控制语句 java程序控制结构_System_08

2）案例演示

使用while输出10句“hello world”

import java.util.Scanner;
public class Test {
	//编写一个 main 方法
	public static void main(String[] args) {

		int i = 0;
		while(i < 10){
			System.out.println("hello world");
			i++;
		}
	}
}

3、do...while循环语句

1）基本语法

循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);

do...while循环也有循环四要素，只是位置不一样。与while不一样的是do...while是先执行再进行判断，也就是说无论循环条件是否成立都需要执行一次。循环条件与while一致，返回的是一个布尔值的表达式。

注意：最后有一个分号。

其流程图如下：

java程序控制语句 java程序控制结构_开发语言_09

2）案例演示

统计 1---200 之间能被 5 整除但不能被 3 整除的个数。

public class Test {
	//编写一个 main 方法
	public static void main(String[] args) {

		int i = 1;
		int count = 0; //统计满足条件的个数
		do {
			if( i % 5 == 0 && i % 3 != 0 ) {
				System.out.println("i=" + i);
				count++;
			}
			i++;
		}while(i <= 200);
		System.out.println("count=" + count);
	}
}

当我们处理复杂的问题时我们可以使用如下两种思考方式进行分析：化繁为简与先死后活。化繁为简便是将我们拿到的复杂问题进行拆解，拆解成一个个简单的问题，先处理简单的问题再处理复杂的问题；而先死后活是先定义一个数进行求解，求解成功后在进行替换。该问题使用两种思路如下：

化繁为简：

(1) 使用 do-while 输出 1-200
(2) 过滤能被 5 整除但不能被 3 整除的数 %
(3) 统计满足条件的个数 int count = 0;

先死后活：

(1) 范围的值 1-200 你可以做出变量
(2) 能被 5 整除但不能被 3 整除的 , 5 和 3 可以改成变量

4、多重循环控制

1）基本介绍

将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while 均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

例子如下：

for（int i = 1; i <= 7; i++）{ //第一层循环，7次
for（int j = 1; j <= 2; j++）{ //第二层循环，2次
System.out.println("hello world"); //一共执行次数：7 * 2 = 14次
}
}

若外层循环为m次，内层为n次，则内层循环体实际上需要执行 m*n 次。

2）分析方法：内存分析法

案例：分析下面的多次循环执行步骤，并写出输出结果

for(int i = 0; i < 2; i++) { 
    for( int j = 0; j < 3; j++) {
        System.out.println("i=" + i + j=" + j);
    }
}

其分析过程如下：

java程序控制语句 java程序控制结构_servlet_10

四、跳转控制语句

1、break

1）基本语法

{
... ...
break;
... ...
}

break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环【for , while , do-while】语句中。

break在while循环中的示意图为：

java程序控制语句 java程序控制结构_servlet_11

2）案例演示

判断下面代码的输出结果

public class Break01 { 

	//编写一个main方法
	public static void main(String[] args) {

		//测试代码
		for( int i = 0; i < 10; i++) {
			if( i == 3) {
				break ;
			}
			System.out.println("i=" + i);
		}

		System.out.println("退出for循环, 继续执行..");
	}
}

其输出结果如下：

java程序控制语句 java程序控制结构_System_12

当i=0，1，2时，不满足if的判断条件，故不执行if语句中的内容，当i=3时满足if的判断条件，执行break，即跳出当前for循环，不再进行后面的i++操作，循环终止。

3）注意事项

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块。

标签的基本使用如下，label1是标签，可由我们自己指定名字。

label1: { ......
label2: { ......
label3: { ......
break;
......
}
}
}

break后指定到哪个label就退出到哪里，当只有一个break时，默认退出最近的循环体。

分析下面代码输出了什么：

public class Break { 

	//编写一个main方法
	public static void main(String[] args) {

		abc1:
		for(int j = 0; j < 4; j++){//外层for
		abc2:
			for(int i = 0; i < 10; i++){//内层for
				if(i == 2){
					//break  ;//等价 break abc2
					break abc1 ;
				}
				System.out.println("i = " + i);
			}
		}

	}
}

当内层循环到 i==2 时，执行break abc1，即跳出外层for循环。故输出为：

java程序控制语句 java程序控制结构_java_13

2、continue

1）基本语法

{
... ...
continue;
... ...
}

continue语句也是用来结束循环，不过与break语句不同的是：continue只是结束本次循环，会进入下一次循环，并没有结束循环体。

continue 语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签使用的规则一样。

continue在while循环中的示意图为：

java程序控制语句 java程序控制结构_java_14

2）案例演示

分析下面代码输出结果：

public class Continue01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//代码
		int i = 1;
		while( i <= 4) {
			i++;
			if( i == 2) {
				continue;
			}
			System.out.println("i=" + i);
		}
	}
}

当 i=2 时，进入if语句执行continue，跳过本次while循环，执行下一次while循环，i = 3，4，5时都打印输出，即结果为：

java程序控制语句 java程序控制结构_java程序控制语句_15

3、return

return 使用在方法，表示跳出所在的方法。在讲解方法时会详细讲解。

案例：return 写在 main 方法，退出程序Test.java

public class Return01 { 
	//编写一个main方法
	public static void main(String[] args) {

		for(int i=1;i<=5;i++){

			if(i==3) {
		        System.out.println("hello World "+i);
				return; //当return用在方法时，表示跳出方法，如果使用在main,表示退出程序
				
			}
			System.out.println("haha");
		}
		System.out.println("go on..");

	}
}

总结

程序控制结构是Java编程是非常基础、重要的部分，复杂的代码都是由这些基本的语句组成，因此我们要熟练地掌握程序控制结构各种语句。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Android x86安装到U盘安卓x86安装在硬盘教程

下一篇：m1用什么架构 m1芯片用的什么系统

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯