Java流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块

其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

1. 顺序结构
2. 分支结构
3. 循环结构

1 - 顺序结构

程序从上到下逐行的执行，中间没有任何判断和跳转

2 - 分支结构

根据条件选择性的执行某段代码，有if-else和switch-case两种分支语句

1-凡是可以使用三元运算符的地方，都可以改写成if-else语句，反之则不可以
2-如果程序既可以是三元运算符，又可以使用if-else结构，优先选择三元运算符
　　原因：简洁，执行效率高

3 - 分支结构之if-else结构介绍

 

/*
1-分支结构中if-else结构(条件判断结构)
2-3种结构：
    1.
    if(条件表达式){
        执行表达式
    }
    2.
    if(条件表达式){
        执行表达式1
    }else{
        执行表达式2
    }
    3.
    if(条件表达式){
        执行表达式1
    }else if(条件表达式){
        执行表达式2
    }else if(条件表达式){
        执行表达式3
    }
    ...
    else{
        执行表达式n
    }
 */
public class ProcessControl {
    public static void main(String[] args){
        // 举例1 心跳频率(正常心跳频率60-100)
        int heartBeats = 72;
        if (heartBeats < 60 || heartBeats > 100) {
            System.out.println("您需要进一步检查！");
        }
        System.out.println("检查结束！"); // 输出 检查结束！

        // 举例2
        int age = 22;
        if (age < 18) {
            System.out.println("你还未成年，请好好学习呀！");
        }else {
            System.out.println("你已经成年了哦，可以去网吧了哦"); // 执行词句
        }

        // 举例3 判断成绩等级
        int score = 1;
        if (score > 90) {
            System.out.println("优秀是一种习惯，学霸也很孤独呀");
        }else if (score > 70) {
            System.out.println("良好呀，还需继续努力哦");
        }else if (score > 60) {
            System.out.println("及格唉，你肯定是不好好学习哦");
        }
        else {
            System.out.println("差，你是一个差生，要努力做祖国的花朵哦"); // 执行此句
        }
    }
}

说明：

1-else结构是可选的

2-针对表达式

　　1-如果多个条件表达式之间是“互斥”关系(或没有交集的关系)，哪个判断和执行语句声明在上面还是下面都无所谓

　　2-如果多个条件表达式之间有交集关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面

　　3-如果多个条件表达式之间又包含的关系，通常情况下需要将范围小的声明在范围大的上面，否则，范围小的就没有机会执行了

3-if-else结构是可以互相嵌套的

4-如果if-else结构中的执行语句只有一行时，对应的一对{}是可以省略的，但是不建议大家省

4 - 分支结构之switch-case结构介绍

 

/*
1-分支结构中的switch-case
2-格式：
    switch(表达式){
        case 常量1:
            执行语句1;
            // break;
        case 常量2:
            执行语句2;
        ...
        default:
            执行语句n;
    }
3-说明：
    1-根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应case结构中，调用其执行语句。
    2-当调用完执行语句后，任然继续向下执行其他case结构中的执行语句，直到遇到break关键字，或执行完后面的switch-case语句
    3-break关键字可以 使用在switch-case语句中,一旦遇到break，程序就跳出switch-case语句
    4-switch-case语句中的表达式，只能是以下6种数据类型之一：
        byte、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
        注：枚举类型，后面会介绍
    5-case之后只能声明常量，不能声明范围
    6-break关键字按实际情况选择加或不加
    7-default的用法相当于else的用法，可选并且位置是灵活的
 */
public class SwitchTest {
    public static void main(String[] args){
        int number = 2;
        switch(number){
            case 0:
                System.out.println("zero");
            case 1:
                System.out.println("one");
            case 2:
                System.out.println("tow"); // 执行此句，并跳出结构体，如果没有break会继续执行后面的case语句
                break;
            case 3:
                System.out.println("three");

        // 错误示范1
        boolean isHandsome = true;
        switch(isHandsome){  // 注意此行编译时错误
            case true:
                System.out.println("我好帅啊");
                break;
            case false:
                System.out.println("我好丑啊啊");
            default:
                System.out.println("输入有误");
        }
        // 错误示范2
        int age = 20;
        switch(age){
            case age > 18: // 此行编译错误
                System.out.println("你已经成年了");
                break;
            default:
                System.out.println("你是小屁孩");
        }
        }
    }
}

分支语句总结：

　　1-凡是可以用 switch-case 的结构都可以替换为 if-else 语句，反之，则不可以。

　　2-写分支结构时，当发现程序既可以使用 switch-case 语句( switch 表达式中取值的范围不太大 )，也可以使用 if-else 语句时，优先选择 switch-case 语句

　　　　原因：switch-case 执行效率比较高

5 - 循环结构

1-根据循环条件，重复性的执行某段代码

2-有while,do...while,for三种循环语句

3-注：JDK1.5提供了foreach循环，方便遍历集合，数组元素。

6 - 循环结构之for循环介绍

/*
for循环结构的使用
1-循环结构的四个要素：
    1-初始化条件
    2-循环条件 --> 是boolean类型
    3-循环体
    4-迭代循环
2-for循环的结构
    for(初始化条件;循环条件;迭代循环){
        循环体
    }
 */
public class ForTest{
    public static void main(String[] args){
        // 示例1 打印5个 Hello World !
        for(int i = 1;i < 6;i++){
            System.out.println("Hello World !");
        }
        // System.out.println(i); 编译不通过

        // 练习1 程序输出结果？
        int num = 1;
        for(System.out.println("a");num <= 3;System.out.println("c"),num++){
            System.out.println("b"); // abcbcbc
        }
        // 练习2 遍历100以内的偶数，输出所有偶数的和，输出偶数的个数
        int sums = 0;
        int count = 0;
        for(int i = 1;i<=100;i++){
            if(i % 2 == 0){
                // System.out.print(i+","); 输出100以内的所有偶数
                sums += i;
                count++;
            }
        }
        System.out.println("100以内的偶数和为"+sums);
        System.out.println("100以内的偶数个数为"+count);

    }
}

 break关键字的使用

/*
break关键字的使用（跳出循环体）
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
例如：12和20的最大公约数是4，最小公倍数是60。
 */
import java.util.Scanner;
public class ForTest{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个正整数n:");
        int n = scan.nextInt();
        System.out.print("请输入一个正整数m:");
        int m = scan.nextInt();

        // 获取最大公约数
        // 1.先获取两个数中较小值
        int min = (n >= m)? m : n;
        // 2.遍历
        for(int i = min;i>1;i--){
            if(n % i == 0 && m % i == 0){
                System.out.println("最大公约数="+i);
                break; // 一旦执行到break，就跳出当前循环
            }
        }

        // 获取最小公倍数
        // 1.获取两个数中的较大值
        int max = (n >= m)? n : m;
        // 2.遍历
        for(int i = max;i <= m*n;i++){
            if(i % n == 0 && i % m == 0){
                System.out.println("最小公倍数="+i);
                break;
            }
        }
    }
}

7 - 循环结构之while循环

/*
1-循环结构的四个要素：
    1-初始化条件
    2-循环条件 --> 是boolean类型 关注点
    3-循环体
    4-迭代循环
说明：通常情况，循环的结束都是因为‘循环条件’中条件返回false
2-while循环结构：
    1初始化条件
    while(2循环条件){
        3循环体
        4迭代循环
    }
3-说明：
    ①写程序要避免出现死循环(迭代条件丢失)
    ②for循环与while循环是可以相互转换的
        区别：初始化条件作用域范围不一样
 */
import java.util.Scanner;
public class WhileTest {
    public static void main(String[] args){
        // 遍历100以内的所有偶数
        int i = 1;
        while(i < 100){
            if(i % 2 == 0){
                System.out.print(i+",");
            }
            i++; // 迭代条件，一旦没有，程序则死循环
        }
    }
}

8 - 循环结构之do-while循环

/*
1-循环结构的四个要素：
    1-初始化条件
    2-循环条件 --> 是boolean类型 关注点
    3-循环体
    4-迭代循环
说明：通常情况，循环的结束都是因为‘循环条件’中条件返回false
2-do-while循环结构：
    ①初始化条件
    do{
        ③循环体;
        ④迭代循环;
    }while(②循环条件);
3-执行过程
    ① -> ③ -> ④ -> ② -> ③ -> ④ ... ②
4-说明：
    1.do-while循环至少会执行一次循环体
    2.开发中使用 for while 使用较多，而do-while比较少
 */
public class DoWhileTest {
    public static void main(String[] args){
        // 遍历100以内的偶数，并计算所有偶数的和及偶数的个数
        int i = 1;
        int sum = 0;
        int count = 0;
        do{
            if(i % 2 == 0){
                // System.out.print(i+","); 输出所有的偶数
                sum += i;
                count++;
            };
            i++;
        }while(i <= 100);
        System.out.println("所有偶数的和="+sum);
        System.out.println("所有偶数的个数="+count);

        // ***** while循环与do-while循环的对比
        int num1 = 10;
        while(num1 > 20){
            System.out.println("Hello While"); // 此时while循环条件不满足，不会输出语句
            num1++;
        }

        int num2 = 10;
        do{
            System.out.println("hello do-while"); // 而do-while就算循环条件不满足，也会执行一次循环体，所以输出 hello do-while
            num2++;
        }while(num2 > 20);

    }
}

综合练习题

题目1：从键盘读入不确定的整数，并判断读入的整数和负数的个数，输入0时程序结束

import java.util.Scanner;
public class DoWhileTest {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int positiveNumber = 0; // 记录正数个数
        int negativeNumber = 0; // 记录负数个数

        // for(;;) 也可以使用这种方法限制循环次数
        while(true){
            System.out.print("请输入一个整数：");
            int number = scan.nextInt();
            // 判断number正负情况
            if(number > 0){
                positiveNumber++;
            }else if(number < 0){
                negativeNumber++;
            }else{
                break;
            }
        }
        System.out.println("输入正数为"+positiveNumber);
        System.out.println("输入负数为"+negativeNumber);
    }
}

题目2：输出100以内所有质数

/*
质素：素数，只能被1和它本身整除的自然数 --> 从2开始到这个数-1结束为止，都不能被这个数本身整除。
最小的质数：2
 */
public class PrimeNumberTest {
    public static void main(String[] args){
        boolean isFlag = true; // 表示i是否被j除尽，一旦除尽，修改其值
        // 遍历100以内的自然数
        for(int i = 2;i <= 100;i++){
            for(int j = 2;j < i;j++){ // j 被 i去除
                if(i % j == 0){ // i 被 j 除尽
                    isFlag = false;
                }
            }
            if(isFlag == true){
                System.out.println(i);
            }
            // 重置isFlag
            isFlag = true;
        }
    }
}

 题目3：一个数如果恰好等于它的因子之和，这个数就称为“完数”例如：6=1+2+3。求 1000 以内的所有完数（因子：除去这个数本身的其他约数）

public class Test1 {
    public static void main(String[] args) {
        int factor = 0;
        for(int i = 1;i < 1000;i++){
            for(int j = 1;j < i;j++){
                if(i % j == 0){
                    factor += j;
                }
            }
            if(i == factor){
                System.out.println(i);
            }
            // 重置factor
            factor = 0;
        }
    }
}

9 - 嵌套循环(多重循环)

/*
嵌套循环的使用(多重循环)
1-嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环，其中for，while，do-while，均可作为外侧循环或内层循环
    1-外侧循环：B
    2-内存循环：A
2-实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当层循环，
    开始下一次循环。
3-设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次
    例如：
        ①打印九九乘法表
        ②输出：
            ******
            ******
            ******
            ******
 */
public class ForForTest {
    public static void main(String[] args){
        /*
        输出：
            ******
            ******
            ******
            ******
         */
        for(int i = 1;i <= 4;i++){
            for(int j = 1;j <= 5;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        // 打印99乘法表
        for(int i = 1;i <= 9;i++){
            for(int j = 1;j <= i;j++){
                System.out.print(j+" * "+i+" = "+j*i+" ");
            }
            System.out.println();
        }
    }
}

10 - 从键盘获取输入的数据(程序交互)

/*
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤:
    1-导包：import java.util.Scanner;
    2-Scanner实例化：Scanner scan = new Scanner(System.out);
    3-调用Scanner类的相关方法，来获取指定类型的变量

注意：对于char型的获取，Scanner没有提供相关的方法，只能获取一个字符串
*/
import java.util.Scanner;
public class StringTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你的分数：");
        int score = scan.nextInt();
        System.out.println(score);
    }
}

11 - 获取随机数方法

/*
如何获取一个随机数:范围在 (10 - 99)
公式：[a,b] --> (int)(Math.random() * (b-a+1) +a)
 */
public class StringTest{
    public static void main(String[] args){
        double value = Math.random(); // [0.0,1.0)
        int num = (int)(value * 90 + 10);
        System.out.println(num);
    }
}

12 - break和continue关键字

/*
break：循环结构中 结束当前循环 或在 switch-case语句中 跳出结构体
continue：循环结构中 结束当次循环
注意：关键字后面不能声明语句
 */
public class ProcessControl{
    public static void main(String[] args){
        // 输出：1 3 4 5 6 7 8 9 10
        for(int i = 1;i <= 10;i++){
            if(i == 2){
                continue;
            }
            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.println(j);
            }
            System.out.println();
        }
    }
}