Java基础---流程控制

流程控制(顺序结构-分支结构-循环结构-结束循环的语句)

顺序结构

从上往下依次执行，一句一句的执行，每一行代码都会执行

分支结构

分支结构是有条件的执行某些语句，不是每一行都执行
包括:
	if分支
		一条分支
		两条分支
		多条分支
	switch分支

if分支

if一条分支

	if一条分支(语句块不一定执行)
		语法:
			if(boolean类型的表达式){
				语句块
			}
		语境:
			如果怎么样就怎么样
		执行流程：
			如果boolean类型的表达式的值为true,则执行语句块
			如果boolean类型的表达式的值为false,则不执行语句块
			无论语句块是否执行，都不影响后面程序的执行
		使用注意:1):不能在if(boolean表达式)后使用分号

/**
 * 演示if一条分支
 * @author JackeyLov9
 *
 */			
import java.util.Scanner;                                                                
public static void main(String[ ] args) {
		//创建一个Scanner的对象实例
		Scanner scan = new Scanner(System.in);
		//提醒用户输入
		System.out.println("请输入您的年龄:");
		//接收控制台的输出
		int age = scan.nextInt();
		//if一条分支(如果if中的语句块只有一句，那么可以不使用大括号，一般建议无论有多少句都是用大括号)
		//如果不使用大括号，则只有离if最近的一句受到if的控制
		if(age < 18) {
			System.out.println("小屁孩儿");
		}
		System.out.println("程序继续");
	}

if两条分支

	if两条分支(语句块1和语句块2必定会二选一执行)
		语法:
			if(boolean类型的表达式){
	    		语句块1                                                                
	        }else{
	            语句块2
	        }
		语境:
			如果怎么样就怎么样，否则就怎么样
		执行过程:
			如果boolean类型的表达式的值为true，则执行语句块1
			如果boolean类型的表达式的值为false，则执行语句块2
			无论执行语句块1还是执行语句块2，都不影响后面程序的执行
		使用注意:1):不能在if(boolean表达式)后使用分号
	    		2):不能直接使用else语句

/**
 * 演示if二条分支
 * @author JackeyLov9
 *
 */
import java.util.Scanner;
public static void main(String[] args) {
		//创建Scanner对象的实例
		Scanner scan = new Scanner(System.in);
		//接收用户输入的数据
		System.out.println("请输入金额:");
		double money = scan.nextDouble();
		//if两条分支判断 	如果满50则减10，否则就是原价
		if(money >= 50) {
			money -= 10;
		}else {
			System.out.println("不满足活动要求");
		}
		System.out.println("实付金额:" + money);
	}

if多条分支

	if多条分支结构(最多也只会执行一个分支)
		语法:
			if(boolean类型表达式1){
	    		语句块1
	        }else if(boolean类型表达式2){
	             语句块2
	        }else if(boolean类型表达式3){
	            语句块3	
	        }...[else{
	            语句块
	        }]
	     语境:
			 如果怎么样就怎么样,否则如果怎么样就怎么样...[否则就怎么样]--------有多种情况的选择时使用
			 
		 执行过程:
		 	 从上到下依次判断,如果表达式1为true,则执行语句块1,后面的表达式就不再判断,如果表达式1为false,则再判断表达式2，如果表达式2为true,则执行语句块2,如果表达式2也为false,则以此类推去判断表达式3...
		 	最后如果所有表达式都为false,那么则执行else后面的语句块,如果没有else则直接执行后面的程序
		 使用注意:1):不能在if(boolean表达式)后使用分号
	    		 2):不能直接使用else if语句,必须先使用if语句 	
		 		 3):此时的else的语句表示上述所有条件都为false时才会执行的代码

/**
 * 演示if多条分支
 * @author JackeyLov9
 *
 */
import java.util.Scanner;
public static void main(String[] args) {
		//创建Scanner对象的实例
		Scanner scan = new Scanner(System.in);
		//提醒用户输入
		System.out.println("请输入消费金额:");
		//接收用户输入的数据
		double money = scan.nextDouble();
		//判断(方法一)
//		if(money >= 500 && money < 800) {
//			money *= 0.8;
//		}else if(money >= 800 && money <1000) {
//			money *= 0.7;
//		}else if(money >= 1000) {
//			money *= 0.5;
//		}else {
//			System.out.println("您的消费金额不满足活动要求");
//		}
		//判断(方法二)
		if(money >= 1000) {
			money *= 0.5;
		}else if(money >= 800) {
			money *= 0.7;
		}else if(money >= 500) {
			money *= 0.8;
		}else {
			System.out.println("您的消费金额不满足活动要求");
		}
		System.out.println("您的实际消费金额:" + money);
		//提示用户输入支付金额
		System.out.println("请输入支付金额:");
		//接收支付金额
		double money1 = scan.nextDouble();
		//判断
		if(money1 < money) {
			System.out.println("支付金额不足");
		}else {
			//找零
			double sum = money1 - money;
			System.out.println("找零金额" + sum);
		}
	}

switch分支

表达式的数据类型为char

/**
 * 演示switch支持char类型
 * 
 * @author JackeyLov9
 *
 */
public class SwitchDemo1 {
	public static void main(String[] args) {
		char sex = '猫';
		switch (sex) {
			case '男':
				System.out.println("这是一个男人");
				break;
			case '女':
				System.out.println("这是一个女人");
				break;
			default:
				System.out.println("不太明白");
				break;
		}
	}
}

表达式的数据类型为int

/**
 * 演示switch表达式为int类型
 * 
 * @author JackeyLov9
 *
 */
public class SwitchDemo2 {
	public static void main(String[] args) {
		int score = 5;
		/*
		 *在使用switch语句的过程中，如果多个case后面的执行语句是一样的时候，
		 *我们可以只书写一次该执行语句即可，这是一个简单的写法 
		 */
		switch(score) {
			//5分和4分都算优秀
			case 5:	
			case 4:
				System.out.println("优秀");
				break;
			case 3:
				System.out.println("还行");
				break;
			case 2:
				System.out.println("一般");
				break;
			default:
				System.out.println("叭行");
				break;
		}
	}
}

表达式的数据类型为String

/**
 * 演示switch表达式的数据类型为String
 * @author JackeyLov9
 *
 */
public class SwitchDemo3 {
	public static void main(String[] args) {
		//创建Scanner对象实例
		Scanner scan = new Scanner(System.in);
		//提醒用户输入
		System.out.println("请输入当前段位:");
		//接收用户输入的数据
		String str = scan.next();
		switch(str) {
			case "黑铁":
				System.out.println("纯脑瘫");
				break;
			case "青铜":
				System.out.println("用脚在玩游戏？");
				break;
			case "白银":
				System.out.println("癌症晚期患者");
				break;
			case "黄金":
				System.out.println("癌症中期————有点意识");
				break;
			case "铂金":
				System.out.println("癌症早期————有秀的操作");
				break;
			case "钻石":
				System.out.println("守门员");
				break;
			case "大师":
				System.out.println("菜得像个大师");
				break;
			case "宗师":
				System.out.println("比炒饭大师强");
				break;
			case "王者":
				System.out.println("贴吧人均水平");
				break;
			default:
				System.out.println("三十级二十英雄都没有的渣渣");
				break;
		}
	}
}

表达式的数据类型为枚举

/**
 * 演示switch语句支持枚举类型
 * @author JackeyLov9
 *
 */
public class SwitchDemo4 {
	public static void main(String[] args) {
		//声明一个枚举类型
		Season sea = Season.WINTER;
		//switch表达式支持枚举类型
		switch(sea) {
			case SPRING:
				System.out.println("动物交配");
				break;
			case SUMMER:
				System.out.println("野狗撒欢");
				break;
			case AUTUMN:
				System.out.println("秋风踩落叶");
				break;
			case WINTER:
				System.out.println("大约在冬季");
				break;
			default:
				System.out.println("四季以外的生物");
				break;
		}
	}
}

//声明一个枚举类型
enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}

if和switch的选择

	if和switch都属于选择语句,也就是说功能是相似的
	
	if:			判断条件是boolean类型的
	switch		判断条件是整数表达式 ==int类型的值.
	
	发现,switch只能适合对整数的值做判断,如果是其他类型的判断,只能使用if语句
	选择:如果是对整数表达式判断等于多少，首选使用switch.
		其它情况使用if语句

循环结构

	当需要重复的去做相同的事情时就要选择使用循环结构
	重复的执行某一段代码块
		重复的执行相同的逻辑则要使用循环结构
	    有条件的执行某语句块多次，但是并非一定全部执行
	
	循环三要素：
			循环变量----在循环过程中发生改变的量叫循环变量
			循环条件----以循环变量为基础的条件
			循环变量的改变(步进)----通常是往循环结束的方向改变
	for循环
	while循环
	do...while循环
		三种，可以完成相同的功能
		仅仅只是语法上有差异
		以上三者循环，在直到具体的循环次数时，优先选择for循环，当不知道具体循环次数时，选择while循环或者 	 do...while循环，当循环体必须执行最少一次时，优先选择do...while循环，否则选择while循环
			
	递归循环
	forEach循环

while循环

	格式:
		while(boolean表达式){
	    		循环体语句;
	             循环变量的改变;
	}
	while循环特点:先判断表达式，若为true就执行循环体，否则，跳过循环体

/**
 * 	演示while循环语句
 * 
 * @author JackeyLove
 */
public class WhileDemo {
	public static void main(String[] args) {
		案例：1):叫五百声帅哥，打印五百次
		
		int count = 0;//表示叫帅哥的次数
		while(count < 500) {
			count ++;
			System.out.println("帅哥" + count);
		}

	 2):从1数到100
	 
	 	int num = 1;//表示第一个数
		while(num <= 100) {
			System.out.println(num);//打印num值
			num ++;
		}
	3):计算100以内的正整数之和
	
		int number = 1;//表示第一个加数
			int result = 0;//表示前n个数之和
			while(number <= 100) {
				result = result + number;
				System.out.println(number);//打印出每一个加数
				number ++;
			}
			System.out.println(result);
	}
}

do…while循环

	格式:
		do{
	        循环语句
	        循环变量的改变
		}while(boolean表达式);
	do while循环特点:先执行一次循环体，再判断表达式，若为true就执行循环体，否则，跳过循环体
	也就是说do while是先执行后判断，即使判断条件为false,该循环至少会执行一次
		for循环与while循环的循环体可能一次都不执行(先判断再执行)

/**
 * 	演示do while循环语句
 * @author JackeyLove
 * @date 2019年11月24日下午11:04:29
 */
public class DoWhileDemo {
	public static void main(String[] args) {
		/*
		 * do{
		 * 		循环体(需要重复干的事情)
		 * }while(boolean表达式);
		 * 
		 */
//		boolean boo = false;
//		do {
//			System.out.println("Hello");
//		}while(boo);
		//案例1):叫500声帅哥
		int count = 0;
		do {
//			System.out.println("帅哥");
			count ++;
		}while(count < 500);
		//案例2):从1数到100
		int num = 1;//表示第一个数
		do {
//			System.out.println(num);
			num ++;
		}while(num <= 100);
		//案例3):计算100以内的整数和
		int number = 1;//表示第一个加数
		int result = 0;//最终的和
		do {
			result = result + number;//==>result += number;
			number ++;
		}while(number <= 100);
		System.out.println(result);
	}
}

for循环

	格式:
	for(初始化语句;boolean表达式;循环后操作语句){
	    	循环体语句
	}
	执行流程:
			(1.初始化语句:表示对循环进行初始化,只在循环开始时执行一次,定义一个变量并赋值
			2.boolean表达式:表达式为false时,循环终止，为true才执行循环体
			3.循环后操作语句:循环每次迭代之后会调用该语句,一般的该语句都是递增或递减操作)
			1.循环变量的初始化		只执行一次
			2.判断循环条件是否成立
				如果结果为true，则执行循环体
				如果结果为false，则结束循环体
			3.当循环体执行后，执行循环变量的改变
			4.接下来回到第二步,知道循环条件的结果为false时,结束循环
	
	一般的，在for循环值的循环迭代变量起名规则:
		见过最多的循环变量名称:i j k m n

/**
 * 	演示for循环语句
 * 	
 * @author JackeyLove
 * @date 2019年11月24日下午11:26:00
 */
public class ForDemo {
	public static void main(String[] args) {
		/*
		 * for(初始化语句;boolean表达式;循环后操作语句){
		 * 			循环体语句
		 * }
		 * 
		 * 	执行顺序:
		 * 		1):初始化语句
		 * 		2):boolean表达式
		 *				true:进入第3步
		 * 				false:跳过循环
		 *		3):执行循环体
		 *		4):执行循环之后的操作语句
		 *		5):进入第2步
		 *	注意:初始化语句只在最开始的时候执行一次
		 */
		//案例1):叫500声帅哥
		for(int count = 0; count < 500; count ++) {
//			System.out.println("帅哥" + count);
		}
		//案例2):从1数到500
		for(int num = 1; num <= 100; num ++) {
//			System.out.println(num);
		}
		//案例3):计算100以内的整数和
		int result = 0;//结果之和
		for(int number = 1; number <=100; number ++) {
			result += number;
		}
		System.out.println(result);
	}
}

结束循环的语句

	break;	结束当前循环
	return;	结束整个方法
	System.exit(0);	结束虚拟机
	continue;	结束本次循环，继续下一次循环，也就是说continue之后的内容本次循环不再执行，接着进行下一次循环
	break 标记	跳出标记的循环
	
	注意:
	break、continue、 return后面的语句永远没有机会执行,所以不能再跟任何语句,否则编译失败
	
	break 和 return 都能结束当前循环，如何选择问题:
	如果循环之后的操作还执行就用break，否则就用return

break

结束当前循环

//求出100以内前5个3的倍数的数字:
    
  public class BreakDemo {
	public static void main(String[] args) {
		//3 6 9 12 15 18 21....
		//1.循环出100以内的所有数字
		//2.判断哪些能被3整除的数
		//3.如果是3的倍数用计数器计数
		//4.当计数器等于5的时候终止循环
		int sum = 0;//计算器从0开始
		for(int i = 1;i<=100;i++) {
			if(i%3==0) {
				sum++;
				System.out.println(i);
			}
			if(sum==5) {
				break;
			}
		}
	}
}

continue

结束本次循环，继续下一次循环，也就是说continue之后的内容本次循环不再执行，接着进行下一次循环

public static void main(String[] args) {
		//从1输出到10
		for(int i=1;i<=10;i++) {
			//跳过4输出
			if(i==4) {
				continue;//跳过当前循环,进行下一次循环
			}
			System.out.println(i);
		}
		System.out.println("-------------");
		//输出100~200之间不能被3整除的数
		for(int i=100;i<=200;i++) {
			if(i%3==0) {
				continue;
			}
			System.out.println(i);
		}
	}

return

结束整个方法

public class ReturnDemo {
	public static void main(String[] args) {
		//从1输出到10(用break来结束)
		for(int i =1;i<=10;i++) {
			//输出到7就结束循环
			if(i==7) {
				break;//跳出循环/终止循环
			}
			System.out.println(i);
		}
		System.out.println("Ending....");
		System.out.println("-------------");
		//从1输出到10(用return来结束)
		for(int i =1;i<=10;i++) {
			//输出到7就结束循环
			if(i==7) {
				return;//结束所在的方法
			}
			System.out.println(i
					);
		}
		System.out.println("Ending....");
	}
} 

控制外层循环

此时就得使用标签了，标签就是给某个循环起的别名，不过该别名得满足标识符的规范。
若要控制外层循环，就在break或continue后面跟上循环的别名就OK了
如: break <标签名>;

可以去我的个人博客查看更多文章，https://www.sidchai.icu