Java基础语法-第五节-流程控制

程序控制结构

• 定义：程序控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑块
• 其流程控制方式采用结构化程序设计中的三种基本流程结构，即
  • 顺序结构：程序从上到下逐行执行，中间没有任何判断和跳转
  • 分支结构：
    • 根据条件，选择性的执行某段代码
    • 有if...else和switch-case两种分支语句
  • 循环结构
    • 根据循环条件，重复性的执行某段代码
    • 有while,do....while,for三种循环语句
    • 注：JDK1.5提供了foreach循环，方便的遍历集合，数组元素

顺序结构

• Java中定义成员变量时采用合法的前向引用。如：

public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2；
int num1 = 12;
}

分支结构

if-else结构

//举例1
int heartBeats=79;
if(heartBeats <60||heartBeats>100){
    System.out.println("你需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age<18){
    System.out.println("你还可以看动画片");
}else{
    System.out.println("你可以看电影了");
}
//举例3
if(age<0){
    System.out.println("你输入的数据非法");
}else if(age<18){
    System.out.println("青少年时期");
}else if(age<35){
    System.out.println("青壮年时期");
}else if(age<60){
    System.out.println("中年时期");
}else if(age<120){
    System.out.println("老年时期");
}else {
    System.out.println("你已经成仙了");
}

• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
• 当多个条件是“包含”关系时，“小上大下 / 子上父下”

switch-case结构

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，
  char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
• case子句中的值必须是常量，不能是变量名或不确定的表达式值；
• 同一个switch语句，所有case子句中的常量值互不相同；
• break语句用来在执行完一个case分支后使程序跳出switch语句块；如
  果没有break，程序会顺序执行到switch结尾
• default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，
  执行default

int number = 2;
switch(number){
    case 0:
        System.out.println("zero");
        break;
    case 1:
        System.out.println("one");
        break;
    case 2:
        System.out.println("two");
        break;
    case 3:
        System.out.println("three");
        break;
    default:
        System.out.println("other");
}
//**********编译错误的情况***********
//举例1：③的反例
boolean isHandsome = true;
switch(isHandsome){
    case true:
        System.out.println("true");
        break;
    case false:
        System.out.println("false");
        break;
    default:
        System.out.println("error");
}
//举例2：④的反例
int age = 10;
switch(age){
    case age>18:
        System.out.println("成年了");
        break;
    default:
        System.out.println("未成年");
}

循环结构

• 循环结构:在某些条件满足的情况下，反复执行特定代码的功能
• 循环语句分类
  • for 循环
  • while 循环
  • do-while 循环
• 循环语句的四个组成部分
  • 初始化部分(init_statement)
  • 循环条件部分(test_exp)
  • 循环体部分(body_statement)
  • 迭代部分(alter_statement)

for 循环

• 语法格式

  for (①初始化部分; ②循环条件部分; ④迭代部分)｛
      ③循环体部分;
  ｝ 
  

• 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②

• 说明

• 循环条件部分为boolean类型表达式，当值为false时，退出循环

• 初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔

• 迭代部分可以有多个变量更新，用逗号分隔

for(int i = 1;i <= 5;i++){
    System.out.println("Hello World!");
}
//练习
int num = 1;
for(System.out.print("a");num<=3;System.out.print("c"),num++){
    System.out.print("b");
}
//输出abcbcbc
//例题：遍历100以内的偶数，输出所有偶数的和和偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
    if(i%2==0){
        System.out.println(i);
        sum += i;
        count++;
    }
}
System.out.println("所有偶数的和："+sum);
System.out.println("偶数的个数："+count);

while循环

• 语法格式

①初始化部分
while(②循环条件部分)｛
    ③循环体部分;
	④迭代部分; 
} 

• 执行过程：①-②-③-④-②-③-④-②-③-④-...-②
• 说明：
  • 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
  • for循环和while循环可以相互转换

//遍历100以内的偶数
int i = 1;
while(i <= 100){
    if(i % 2 == 0){
        System.out.println(i);
    }
    i++;
}
//出了while循环以后，仍可以调用
System.out.println(i);//101

do-while 循环

• 语法格式

①初始化部分;
do{
	③循环体部分
	④迭代部分
}while(②循环条件部分);

• 执行过程：①-③-④-②-③-④-②-③-④-...②
• 说明：
  • do-while循环至少执行一次循环体

//遍历100以内的偶数,并计算所有偶数的和即偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
int num = 1;
do{
    if(num%2==0){
        System.out.println(num);
        sum += num;
        count++;
    }
    num++;
}while(num <= 100);
System.out.println("所有偶数的和："+sum);
System.out.println("偶数的个数："+count);

嵌套循环

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

//打印******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
    System.out.print('*');//也可以写成"*"
}
System.out.println();
/*
打印******
******
******
******
******
*/
for(int i = 1;i <= 5;i++){
    for(int j = 1;j <= 6;j++){
        System.out.print('*');
    }
    System.out.println();
}
/*				i(行号)		j(*的个数)
打印*			   1			1
   **		    2			 2
   ***			3			 3
   ****		    4			 4
   *****		5			 5
*/
for(int i = 1;i <= 5;i++){		//控制行数
    for(int j = 1;j <= i;j++){ 	//控制列数
        System.out.print('*');
    }
    System.out.println();
}
/*				i(行号)		j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i 
打印*****		   5			5
   ****		    4			 4
   ***			3			 3
   **			2			 2
   *			1			 1
*/
for(int i = 1;i <= 5;i++){		//控制行数
    for(int j = 0;j <= 5-i;j++){ 	//控制列数
        System.out.print('*');
    }
    System.out.println();
}

//输出100000以内的质数
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
//获取当前时间距1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){
    for(int j = 2;j <= Math.sqrt(i);j++){//优化二：对本身质数的自然数是有效的
        if(i % j == 0){
            isFlag = false;
            break;//优化1：只对本身非质数的自然数是有效的
        }
    } 
    if(isFlag){
        System.out.println(i);
    }
    //重置isFlag
    isFlag = true;
}
//获取当前时间距1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
//输出运算的时间
System.out.println(end-start);
/*
优化前：15232
优化1后: 1965
优化1和2后: 660
*/

特殊关键字的使用：break、continue

• break语句

  • break语句用于终止某个语句块的执行

  { ……
  break;
  ……
  } 
  

  • break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

  label1: { ……
  label2: 	{ ……
  label3: 		{ ……
  				  break label2;
  				  ……
  				} 
              } 
          }
  

• continue 语句

  • continue只能使用在循环结构中
  • continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
  • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
  • continue语句用法举例

  for (int i = 0; i < 100; i++) {
  	if (i%10==0)
  		continue;
  	System.out.println(i); 
  }
  

label:for(int i = 0;i <= 4;i++){
    for(int j = 1;j <= 10;j++){
        if(j % 4 == 0){
            //break;//默认跳出包裹此关键字最近的一层循环
            //continue;
            //break label;//结束指定标识的一层循环结构
            continue label;//结束指定标识的一层循环结构当此循环			
        }
        System.out.print(j);
    }
}

附加：特殊流程控制语句3

Scanner输入

• 从键盘或控制台获取输入的变量

• 具体实现步骤

  1. 导包：import java.util.Scanner

  2. Scanner的实例化：Scanner scan = new Scanner(System.in);

  3. 调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量

  • 注意：需要根据相应的方法来输入指定类型的数据。如果输入的数据类型跟要求的类型不匹配时会报异常：InputMismatchException 导致程序终止

import java.util.Scanner;
class Test{
	public static void main(String[] args){
		Scanner scan  = new Scanner(System.in);
		System.out.println("请输入你的姓名：");
		String name  = scan.next();
		System.out.println(name);
		System.out.println("请输入你的芳龄：");
		int age  = scan.nextInt();
		System.out.println(age);
		System.out.println("请输入你的体重：");
		double weight  = scan.nextDouble();
		System.out.println(weight);
		System.out.println("你是否相中了我呢？(true/false)");
		boolean isLove  = scan.nextBoolean();
		System.out.println(isLove);
		//对于char类型的获取，Scanner没有提供相关的方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();//"男”
		char genderChar = gender.charAt(0);//获取字符串索引为0位置上的字符
		System.out.println(genderChar);
	
	}
}	

总结

*一，分支结构中的if-else（条件判断结构）
*	三种形式
*		第一种：
*		if(条件表达式){
*		}
*		第二种：二选一
*		if(条件表达式){
*			执行语句1
*		}else{
*			执行语句2
*		}
*		第三种：多选一
*		if(条件表达式1){
*			执行语句1
*		}else if(条件表达式2){
*			执行语句2
*		}else if(条件表达式3){
*			执行语句3
*		}else if(条件表达式3){
*			执行语句3
*		}.....else{
*			执行语句n
*		}
*
*二，分支结构中的switch-case
*	1.格式
*		switch(表达式){
*			case 常量1：
*				执行语句1；
*				//break;
*			case 常量2：
*				执行语句2；
*				//break;
*			...
*			default：
*				执行语句n；
*				//break;
*		}
*	2.说明
*		①根据switch表达式中的值，依次匹配各个case中的常量。
*		一旦匹配成功，则进入相应的case结构中。调用其执行语句。
*		当调用完执行语句后，则仍然继续向下执行其他case结构中的执行语句，
*		直到遇到break关键字或此switch-case结构末尾为止结束
*		②break关键字可以使用在switch-case中，表示一但执行到此关键字，
*		就跳出switch-case结构
*		③switch-case结构中的表达式，只能是如下的6种数据类型之一：
*			byte,short,char,int,枚举类型(JDK5.0新增)，String类型(JDK7.0新增)
*		④case之后只能声明常量，不能声明范围
*		⑤break关键字是可选的
*		⑥default:相当于if-else的else.也是可选的。而且位置是灵活的
*		⑦凡是可以使用switch-case的结构，都可以转换成if-else.反之不成立
*		⑧我们在写分支语句时，当发现既可以使用switch-case的结构(同时，
*		switch中表达式的取值情况不太多)，又可以使用if-else时，我们会优先使用switch-case。
*		原因：switch-case的执行效率比if-else稍高
*三，循环结构
*	循环语句的四个要素
*		①初始化部分
*		②循环条件部分 -->是boolean类型
*		③循环体部分
*		④迭代部分
*	1:for循环结构
*		for(①;②;④){
*			③
*		}
*		执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
*	break:在循环中，一旦遇到break,则跳出循环
*	2:while循环结构
*		①
*		while(②){
*			③;
*			④;
*		}
*		执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
*		注意：
*		1.写while循环时千万不要丢了迭代条件。一旦丢了，就可能导致死循环！
*		2.我们写程序，要避免死循环
*		3.for循环和while循环是可以相互转换的！
*		  区别：for循环和while循环的初始化条件的作用范围不同
*		
*	算法：局限性	
*	3:do-while循环结构
*		①
*		do{
*			③;
*			④;
*		}while(②);
*		执行过程：① - ③ - ④ - ② - ③ - ④ - ...-②
*		说明：
*		1.do-while循环至少会执行一次循环
*		2.开发中，使用for和while会更多一些，较少使用do-while
*	补充：
*	1.不在循环条件部分限制次数的结构：for(;;)或while(true)
*	2.结束循环有几种方式？
*		方式一：循环条件部分返回false
*		方式二：在循环体中，执行break;
*四，嵌套循环
*	1.嵌套循环：将一个循环结构A声明在另一个循环结构B中，就构成了嵌套循环
*	2.外层循环：循环结构A
*	  内层循环：循环结构B
*	3.说明：
*		①内层循环结构遍历一遍，只是相当于外层循环循环体执行了一次
*		②假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体共执行了m * n次
*	4.技巧：外层循环控制行数，内层循环控制列数
*五，break和continue关键字的使用
*				使用范围			循环中使用的作用(不同点)				相同点
*break 			switch-case				结束当前循环				关键字后面不能声明执行语句
*				循环结构中
*				
*continue  		循环结构中				结束当次循环				关键字后面不能声明执行语句
*
*
*如何从键盘获取不同类型的变量：需要使用Scanner类
*具体实现步骤：
*	1.导包：import java.util.Scanner
*	2.Scanner的实例化：Scanner scan  = new Scanner(System.in);
*	3.调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量
*	注意：
*	需要根据相应的方法来输入指定类型的数据。如果输入的数据类型跟要求的类型不匹配时
*	会报异常：InputMismatchException 导致程序终止
*	
*
//练习：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
while(true){
    int number = scan.nextInt();
    //判断number的正负情况
    if(number > 0){
        positiveNumber++;
    }else if(number < 0){
        negativeNumber++;
    }else{
        //一旦执行break,跳出循环
        break;
    }
}
System.out.println("输入的正数的个数为："+positiveNumber);
System.out.println("输入的负数的个数为："+negativeNumber);