java语法（下）：三种基本流程结构

一、顺序结构

1、三种基本流程结构

顺序结构、分支结构、循环结构

二、分支结构

写在前面：分支结构分成if…else和switch…case

1、if…else结构

（1）if语句三种格式


（2）if-else结构使用说明

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

import java.util.Scanner;
class IfTest2{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        System.out.println("请输入第一个整数: ");
        int num1 = scan.nextInt();
        System.out.println("请输入第二个整数: ");
        int num2 = scan.nextInt();
        System.out.println("请输入第三个整数: ");
        int num3 = scan.nextInt();
        
        if(num1 >= num2){
            if(num3 >= num1){
                System.out.println(num2 + "," + num1 + "," + num3);
            }
            else if(num3 <= num2){
                System.out.println(num3 + "," + num2 + "," + num1);
            }
            else{
                System.out.println(num2 + "," + num3 + "," + num1);
            }
        }
        else{
            if(num3 >= num2)
                System.out.println(num1 + "," + num2 + "," + num3);
            else if(num3 <= num1)
                System.out.println(num3 + "," + num1 + "," + num2);
            else
                System.out.println(num1 + "," + num3 + "," + num2);
        }
        
    }        
}

2、switch-case结构

（1）switch-case语句格式

switch(表达式){
case 常量1:
语句1;
// break;
case 常量2:
语句2;
// break; … …
case 常量N:
语句N;
// break;
default:
语句;
// break;
}

（2）switch-case结构使用说明

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

/*
使用switch-case结构
例题1：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

说明:如果switch-case中的多个case的执行语句相同，则可以合并多个case
*/
class SwitchCaseTest2{
    public static void main(String[] args){
        int score = 78;
        switch(score / 10){
            case 0:            
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不及格");
                break;
            case 6:
            case 7: 
            case 8:
            case 9:
            case 10:
                System.out.println("及格");
                break;
        }
        
        //更优的解决方案
        switch(score / 60){
            case 0:
                System.out.println("不及格");
                break;
            case 1:
                System.out.println("及格");
                break;
        }
    }
}

3、switch-case与if-else的转换说明

• 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
• 我们写分支结构时，当发现既可以使用switch-case，（同时，switch中的表达式的取值情况不太多），又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

三、循环结构

写在前面：4个要素
（1)初始化条件
（2)循环条件---->是boolean类型
（3)循环体
（4)迭代条件

2、for循环的使用

• （1）语法格式：
  for (①初始化部分; ②循环条件部分; ④迭代部分)｛ ③循环体部分; ｝

• （2）执行过程：
  ①-②-③-④-②-③-④-②-③-④-…-②

• （3）说明：
  ②循环条件部分为boolean类型表达式，当值为false时，退出循环
  ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
  ④可以有多个变量更新，用逗号分隔

/*
For循环结构的使用
一、循环结构的4个要素
1)初始化条件
2)循环条件---->是boolean类型
3)循环体
4)迭代条件

二、for循环的结构
for(1);2);4)){
    3)
}

执行过程：1) - 2) - 3) - 4)- 2) - 3) - 4) ... - 2)
*/

class ForTest{
    public static void main(String[] args){
        
        for(int i = 1; i <= 5;i++){
            System.out.println("HelloWorld!");
        } 
        //i:在for循环内有效。出了for循环就失效了。        
        //System.out.println(i);

        //练习：
        int num = 1;
        for(System.out.print('a'); num <= 3; System.out.print('c'),num++){
            System.out.print('b');
        }
        //输出结果：abcbcbc
        System.out.println();
       
        //例题：遍历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);
        
    }
}

3、while循环的使用

• （1）语法格式：
  ①初始化部分
  while(②循环条件部分)｛ ③循环体部分; ④迭代部分; }
• （2）执行过程：
  ①-②-③-④-②-③-④-②-③-④-…-②
• （3）说明：
  注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。 for循环和while循环可以相互转换

/*
while循环的使用

一、循环结构的4个要素
1)初始化条件
2)循环条件---->是boolean类型
3)循环体
4)迭代条件


二、while循环的结构
1)
while(2)){
    3);
    4);
}

说明：
1.写while循环要小心不能丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。

算法:有限性。
*/

class WhileTest{
    public static void main(String[] args){
        //遍历100以内的所有偶数
        int i = 1;
        while(i <= 100){
            
            if(i % 2 == 0){
                System.out.println(i);
            }
            
            i++;
        }
        //出了while循环以后，仍可以调用
        System.out.println(i);  //101
    }
}

4、do-while循环的使用

• (1）语法格式
  ①初始化部分;
  do{
  ③循环体部分
  ④迭代部分
  }while(②循环条件部分);

• （2）执行过程：
  ①-③-④-②-③-④-②-③-④-…②

• （3）说明：
  do-while循环至少执行一次循环体

/*
do-while循环的使用

一、循环结构的4个要素
1)初始化条件
2)循环条件---->是boolean类型
3)循环体
4)迭代条件


二、do-while循环的结构

1)
do{
    3);
    4);
}while(2));

执行结构：1) - 3) - 4) - 2) - 3) - 4) - 2) - ... - 2)


说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
*/
class DoWhileTest{
    public static void main(String[] args){
        //遍历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);
        
        
        //******体会do-while至少执行一次循环体*************
        int number1 = 10;
        while(number1 > 10){
            System.out.println("hello:while");
            number1--;
        }
        
        int number2 = 10;
        do{
            System.out.println("hello:do-while");
            number2--;
        }while(number2 > 10);
        
    }
}

5、嵌套循环的使用（多重循环）

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

/*
嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

2.内层循环：循环结构A
  外层循环：循环结构B
  
3.说明：
1.内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
2.假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n 次。


4.技巧：
    外层循环控制行数，内层循环控制列数
*/
class ForForTest{
    public static void main(String[] args){
        //******
        //System.out.print("******");
        
        for(int i = 1; i <= 5;i++){
            System.out.print('*');
        }
        
        /*
        ******
        ******
        ******
        ******
        */
        System.out.println();
        for(int j = 1; j <= 4; j++){
            for(int i = 1; i <= 5;i++){
                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();
        }
        /*
        ****
        ***
        **
        *
        */
        for(int i = 1; i <= 4; i++){
            for(int j = 1; j <= 4 - i + 1;j++){
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

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

1、特殊流程控制语句(一)——break 语句

（1）break语句使用，用于终止某个语句块的执行
{ ……
break;
……
}
2、break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是
哪一层语句块

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

2、特殊流程语句控制(二)——continue 语句

（1）使用说明

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

（2）continue语句用法举例

public class ContinueTest {
	public static void main(String args[]){
		for (int i = 0; i < 100; i++) {
			if (i%10 == 0){
				continue;
			}
			System.out.println(i); 
		} 
	} 
}

3、特殊流程控制语句说明

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
• 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条
  语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同
  于goto的。
• break、continue用法举例：

/*
break和continue关键字的使用
                使用范围                循环中使用的作用(不同点)           相同点
break：        switch-case               
               循环结构中                   结束当前循环                      
                                                                        关键字后面不能声明执行语句    
continue       循环结构中                   结束当次循环，开始下次循环
*/
class BreakContinueTest{
    public static void main(String[] args){
        for(int i = 1; i <= 10; i++){
            
            if(i % 4 == 0){
                break;  //123
                //continue; //123567910
                //System.out.println("今晚月色真美");
            }
            System.out.print(i);
            
        }
        System.out.println("\n");
        
        label:for(int i = 1; i <= 4;i++){
            for(int j = 1; j <= 10;j++){
                if(j % 4 == 0){
                    //break;    //默认跳出包裹此关键字最近的一层循环
                    //continue;
                    
                    //break label;  //结束指定标识的一层循环结构
                    continue label;  //结束指定标识的一层循环结构的当此循环
                
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}