Java基础——流程控制-（分支+循环）

流程控制

• • 流程控制
  • • 1 、分支机构
    • • 1.1 if-else语句
      • 1.2 switch语句
    • 2 、迭代结构
    • 3、转移语句
    • 4 综合例子：（嘿嘿）

流程控制

Java程序通过控制语句来执行程序流，从而完成一定的任务。Java中的控制语句有以下几类：

​ -分支结构：if-else 、switch;
​ -迭代结构：while、do-while、for；
​ -转移语句：break、continue、return。

1 、分支机构

​ 分支结构是根据假设的条件是否成立，在决定执行什么样的语句的结构，它的作用让程序更具有选择性。
​ Java中通常将假设条件以布尔表达式的方式实现。Java中提供的分支有：
​ ——if-else语句
​ ——switch语句

1.1 if-else语句

if-else语句是常用的分支结构，它分为单分支、多分支与嵌套分支。

1.1.单分支

语法结构：

if(判断条件){
	    代码。。。
	}

语法解释：判断条件 是布尔表达式，结构为true或false；代码。。。：表示语句块。
当判断条件为true时，执行{ }里面的代码块的内容。
如下：

if(year/4==0 && year/100!=0 ||year/400==0) {
			System.out.println("您输入的年份是："+year+"年,是润年");
		}

1.1.2 多分支

结构图：

语法结构：

if(判断条件){
    代码1。。。
}else{
    代码2。。。
}

语法解释：判断条件 是布尔表达式，结构为true或false；代码。。。：表示语句块。
当判断条件为true时，执行{代码1。。。 }里面的代码块的内容，否则执行{代码2。。。 }里面的代码块的内容
例如：

if(year/4==0 && year/100!=0 ||year/400==0) {
		System.out.println("您输入的年份是："+year+"年,是润年");
	}else {
		System.out.println("您输入的年份是："+year+"年,是平年");
	}

1.1.3 嵌套分支

在分支里面在进行分支，形成多层分支！
语法结构：

if(判断条件1){
    代码1。。。
}else if(条件2){
    代码2。。。
} else if(判断条件3){
    代码3。。。
}else{
    代码4。。。
}

if(year/4==0 && year/100!=0) {
		System.out.println("您输入的年份是："+year+"年,是润年");
	}else if(year/400==0){
		System.out.println("您输入的年份是："+year+"年,是润年");
	}else {
		System.out.println("您输入的年份是："+year+"年,是平年");
	}

if(year/4==0 && year/100!=0) {
		System.out.println("您输入的年份是："+year+"年,是润年");
	}else{
    	if(year/400==0){
			System.out.println("您输入的年份是："+year+"年,是润年");
		}else {
			System.out.println("您输入的年份是："+year+"年,是平年");
		}
	} 

判断成绩案例：

public static void main(String[] args) {
		
		if(score > 0 && score < 100) {//判断分数是否在范围区间
			if(score>90) {
				System.out.println("优秀");
			}else if(score>80) {
				System.out.println("良好");
			}else if(score>70) {
				System.out.println("中等");
			}else if(score>60) {
				System.out.println("及格");
			}else{
				System.out.println("不及格");
			}	
		}else {
			System.out.println("请您输入成绩"+score+"不在在范围内，请您输入标准成绩！！");
		}
	}
	}

注意：
​ -在if判断的判别表达式中，不支持同时两边判别，比如：1<x<3 这样是不支持的，如果要表达这样的内容可以加入逻辑运算符来连接，比如： 1<x && x<3 这样是可行 的！

1.2 switch语句

​ 当一个case成立，从这个case向后穿透所有的case，包括default，直到程序结束或者遇到break程序才结束。

形式：

switch(变量或者表达式){
        case 常量1:
        case 常量2:
        case 常量3:  
    	case 常量4:  break；
        default:
}

​ -switch语句把表达式返回的值依次与每个case句子中的值相比较，如果遇到匹配的值，则执行case后面的语句块；
​ -switch后面的括号中的表达式中返回值的类型必须是int类型或者integer包类型。由于byte、chair、short都可以隐式的转换为int，jdk1.7以后支持String类型。因此也是支持的。
​ -case句子中的值必须是常量，并且也是int类型或者integer包类型、byte、chair、short类型之一，并且每一个case句子中的值应该是不同的！
​ -default是可选的！
​ -break语句是用来执行完哟一个case后，使程序跳出switch语句，终止switch语句的执行！

	public static void main(String[] args) {
		
		System.out.println("请输入1~5内的数字！");
		int a =  new Scanner(System.in).nextInt();
		
		switch(a) {
		case 1:System.out.println(a);break;
		case 2:System.out.println(a);break;
		case 3:System.out.println(a);break;
		case 4:System.out.println(a);break;
		case 5:System.out.println(a);break;
		default:System.out.println("请输入范围内的数字！");
		}
	}

2 、迭代结构

迭代结构的作用是反复执行一段代码，由循环体中的条件，判断继续执行代码还推出执行，直到满足终止循环的条件为止。根据判断条件，循环结合又细分为先判断后执行与先执行后判断的结构，在Java中提供的迭代结构有三种：
​ -for语句；（先判断后执行）
​ -while语句；（先判断执行）
​ -do-while语句。（先执行后判断）

2.1 for语句

2.1.1单循环
形式结构

for(开始条件；循环条件；更改条件){
       循环体代码…
}

语法解释：
​ -语句执行时，首先执行初始化（开始条件），然后判断终止条件表达式是否满足（循环条件），如果满足条件，返回值为true，执行循环体代码，循环完一次后，再次判断是否继续执行!

	public static void main(String[] args) {
		for(int i = 0;i<11;i++) {
			System.out.println(i);//打印出1到10
		}	
	}

​ -初始化：开始条件；循环条件；更改条件均可以为空，但是分号不能省略！，三者均为空时，就是一个无线循环！
​ -开始条件（初始化部分）与更改条件（迭代部分）可以使用逗号语句(用逗号分隔的语句序列)来进行多个操作。

for(int i=0,j=20;i<j;i++,j--){
    //循环体代码。。。
    System.out.print("i的值："+i +"   ");
	System.out.print("j的值："+j);
	System.out.println();//换行
}
/**
i的值：0   j的值：20
i的值：1   j的值：19
i的值：2   j的值：18
i的值：3   j的值：17
i的值：4   j的值：16
i的值：5   j的值：15
i的值：6   j的值：14
i的值：7   j的值：13
i的值：8   j的值：12
i的值：9   j的值：11
*/

2.1.2嵌套循环
​ -根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。。

for(开始条件；循环条件；更改条件){
    for(开始条件；循环条件；更改条件){
       循环体代码…
	}
}

例如经典的九九乘法表：

for(int i = 1;i <= 9;i++) {
	for(int j = 1;j <= i; j++) {
			System.out.print(j+"X"+i+"="+i*j+"  ");//不换行，中间加空格
		}
		System.out.println();//换行
	}
/**就是这样子！
1X1=1  
1X2=2  2X2=4  
1X3=3  2X3=6  3X3=9  
1X4=4  2X4=8  3X4=12  4X4=16  
1X5=5  2X5=10  3X5=15  4X5=20  5X5=25  
1X6=6  2X6=12  3X6=18  4X6=24  5X6=30  6X6=36  
1X7=7  2X7=14  3X7=21  4X7=28  5X7=35  6X7=42  7X7=49  
1X8=8  2X8=16  3X8=24  4X8=32  5X8=40  6X8=48  7X8=56  8X8=64  
1X9=9  2X9=18  3X9=27  4X9=36  5X9=45  6X9=54  7X9=63  8X9=72  9X9=81 
*/

经典的质数打印：

public static void main(String[] args) {
		
		int sum = 0,pn, num = 0;
		System.out.println("请输入您需要查询区间的起点数：");
		int min = new Scanner(System.in).nextInt();
		System.out.println("请输入您需要查询区间的终点数：");
		int max = new Scanner(System.in).nextInt();
		
		System.out.println(min+"到"+max+"以内的质数：");
		if(max > min) {
			for(int i = min;i < max; i++) {
				int x = 1;
				for(int j = 1;j < i; j++) {
					if(i % j ==0) {//判断是否质数
						x++;//只能被1和本身整除，x将只会等于2
					}	
				}
				if(x == 2) {//x将只会等于2时，i为质数，打印并计数与求和
					pn = i;
					sum = sum + pn;
					num++;
					if(num % 10 == 0) {
						System.out.println();//满10个换一行
					}
					System.out.print(pn+",");//打印出找到是质数
				}
			}
			System.out.println();
			System.out.println(min+"到"+max+"以内的质数和："+sum);
			System.out.println(min+"到"+max+"以内的质数一共有："+num+"个");
		} else{
			System.out.println("您在跟偶开玩笑哦，最大值"+max+"怎么能比最小值"+min+"小呢！");	
		}	
	}

2.2 while语句

​ while语句是常用的迭代语句。它先判断然后通过判断的返回值来决定要不要执行接下来的代码块的内容。结构为：

while(判断条件){
	//循环体代码块
}

​ while语句的判断表达式的返回结果是布尔类型，若表达式的返回值是true则执行while循环体内的语句，否则结束循环，执行while循环以后的语句。

public static void main(String[] args) {
		int a = 10,b = 15;
		while(a <= b) {
			System.out.println("b比a大"+(b-a));
			b--;
		}
		/**
		  	b比a大5
			b比a大4
			b比a大3
			b比a大2
			b比a大1
			b比a大0
		 */
	}

2.3 do-while语句

​ do-while语句用于至少执行一次的的情形，语句结构为：

do{
	//循环代码块
}while(判断条件)

​ 开始进入循环，首先先执行do-while语句中的do语句块（开始执行循环代码块的内容）。然后计算判断表达式，若表达式的返回值是true则继续执行do-while循环体内的语句，否则结束循环，执行do-while循环以后的语句。

int a = 10,b = 15;
		 do{//不管什么判断条件，先执行
			System.out.println("b比a大"+(b-a));
			b--;
		}while(a <= b);

3、转移语句

Java的转移语句用在选择结构和循环结构中，便于控制程序执行的方向。转移语句有：
​ -break语句；
​ -continue语句;
​ -return语句。

3.1 break语句

break的主要三个作用：
​ -在switch语句中，用于终止case语句序列，跳出switch语句；
​ -在循环结构中，用于终止循环语句序列，跳出循环结构，终止循环而执行循环后面的语句；
​ -与标签语句配合使用，从内层循环或者内层程序块中退出。

for(){
       代码1
if(条件){
  代码3…
    break;//如果成立，直接跳出这个for循环
}
代码2…
}

public static void main(String[] args) {
		
		System.out.println("请输入1~5内的数字！");
		int a =  new Scanner(System.in).nextInt();
		
		switch(a) {
		case 1:System.out.println(a);break;
		case 2:System.out.println(a);break;
		case 3:System.out.println(a);break;
		case 4:System.out.println(a);break;
		case 5:System.out.println(a);break;
		default:System.out.println("请输入范围内的数字！");
		}
	//break，满足条件跳出循环，不在执行后面的语句	
	}

3.2 continue语句

​ continue语句用于for、while、do-while等循环体中是，常与if条件语句一起使用，用来加速循环。满足条件是，跳过本次循环剩下还未执行的语句，再次进入判断语句是否再次循环。

for(){
       代码1
if(条件){
    代码3…
    continue;//如果成立，跳出本次for循环，进入下一轮
}
代码2…
}

3.3 return语句

​ return语句通常用在一个方法的最后，以退出当前方法，主要有两种方式：
​ -return表达式；
​ -return。

​ 当含有return语句的方法被调用时，执行return语句将从当前方法中退出，返回到调用该方法的语句处。
​ 如果执行的是第一种方式，将同时返回表达式执行结果。第二种方式执行后不返回任何值，用于方法声明时明确返回类型为void（空）的方法中。

​ -**注意：**return语句通常放在一个方法的最后，否则会编译错误，除非在if-else语句中。

public static void main(String[] args) {
		int a = 1,b = 2;
		int sum = dosum(a,b);//给方法传入两个数值
		System.out.println(a+"+"+b+" = "+sum);
	}
	public static int dosum(int a,int b) {
		return a + b;//返回a+b是值给调用方法中定义的sum
	}

​ -使用说明
​ -在一个方法中，允许多个return语句，但是每次调用方法时只有一个return语句被执行，由此，方法的执行结果是唯一的。
​ -return语句返回值的类型和方法中定义的类型应该保持一致，两者不一致时，则以方法定义的类为准，自动进行类型转换，如果无法强制转换将会出错。
​ -如果方法的定义类型为void，则在方法中可省略return语句。

4 综合例子：（嘿嘿）

	public static void main(String[] args) {

		System.out.println("亲，请输入1或者2，会有惊喜哦!");
		int a =  new Scanner(System.in).nextInt();
		if(a == 1) {
			for(int i=1;i<6;i++) {
				switch(i) {
				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;
				}
				try {
					Thread.sleep(1000);//控制每一秒执行依次
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}else if(a == 2){
			for(int i=1;i<6;i++) {
				switch(i) {
				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;
				}
				try {
					Thread.sleep(1000);//控制每一秒执行依次
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}