循环结构

流程控制分类

1. 顺序结构

从上到下，从左到右

2. 分支结构

选择执行，不会同时发生
if

package cn.susu.flow;

import org.junit.Test;

//测试if分支语句，包括它的变种语句else/else if
public class TestIf {
	@Test
	public void testif() {
		//需求：天晴晒被子，下雨收衣服
		//语法：if（布尔表达式）
		//else if 语法:if(){...}else if (){...}else if (){...}else if (){...}else等  
		
	boolean rainning = true;//判断标识，代表是否下雨
	if(rainning) { 
		System.out.println("下雨收衣服");
	}
	
		System.out.println("if语句结束了");
	   }
	 }

if(){…}else{…}
案例：判断年份为平年还是闰年

package cn.susu.basic;
import java.util.Scanner;

/**案例：接受用户输入的年份，判断是平年还是闰年*/
//方式一：能被4整除，并且不能被100整除(闰年)
//方式二：能被400整除(闰年)
public class TestYear {
	public static void main(String[] args) {
		//提示用户输入年份
		System.out.println("请您输入要判断的年份");
		int year = new Scanner(System.in).nextInt();
		//定义一个变量用来保存结果
		String result = "平年";//默认每年都是平年
		//判断是否符合闰年的判断条件
//		if(判断条件) {
//			符合此判断条件的执行代码，如果条件不符合，不执行此代码}
		//方式一：能被4整除，并且不能被100整除
		if(year % 4 == 0) {
			if(year % 100 != 0) {
				result = "闰年";//符合闰年的判断条件，修改结果为闰年
			}
		}
		//方式二：能被400整除
		if(year%400 == 0) {
			result = "闰年";
		}
		else {
			result = "平年";
		}
		//判断
		/**解决方案2*/
		/**判断结构 if(判断条件){满足判断条件以后执行的代码} */
		//if(条件1  || 条件2){是闰年 }
		//if((小条件1  && 小条件2) || 条件2){ 是闰年 }
		//if((能被4整除  && 不能被100整除) || 能被400整除){ 是闰年 }

		if((year % 4 == 0&&year % 100 != 0 ) || year%400 == 0 ){
			result = "闰年";
		}
		//打印判断结果
		System.out.println(year+"年是"+result);
	}

}

if(){…}else if(){…}
循环案例：购买商品满减打折

package cn.susu.basic;

import java.util.Scanner;
//需求：接收用户输入的原价，满1000打9折，满2000打8折，满5000打5折，满10000打1折
/**本类用于练习商品打折案例*/
public class TestDiscount {
	//1.创建入口函数
	public static void  main (String[] args) {
		//2.提示用户输入原价
		System.out.println("请您输入您的价格：");
		//3.接收用户输入的价格
		double price = new Scanner(System.in).nextDouble();
		//4.可计算打折以后的价格
		//4.1定义变量用保存打折后的价格
		double count=price;/**初始值是商品的原价*/
		//4.2判断用户的打折段位并打折
		if(price>=10000) {
			count = price*0.1;
		}else if (price>=5000) {
			count = price*0.5;
		}else if (price>=2000) {
			count = price*0.8;
		}else if (price>=1000) {
			count = price*0.9;
		}
		
		//5.输出实际支付的价格
		System.out.println("您实际应该支付："+count+"元");
	}

}

switch：多分支（支持char、byte、short、int，不支持long 变量类型）
如果没有break，当某个条件成立，后面所有条件全部生效而且其它代码全都执行

 package cn.susu.basic;
/**本类用于练习swtich结构*/
public class TestSwitch {
	//1.创建程序的入口函数
	public static void main(String[] args) {
		int a = 3;
		/**总结1：变量a的类型支持btye、short、char、int、String*/
		switch(a) {
		/**总结:没有break，就会从输入的语句行一直输出(穿透)到最后一行，有break只打印本行*/
		/**总结2：break表示结束当前的case，如果不加break会向后穿透所有的case，包含default*/
			case 1:System.out.println("1");break;
			case 2:System.out.println("2");break;
			case 3:System.out.println("3");break;
			case 4:System.out.println("4");break;
			case 5:System.out.println("5");
			/**总结3：default是"保底"的一个选项，可加可不加
			 * default是如果没有匹配到任何case是，执行的默认选项
			 * 如果在default之前遇到了break，default才不会执行*/
			default:System.out.println("你是傻子");break;
		}
		
		String s = "Friday";
		switch(s) {
			case "Monday":System.out.println("星期一吃火锅");break;
			case "Tuesday":System.out.println("星期二吃烤肉");break;
			case "Wednsday":System.out.println("星期三吃米饭");break;
			case "Thursday":System.out.println("星期四吃粥");break;
			case "Friday":System.out.println("星期五吃锅包肉");break;
			case "Saturaday":System.out.println("星期六吃山珍海味");break;
			case "Sunday":System.out.println("星期日吃土，喝西北风");break;
			default :System.out.println("想吃啥就吃点啥吧");break;	
		}	
	}
}	

3.循环结构

重复执行，循环不退出死循环。

for循环

package cn.susu.basic;

public class ForDemo {
	//DEBUG调试
	//添加断点：双击目标语句，再次双击，取消断点，结构性语句无法添加
	//如果想查看程序执行的具体细节，需要以Debug模式运行程序并切换试图
	//F6下一步
	public static void main(String[] args) {
		for(int i = 0;i<=10;i++) {
			System.out.println(i);
		}
	}
}

for嵌套循环

package cn.susu.basic;
/**本类用于测试嵌套for循环
 * 外层循环控制行数，内层循环控制列数*/
public class TestForDemo {
	public static void main(String[] args) {
		method1();//测试外层循环执行1次，内层循环执行多次
		method2();//打印一个3行5列的矩形，使用元素*
		method3();//打印一个10行10列的矩形，使用元素*
	}

	private static void method3() {
		for(int i=0;i<10;i++) {
			for(int j=1;j<=10;j++) {
				System.out.print("*");
			}System.out.println();
		}
		
	}

	private static void method2() {
		for(int i= 1;i<=3;i++) {
			for(int j= 1;j<=5;j++) {
				System.out.print("*");
		}System.out.println();//空白行就是换行
	  }
	}

	public static void method1() {
		//需求1：打印1-3
		//需求2：打印1-5
		//当i=1时，满足1<=3条件，所以i值打印1，内层循环的j打印1-5
		//当i=2时，满足1<=3条件，所以i值打印2，内层循环的j打印1-5
		//当i=3时，满足1<=3条件，所以i值打印3，内层循环的j打印1-5
		/**总结1：外层循环执行1次，内层循环执行多次*/
		/**总结2：外层循环控制的是执行的轮数，循环3次，执行3轮*/
		for(int i = 1;i<=3;i++) {	/**外层循环，打印1-3*/
			System.out.print(i);
			System.out.println();
			/**总结3：内层循环控制的是每一轮执行的次数，循环5次，每次打印1-5*/
			for(int j = 1;j<=5;j++) {/**内层循环，打印1-5*/
				System.out.print(j);
			}System.out.println();
		}
	}
}

package cn.susu.basic;
/**本类用于测试99乘法表*/
public class TestFor99 {
	public static void main(String[] args) {
		for(int i=1;i<10;i++) {
			for(int j=1;j<=i;j++) {
				/**拼接打印的算式，后面加了\t
				 * 表示这是表格格式\t也被称作制表符
				 * */
				System.out.print(j+"*"+i+"="+i*j+"\t");
			}System.out.println();
		}
	}
}

  专门破坏死循环方案：break、continue、return

break: 直接结束当前循环,跳出循环体,简单粗暴
break以后的循环体中的语句不会继续执行,循环体外的会执行
注意如果是嵌套for循环,在内层循环遇到了break,只会跳出当前这一层内循环哦,若想全部都跳过，可以使用return

continue: 跳出本轮循环,继续下一轮循环
continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

package cn.susu.basic;

import java.util.Scanner;
/**本类用于测试break和continue，案例：找数字88*/
//需求：提示并接收用户输入100次数字，如果不是88，则继续输入
//找到88就结束
public class TsetBreakAndContinue {
	//1.创建入口函数
	public static void main(String[] args) {
		for(int i=0;i<=100;i++) {
			//3.提示并接收用户输入的数字
			System.out.println("请您输入要猜的数字：");
			int num= new Scanner(System.in).nextInt();
			if(num !=88){
				continue;//继续输入
				/**注意：不管加不加continue，都可以在猜不对的情况下继续输入
				 * 只是在加了continue后效率更高，只要数据不等于88，就无需执行循环后半部分代码
				 * 直接进行下一轮猜数字即可*/
				/**break和continue后都不允许写代码，都是不可到达的代码Unreachable code*/
			}
			System.out.println("我是用来测试continue有没有跳过后半部分代码的！！！");
			if(num==88) {
				System.out.println("恭喜您猜对了！");
				break;
			}
		}
	}
}

4.while 循环（格式）(先判断,再执行)

do while（循环先执行,再判断,循环体代码保证最少执行一次）

while（执行条件）{
循环体；
}

do{
循环体；
}while（执行条件）；

package cn.susu.basic;

import java.util.Random;
import java.util.Scanner;

/**本类用于联系while循环和do-while循环
 * 需求：产生一个随机数，与用户输入的数字作比较，直到用户才对*/

public class TestWhile_doWhile {
	//1.创建程序入口函数
	public static void main(String[] args) {
		int r=createNum();//调用生成随机数的方法,并且接受生成的随机数
		System.out.println("你猜我是几:");
//		guessNum1(r);
		guessNum2(r);
	}
	/**do-while*/
	public static void guessNum2(int r) {
		do {//先执行一次
			//提示并接收用户猜的数据
			System.out.println("大爷，来猜啊~");
			int input=new Scanner(System.in).nextInt();
			//判断用户是否猜对
			if(input>r) {
				System.out.println("猜大了，悠着点~");
			}else if(input<r) {
				System.out.println("猜小了，大胆点！");
			}else if(input==r) {
				System.out.println("厉害啊，猜对了！！！！我是："+r);
				//一定要设置死循环的出口
				break;
			}
		}while(true);

	}
	/**while*/
	public static void guessNum1(int r) {
		//01.写一个死循环
		while(true) {/**死循环一定要设置程序的出口*/
			//02.接收用户输入的值
			System.out.println("你来猜我啊：");
			int input=new Scanner(System.in).nextInt();
			//03.判断用户是否猜对（拿用户输入的input与生成的随机数r作比较）
			if(input>r) {
				System.out.println("猜大了，悠着点~");
			}else if(input<r) {
				System.out.println("猜小了，大胆点！");
			}else if(input==r) {
				System.out.println("厉害啊，猜对了！！！！我是："+r);
				break;
			}
		}
	}
	//2.创建一个用来生成随机数的方法                                         
	public static int createNum() {
		/**注意导包：java.util.Random
		 * 导包的快捷键：Ctrl+Shift+o*/
		/**参数100是自定义的，此时生成的随机数范围是[0,100)的整数*/
		int random=new Random().nextInt(100);
		return random;


	}

}

综合案例：ATM存取款机

package cn.susu.flow;

//模拟ATM机的运行
/*
 *需求:用户输入数字，根据用户数字，我们做相应的处理，在控制台显示相应的操作
 *1.查询
 *2.取款
 *3.存款
 *4.退出,结束错误
 *other：提示输入错误
 */
import java.util.Scanner;
import org.junit.Test;
public class ATM {
	@Test
	public void atm() {
		// 1.获取键盘输入
		Scanner scanner = new Scanner(System.in);// 得到系统监控设备,System.in输入设备（键盘）
		// 死循环，for(;;) 、while(true)，要可以不断输入，直到按键退出
		while (true) {
			try {// 把可能出错的代码放入try中
				int n = scanner.nextInt();// 把键盘输入的内容转换成整数
				// 键盘监控，程序运行起来，程序处于阻塞（等待）状态
				//如果没有输入或者回车，程序就一直等待，等用户输入值回车之后，才会继续运行
				System.out.println("键盘输入" + n);
				// 多分支，只判断值，switch更加简洁
				switch (n) {
				case 1:
					System.out.println("查询");
					break;
				case 2:
					System.out.println("取款");
					break;
				case 3:
					System.out.println("存款");
					break;
				case 4:
					System.out.println("退出");
					return;// 结束程序，return更合适
				default:
					System.out.println("输入错误，请重新输入");
				}
			} catch (Exception e) {// 捕获异常，程序就不会报错了
				System.out.println("出错了：" + e.toString());
				break;//预防错误导致的死循环
			}
		}
	}
}

########################后面是帮助，非代码非文章部分#######################

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

• 关于 Mermaid 语法，参考 [这儿][3],

FLowchart流程图

我们依旧会支持flowchart的流程图：