【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、基本介绍

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

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，就不执行。特别说明：如果{ }中只有一条语句可以不加{ }，但是建议加上{ }。

其流程图为：

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只有一条语句，{}可以省略不写，建议写上。

其流程图为：

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代码块，注意，只能有一个执行人口。

其流程图为：

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

        }

}

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

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。

其流程图为：

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 (循环变量初始化; 循环条件; 循环变量迭代) {

        循环操作(可以多条语句);

}

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

其流程图为：

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循环是先判断再执行语句。

其流程图为：

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一致，返回的是一个布尔值的表达式。

注意：最后有一个分号。

其流程图如下：

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);
    }
}

其分析过程如下：

---

四、跳转控制语句

1、break

1）基本语法

{

        ... ...

        break;

        ... ...

}

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

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

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循环, 继续执行..");
	}
}

其输出结果如下：

当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循环。故输出为：

2、continue

1）基本语法

{

        ... ...

        continue;

        ... ...

}

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

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

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

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时都打印输出，即结果为：

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