Java分支结构（if、if else、switch）、循环结构（while、do while、for）

前言

本节我们来介绍下Java中的循环结构和分支结构

一、分支结构

  分支结构有if、if else、switch，下面就来具体的说一说这些结构的用法以及需要注意的问题

1.if条件语句

格式：if(条件表达式){执行语句；}

我们以一个例子来简单说明if语句的用法，完成程序如下:如果张三玩的石头人没有空大，那么队友就会跟他说666，代码如下:

//如果石头人没有空大则i为1，默认为-1
int i = -1;
System.out.println("石头人快放大！！！");
i = 1；
if(i == 1){
	System.out.println("666");
}
//输出结果为666

2.if-else条件语句

格式：if(条件表达式){
          执行语句；
      }else {
          执行语句；
      }

还是以一个例子来简单说明，完成程序如下:如果张三玩的石头人没有空大，那么队友就会跟他说666，否则，队友就会说可惜了，代码如下:

//如果石头人没有空大则i为1，默认为-1
int i = -1;
System.out.println("石头人快放大！！！");
if(i == 1){
	System.out.println("666");
}else{
	System.out.println("可惜了");
}
//输出结果为可惜了

3.if-else-if嵌套条件语句

格式：if(条件表达式){
          执行语句；
      }else if(){
          执行语句；
      }else {
          执行语句；
      }

if-else语句嵌套可以控制多个条件,完成程序如下:如果张三玩的石头人没有空大，那么队友就会跟他说666，如果R中2个，队友就会说不错，如果R中3个，队友就会说太棒了，否则，队友就会说可惜了，代码如下:

//如果石头人空大默认为-1
int i = -1;
System.out.println("石头人快放大！！！");
i = 3；
if(i == 1){
	System.out.println("666");
}else if(i == 2){
	System.out.println("不错");
}else if(i == 3){
	System.out.println("太棒了");
}else{
	System.out.println("可惜了");
}
//输出结果为太棒了

需要的注意问题：
  1.如果if只有一条执行语句，那么括号可省略不写，但是为了程序编码规范，一般习惯一条语句也加上括号
  2.if-else的隐性条件判断，如果if的条件a > 60不成立，那么执行else执行语句的a变量相当于是a <= 60

4.switch-case语句

格式：switch(变量或变量表达式){
          case 值1:
          		  语句体;//可选加break;
          case 值2:
          		  语句体;//可选加break;
          case 值3:
          		  语句体;//可选加break;
          //可选加default;
      }

    switch(4){
        case 1:
            System.out.println("666");
            break;
        case 2:
            System.out.println("不错");
            break;
        case 3:
            System.out.println("太棒了");
            break;
        case 4:
             System.out.println("真的厉害");
             break;
        case -1:
             System.out.println("可惜了");
             break;
        default:
        	 System.out.println("大招冷却呢");
        }
        //输出结果:真的厉害

需要的注意问题：
  1.switch 语句中的变量类型可以是： byte、short、int、char、String
  2.case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量、或常量的计算表达式(如1+2等)
  3.case中如果有匹配的值则执行相应的语句，依次向下执行，直到结束或者遇到break语句，如果没有相匹配的值则执行default语句，如果再没有default的话则跳出switch语句
  4. default语句可以在任何位置，但建议在最后一个

二、循环结构

  循环结构有while、do while以及for，掌握循环语句要拿准三个要素，第一个是初始化变量赋值，也就是我们循环开始的地方，第二个是判断循环是否继续进行的条件，这点很重要，第三个是每一次循环结束后，控制循环的变量的变化，下面我们来具体介绍下

1.while循环语句

格式：while(条件判断语句){循环体；}

以循环输出1-100的数的和为例，来具体介绍下循环语句的应用方法，代码如下:

//循环输出1-100的和
//一、初始化变量赋值,首先要想一下，我们要求一个1-100的和，首先得有一个变量
//去成为这个和，还要有一个变量去把自身加给这个和，一共有两个变量，这也是
//写循环语句的第一步，初始化变量赋值
int sum = 0;
int m = 1;
//二、判断循环是否继续进行的条件，因为我们要求的是1-100以内的和，所以
//在大于100的时候结束循环
while(m <= 100){
sum += m;
//三、控制循环的变量变化，我们要求的是1-100的和，所以每次只需要加1即可，
//如果求得是1-100的奇数和，那么就可以写成m += 2
m++;
}
System.out.println(sum);
//输出结果为5050

2.do-while循环语句

格式：do{
		循环体;
	}while(条件判断语句)

int i2 = 1;
int num2 = 0;
//无需判断条件直接执行第一步
do {
	num2 += i2;
	i2++;
}while (i2 <= 100);
System.out.println(num2);
//输出结果为5050

需要的注意问题：
  1.do while与while循环的最根本的区别是do while循环相当于把循环语句的第一次循环拿出来直接执行一次，且不需要判断条件，而while循环从第一步开始就需要判断条件，也就是说无论如何do while循环至少执行一次

3.for循环语句

for循环相当于把初始化变量赋值，判断语句，控制条件语句整合到了一起，非常方便，也是今后编程中最常用的循环

格式：for(初始化语句;判断语句;条件控制语句){
            循环体语句;
     }

执行流程：
  1.执行初始化语句
  2.执行判断语句，如果是true，继续执行，false循环结束
  3.执行循环体语句
  4.执行条件控制语句
  5.回到第二步

//循环输入1-100的和
int num = 0;
for (int i = 0; i <= 100; i++) {
num += i;
System.out.println(num);
}
//输出结果为5050

需要的注意问题：
  1.for循环语句的控制很灵活，两个分号的左右以及中间部分可以按需填写，也可以不写
  2.在任意位置使用break语句后会跳出当前的大循环（考虑到循环嵌套），使用continue 语句会使程序立即跳转到条件控制语句

三、循环嵌套（打印九九乘法表）

  循环嵌套对于很多初学者来说是一个难点，但其实也很好理解，只要找到外部循环与内部循环的关系即可轻松掌握，下面通过几个例子来带大家更好的掌握循环嵌套，先举一个例子：一开始我要跑十圈，代码如下:

for (int i = 1; i <= 10; i++) {
System.out.println("这是我跑的第" + i + "圈");
}

  之后我每跑一圈做十个俯卧撑，然后我再跑下一圈，再做十个俯卧撑， 这里跑十圈是一个循环，而在这十圈之内，我每一圈又做了十个俯卧撑，这就相当于在跑圈这个循环之中又嵌套了一个做俯卧撑的循环，其中跑十圈是外部循环，做俯卧撑是内部循环，代码如下：

//循环嵌套
//跑十圈，每一圈做十个俯卧撑
for (int i = 1; i <= 10; i++) {
	System.out.println("这是我跑的第" + i + "圈");
	//假设现在i为1，也就是我现在是在跑第一圈的过程中，接下来
	//我要做俯卧撑了
	for (int j = 1; j <= 10; j++) {
	//此时i一直为1，j由1-10,直到该循环结束
		System.out.println("这是我跑第" + i +"圈" +
		+ "，做的第" + j +"个俯卧撑");
	}
	//到这里我才跑完第一圈，做完十个俯卧撑，接下来i++，开始
	//第二轮外部循环
}

  通过上面的例子，我们可以轻松的打印出九九乘法表,在这里外部循环i相当于控制了行数，内部循环j相当于控制了列数，这里的外部循环相当于我们在跑圈，内部循环相当于在跑每一圈的时候做的俯卧撑
  观察下图可知，九九乘法表一共有九行，相当于我们跑了九圈，跟我们只跑圈的代码一样，相当于改成了跑九圈

for (int i = 1; i <= 9; i++) {
System.out.println("这是我跑的第" + i + "圈");
}

  而内部循环就不是每一圈做10个俯卧撑了，这个时候就要观察内部循环和外部循环之间的联系，我们发现，我们跑的圈数跟我们做的俯卧撑数一样，第1圈做1个，第2圈做2个，第3圈做3个…那么这个时候我们的判断条件就要改一下了，也就是，我们每一圈做的俯卧撑数最多和圈数相同，也就是内部循环的变量j（俯卧撑数）要<=外部循环的变量（圈数）
  之前我们的循环嵌套是要做俯卧撑，而现在我们是要打印九九乘法表，这个时候在观察九九乘法表，发现前面的数×后面的数就是俯卧撑数×圈数，也就是内部变量×外部变量，这下我们就可以轻松写出打印九九乘法表的代码:

//打印九九乘法表
for (int i = 1; i <= 9; i++) {
	for (int j = 1; j <= i; j++) {
		System.out.print(j + "×" + i + "=" + i * j + "\t");
	}
	System.out.println();
}

总结

本节主要介绍了Java的分支结构、循环结构和循环嵌套，详细讲解了如何打印出九九乘法表，希望对各位有所帮助

1.选择结构

a):选择结构主要是：
If(布尔表达式1){//true则执行代码块，false跳过
代码块1
}else if(布尔表达式2){
代码块2
}
注意：

• else类似于else if；
• 模块间相互排斥，一个为true，其它不执行。
• if语句支持嵌套。

例：
根据自己的购买力买车：
如果有500万，买劳斯莱斯；
否则，如果有100万，买GTR；
否则，如果有50万，买奔驰E；
否则，如果有20万，大众帕萨特；
否则，如果有10万，哈弗H6；
否则，如果有5万，奇瑞QQ；
否则，如果有1万，电动车；
否则，捷安特自行车。

		int money = 100; //万元
		if(money >= 500){
			System.out.println("劳斯莱斯");
		}else if(money >= 100){
			System.out.println("买GTR");
		}else if(money >= 50){
			System.out.println("奔驰E");
		}else if(money >= 20){
			System.out.println("大众帕萨特");
		}else if(money >= 10){
			System.out.println("哈弗H6");
		}else if(money >= 5){
			System.out.println("奇瑞QQ");
		}else{
			System.out.println("捷安特自行车");
		}
		System.out.println("程序结束...");

2. 分支结构

switch(变量/表达式){
case 值1：//true则执行代码块，false跳过
代码块1；
break；//跳出分支结构
case 值2：
代码块2；
break；//跳出
default：
未满足条件时的逻辑代码；
break；
}
注意： break跳出的位置很重要。
例：
判断一个整数，如果是1~5之间，则分别输出5个福娃的名字，否则输出“北京欢迎你”。
答：

int a=3;//1~5之间数字
switch(a){
		case 1:
			System.out.println("贝贝");
			break;
		case 2:
			System.out.println("晶晶");
			break;
		case 3:
			System.out.println("欢欢");
			break;
		case 4:
			System.out.println("迎迎");
			break;
		case 5:
			System.out.println("妮妮");
			break;
		default:
			System.out.println("北京欢迎你");
			break;
}

3. 循环结构

a):while循环：
初始部分；
while(循环条件){//直到条件变化为false，才结束。
操作部分；
迭代部分；
}
注意： 与条件相关的才是初始部分和迭代部分，有入口条件，先判断，再执行，执行0~n次。适用循环于次数明确的。

例：计算1+2+3+…+100的和

		int s = 0;//和
		int i = 1;
		while(i <=100){
			s = s + i;
			i++;
		}
		System.out.println(s);

b):do while循环：
初始部分；
do{
操作部分；
迭代部分；
}while(条件部分);//直到条件变化为false，才结束。
注意： 无入口条件，先执行，再判断，执行1~n次。使用于循环次数不明确的。

例：计算1+2+3+…+100的和

		int s = 0;//和
		int i = 1;
		do{
			s = s + i;
			i++;
		}while(i <= 100);
		System.out.println(s);

c):for循环
for(初始部分；循环条件；迭代部分){//直到条件变化为false，才结束。
循环操作
}
注意： 可以把初始部分和迭代部分写在别的位置，但是要保留分号。

例：计算1+2+3+…+100的和

		int s = 0;//和
		for(int i = 1;i <= 100;i++){
			s = s + i;
		}
		System.out.println(s);

4. 循环嵌套

概念：在一个完整的循环中嵌套另一个循环

补充：嵌套循环约定成俗的变量命名：一重循环i；二重循环j；三重循环k。

附：流程控制

break ：

• 跳出，终止 选择循环或循环结构；
• 可以判断 在循环出错的时候跳出循环
• 可以为某循环加标记，使用 break 标记名; 跳出对应循环
  continue：
  结束本次循环操作，继续执行下一次循环。

Hello,everyone! forever之前给大家介绍了C语言的分支结构和循环结构，在分支中介绍了分支语句嵌套，但当时没有介绍 switch 嵌套，所以这次主要介绍 switch 嵌套和循环嵌套.
首先来说说什么是嵌套吧！一个语句内包含另一个完整的语句结构称为语句嵌套。内嵌套的语句结构内还可以继续嵌套其他语句结构，这就构成多层嵌套。如：在循环体内嵌套一个完整的循环语句，就称为循环嵌套；在内部循环嵌套里在嵌套一个循环结构，就是多层循环。嵌套的含义是指“完整的包含”。

switch 嵌套

如同 if 语句一样，switch 语句也可以构成嵌套结构。在 switch-case 内部再嵌套一个 switch-case 语句，就构成 switch 嵌套结构；若内部的内部再继续嵌套就会构成多层嵌套。
1、语法结构：
以下是 switch 嵌套结构，default 可以看情况使用，不使用时就相当于不处理。一般用 default 时，在后面就可以不加 break。

switch (表达式1)
{
case 常量表达式1:语句1;
	switch (表达式2)
	{
	case 常量表达式A:语句a; 
		break;
	case 常量表达式B:语句b;
		break;
		……
	default:语句N;
	}
	break;
case 常量表达式2:语句2;
	switch (表达式n)
	{
		……
	}
	break;
case 常量表达式3:语句3;
	break;
	……
default:语句n;
}

2、switch-case 嵌套语句程序示例
例题一：简单的理解 switch 语句嵌套结构

*简单的switch嵌套程序*
#include<stdio.h>
int main()
{
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);   //先输入两个值
	switch (a)    //这个外部 switch 对 a 进行判断
	{
	case 1:       //a=1时进入内部嵌套 switch 语句
		switch (b)   //这里 switch 对 b 进行判断
		{
		case 0:printf("$$$\n");
			break;
		case 1:printf("&&&\n");
		default:printf("***");   //这里是除了以上情况外的其他情况
			break;
		}
		break;   //结束 case1 内部的嵌套语句
	case 2:printf("###\n");
		break;
	case 3:printf("@@@\n");
	default:printf("!!!\n");
	}
	return 0;
}

运行结果：

例题二：switch 和 if 的结合使用。请输入星期几的第一个字母来判断是星期几，如果第一个字母一样则继续判断第二个字母。

*请输入星期几的第一个字母来判断是星期几，如果第一个字母一样则继续判断第二个字母。*
#include<stdio.h>
#include<ctype.h>//这是toupper 函数调用头文件
int main()
{
	char letter1;
	char letter2;
	printf("请输入星期中某一天的第一个字母：（M/W/F/T/S）\n");
	scanf("%c", &letter1);
	letter1 = toupper(letter1);// toupper 是一个将小写字母转换成大写字母的函数
	getchar();//利用 getchar 消除回车符'\n',如果没有这个 getchar ,
	switch (letter1)     //那么后面继续输入第二个字母时就会输入回车符'\n',直接判断为 error
	{
	case 'M':printf("星期一\n");
		break;
	case 'W':printf("星期三\n");
		break;
	case 'F':printf("星期五\n");
		break;
	case 'T':printf("请输入第二个字母：(u/h)\n");
		scanf("%c", &letter2);
		if (letter2 == 'u')//case 内部结合 if-else 语句使用
		{
			printf("星期二\n");
		}
		else if (letter2 == 'h')
		{
			printf("星期四\n");
		}
		else
		{
			printf("error\n");
		}
		break;
	case 'S':printf("请输入第二个字母：(a/u)\n");
		scanf("%c", &letter2);
		if (letter2 == 'a')
		{
			printf("星期六\n");
		}
		else if (letter2 == 'u')
		{
			printf("星期天\n");
		}
		else
		{
			printf("error\n");
		}
		break;
	default:printf("error\n");
	}
	return 0;
}

运行结果：查找星期二

循环嵌套

循环结构的循环语句可以是任意合法的 C 语句。若一个循环结构的循环体中包含了另一循环语句，则构成了循环的嵌套，称为多重循环。嵌套的含义是指“完整的的包含”，那么循环的嵌套是指在一个循环的循环体内完整的包含另一个或另外几个循环结构。C 语言中三种循环控制语句可以相互嵌套在一起。
1、while 循环嵌套
（1）语法结构：

while (表达式1)
{
	语句1;
	while(表达式2)
	{
		语句2;
	}
	……
}

(2)while 循环嵌套程序示例
示例一：利用 while 循环嵌套打印九九乘法表

//打印九九乘法表
#include<stdio.h>
int main()
{
	int i = 1, j = 1;
	while (i < 10)
	{
		j = 1;
		while (j <= i)
		{
			printf("%d*%d=%-4d ", j, i, i * j);//%-4d意思是左对齐并且保证留四个字符长度的距离
			j++;
		}
		printf("\n");//起到换列的作用
		i++;
	}
	return 0;
}

运行结果：九九乘法表打印

2、do-while 嵌套循环
（1）语法结构

do
{
	语句1;
	do
	{
		语句2;
	} while ();//一定要注意do-while语句后面的“分号”，不能丢
	……
} while ();

（2）do-while 循环嵌套示例
随机打印2-n+1个数字

#include<stdio.h>//随机打印 2-n+1 个数
int main()
{
	
	int i = 0;
	int n = 0;
	scanf("%d", &n);
	do
	{
		i++;
		do
		{
			i++;
			printf("%d\n", i);
		} while (i <= n);
	} while(i<=n);
	return 0;
}

运行结果：

3、for 循环嵌套
（1）语法结构

for ( ; ; )
{
	语句1;
	for( ; ; )
	{
		语句2;
	}
	……
}

（2）for 循环嵌套示例
示例一：数字金字塔

//利用 for 循环嵌套实现数字金字塔
#include<stdio.h>//数字金字塔
int main()
{
	int i = 0, j = 0;
	int n = 0;
	scanf("%d", &n);
	for (i = 1; i <= n; i++)
	{
		for (j = n-i; j >0; j--)//此循环语句为了实现空格打印
		{
			printf(" ");
		}
		for (j = 1; j <= i; j++)
		{
			printf("%d ", i);
		}
		printf("\n");//实现换行

	}
	return 0;
}

运行结果：输入5，进行金字塔排列

示例二：冒泡排序法
for 循环实现从小到大冒泡排序

//利用 for 循环嵌套实现从小到大冒泡排序
#include<stdio.h>//冒泡排序
int main()
{
	int n = 0;
	int i = 0, j = 0;
	int arr[100] = { 0 };
	int temp = 0;
	scanf("%d", &n);
	for (i = 0; i < n; i++)//利用循环给数组赋值
	{
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < n - 1; i++)//冒泡排序外层循环进行 n-1 轮排序![请添加图片描述](https://img-blog.csdnimg.cn/9caa20aa99b742fc99e480f65f3c12ac.png)

	{
		for (j = 0; j < n - i - 1; j++)//冒泡排序内层循环每轮要进行 n-i-1 层比较
		{
			if (arr[j] > arr[j + 1])//进行大小比较
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	for (i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行结果：随机输入5个数进行排序

示例三：打印 100-200 之间的素数
for 循环嵌套打印100-200间素数

//打印100-200间素数
#include<stdio.h>//打印100-200间素数
int main()
{
	
	int j = 0;
	for (int i = 100; i <= 200; i++)
	{
		for (j = 2; j < i; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (i == j)
		{
			printf("%d\n", i);
		}
	}
	return 0;
}

运行结果：

总结

1、在循环以及循环嵌套中依然会常用到 break 和 continue ，之前文章详细介绍过这两个语句，因此要注意他们的使用；
2、再多层嵌套里一般也会用到 goto 跳转语句，终止程序在某些结构中的深度嵌套；
3、除以上基本嵌套之外，while、do-while、for以及和其他分支语句都可以任意嵌套组合使用，而且 C 语言中不限制嵌套的层数，我们可以合理组织程序的模块结构；
4、在编写程序时，尽量避免过多的嵌套，影响代码整体美观，嵌套过多也对硬件相关配置要求更高。
目前就这些！这些代码都比较简单，浅显易懂，希望对一些初学者有一定帮助，也望其他大佬能多多指点！如有不足或错误之处，请谅解并指教哈！
谢谢观看，再见啦！
以上代码均可运行，所用编译环境为 vs2019 ,运行时注意加上编译头文件#define _CRT_SECURE_NO_WARNINGS 1