1 选择流程控制

1.1 顺序结构

顺序结构是程序中最简单、最基本的流程控制, 没有特定的语法结构, 按照代码的先后顺序依次执行, 程序中大部分代码都是这样执行的.

顺序结构的执行流程:

开始 -> 语句A -> 语句B -> ... -> 语句X -> 结束.

1.2 if判断语句

(1) if语句格式1:

if (关系表达式) {
    语句体
}

执行流程:

① 首先判断关系表达式的值, 看其结果是true(真)还是false(假);

② 如果是true就执行语句体;

③ 如果是false就不执行语句体.

(2) if语句格式2:

if (关系表达式) {
    句体1;
} else {
    语句体2;
}

执行流程:

① 首先判断关系表达式的值, 看其结果是true(真)还是false(假);

② 如果是true就执行语句体1;

③ 如果是false就执行语句体2.

(3) if语句格式3:

if (关系表达式1) {
    语句体1;
} else if (关系表达式2) {
    语句体2;
}
// n-2个else if语句块...
else {
    语句体n+1;
}

执行流程:

① 首先执行关系表达式1, 判断其结果是true(真)还是false(假);

② 如果是true就执行语句体1;

③ 如果是false就执行关系表达式2, 判断其结果是true还是false;

③ – 1: 如果是true就执行语句体2;

③ – 2: 如果是false就继续执行接下来的关系表达式, 并根据其结果决定是否运行某个语句体;

④ 如果没有任何关系表达式的值是true, 就执行最后的else块中的语句体n+1.

(4) if判断语句的执行流程图:

(5) if判断语句的示例代码:

/**
 * if判断语句的测试代码: 给出学生成绩, 输出其所属的等级
 *  * 90-100  优秀
 *  * 70-90   良好
 *  * 60-70   及格
 *  * 60以下  不及格
 */
public class IfDemo {

    public static void main(String[] args) {
        int score = 88;
        // if语句格式3, 考虑到程序的健壮性, 加入错误数据的判断
        if (score < 0 || score > 100) {
            System.out.println("成绩输入错误!");
        } else if (score >= 90 && score <= 100) {
            System.out.println("你的成绩为优秀~");
        } else if (score >= 70 && score < 90) {
            System.out.println("你的成绩为良好");
        } else if (score >= 60 && score < 70) {
            System.out.println("你的成绩刚好及格, 继续努力哦~");
        } else {
            System.out.println("你的成绩不及格, 要加油了哦~");
        }
    }
}

1.2 switch选择语句

(1) switch语句格式:

switch(表达式) {
    case 值1:
        语句体1;  // 可以是一条或多条语句
        break;
    case 值2:
        语句体2;
        break;
    // 其他case语句...
    default:    // 默认语句
        语句体n+1;
        break;
}

执行流程:

① 计算出表达式的值;

② 与case的值依次比较, 一旦匹配, 就执行该case的语句体, 在执行中如果遇到break关键字, 就结束执行; 如果一直没有遇到break关键字, 就一直向下执行, 直到default语句执行结束;

③ 如果所有case都与表达式的值不匹配, 就执行default语句体部分, 然后程序结束.

使用细节:

① break关键字: 如果某个case中没有break关键字跳出当前选择流程, 就会继续执行下面的case, 直到遇到break关键字, 或者执行完default中的逻辑. —— 一些经验颇丰的开发人员也会在这里栽跟头, 要注意;

② case与default没有顺序之分, 先执行匹配的case, 没有的话再去找default语句 —— 为了代码结构的清晰, 建议把default放在最后;

③ 结束switch语句的两种情况: 遇到break或return关键字, 或者执行到switch语句结束;

④ 如果匹配的case或者default语句中没有对应的break, 那么程序会继续向下执行, 直到遇到break关键字或者switch语句结束.

(2) 格式说明:

switch表达式的取值说明:

① JDK 5之前可以是: byte, short, int, char类型的值;

② JDK 5之后, 可以是enum类型的值;

③ JDK 7以后可以是String类型的值.

switch语句体中其他关键字的说明:

① case: 后面跟的是要和表达式进行比较的值;

② break: 表示中断、结束的意思, 可以结束switch语句;

③ default: 表示所有case都不匹配的时候, 就执行这里的内容, 和if语句中的else的作用相似.

(3) switch控制语句的执行流程图:

(4) switch控制语句的示例代码:

/**
 * switch选择语句的示例代码: 给出一个1-7之间的数字, 输出其对应的星期
 */
public class SwitchDemo {
    public static void main(String[] args) {
        // 给出日期
        int weekday = 5;
        // switch语句实现选择
        switch (weekday) {
            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;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("你输入的数字有误");
                // 最后的break可以省略
                break;
        }
    }
}

2 循环流程控制语句

2.1 for循环

(1) for循环语句格式:

for (初始化语句A; 判断条件语句B; 控制条件语句C) {
    循环体语句D;
}
其他语句E;

执行流程:

① 执行初始化语句A;

② 执行判断条件语句B, 看其结果是true还是false:

如果是true, 执行循环体内部的语句D;

如果是false, 循环结束, 执行其他语句E.

③ 执行控制条件语句C;

④ 继续执行第②步.

控制条件语句的作用:

改变判断条件语句中的某个因素, 也就是要让B语句有结束的可能, 否则会成为死循环, 一直循环下去, 程序就无法结束了

(3) for循环语句的执行流程图:

(4) for循环语句的示例代码① —— 求1-100之间偶数的和:

/**
 * 求出1-100之间偶数和:
 * A: 定义求和变量, 初始化值是0
 * B: 获取1-100之间的数据, 用for循环实现
 * C: 把获取到的数据进行判断, 看是否是偶数, 如果是, 就累加
 * D: 输出求和结果
 */
public class ForDemo1 {
    public static void main(String[] args) {
        // 定义求和变量, 初始化值是0
        int sum = 0;
        // 用for循环获取1-100之间的数据
        for (int x = 1; x <= 100; x++) {
            //把获取到的数据进行判断, 看是否是偶数
            if (x % 2 == 0) {
                sum += x;
            }
        }
        // 输出求和结果
        System.out.println("sum:" + sum);
    }
}

(5) for循环语句的示例代码② —— 在控制台打印水仙花数:

水仙花数: 是指一个三位数, 其各位数字的立方和等于该数本身.

举例: 153就是一个水仙花数, 因为: 153 = 1*1*1 + 5*5*5 + 3*3*3.

/**
 * 需求: 在控制台输出所有的”水仙花数”
 * 分析:
 *     A: 水仙花数都是三位数, 也就是数值的范围是100-999
 *     B: 获取一个数的每一位的数, 以153为例:
 *         个位: 153 % 10 = 3;
 *         十位: 153/10 % 10 = 5;
 *         百位: 153/100 % 10 = 1;
 *     C: 对每一位上的数进行立方计算并求和, 如果与原数相等, 就说明这个数就是水仙花数
 */
public class ForDemo2 {
    public static void main(String[] args) {
        // 通过循环获取到每一个三位数
        for (int x = 100; x < 1000; x++) {
            // 获取个位, 十位, 百位
            int one = x % 10;
            int two = (x / 10) % 10;
            int three = (x / 10 / 10) % 10;
            // 对每一位上的数进行立方计算并求和, 并和原数比较
            if ((Math.pow(one, 3) + Math.pow(two, 3) + Math.pow(three, 3)) == x) {
                System.out.println(x);
            }
        }
    }
}

2.2 while循环

(1) while循环语句格式:

// 基本格式:
while (判断条件语句) {
    循环体语句;
}

// 扩展格式:
初始化语句;
while (判断条件语句) {
    循环体语句;
    控制条件语句;
}

执行流程:

当判断条件语句的结果为true, 就执行while中的循环体语句.

—— 所以这种类型的循环又叫作 当型循环.

(2) while循环语句执行流程图:

与for循环语句的执行流程图相同, 请参考上面的配图.

(3) while循环语句的示例代码:

/**
 * 求1-100之间的数据的累加和, 分别用for和while实现.
 */
public class WhileDemo {
    public static void main(String[] args) {
        // for循环的实现:
        // 定义求和变量
        int sum1 = 0;
        // 获取1-100之间的数据
        for(int x = 1; x <= 100; x++) {
            // 累加
            sum1 += x;
        }
        System.out.println("for循环计算的1-100的累加和: " + sum1);

        // while循环的实现:
        // 初始化语句
        int sum2 = 0;
        int x = 1;
        while (x <= 100) {
            sum2 += x;
            // 类似于for中的控制条件语句
            x++;
        }
        System.out.println("while循环计算的1-100的累加和: " + sum2);
    }
}

2.3 do…while循环

(1) do…while循环语句格式:

// 基本格式:
do {
    循环体语句;
} while (判断条件语句);

// 扩展格式:
初始化语句;
do {
    循环体语句;
    控制条件语句;
} while (判断条件语句);

执行流程:

无论判断语句条件是否为true, 都要先执行一遍do中的循环体语句, 直到判断语句条件为false.

—— 所以这种类型的循环又叫作 直到型循环.

(2) do...while循环语句执行流程图:

(3) do...while循环语句的示例代码:

/**
 * do-while循环计算1-100以内的偶数之和
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        // 定义求和变量, 初始化值是0
        int sum = 0;
        int x = 1;
        do {
            // 把获取到的数据进行判断, 看是不是偶数
            if (x % 2 == 0) {
                sum += x;
            }
            x++;
        } while (x <= 100);
        // 输出求和结果
        System.out.println("sum:" + sum);
    }
}

2.4 三种循环的区别

(1) 执行次数上的区别:

① do…while循环至少会执行一次循环体.

② for循环和while循环只有在条件成立的时候才会执行循环体;

(2) for循环语句和while循环语句的区别:

控制条件语句, 应该具有改变判断条件语句的结果的功能, 一般是通过对变量的操作来实现, 比如下面示例代码中的x, y, z.

关于这类变量的使用, 有下述区别:

① for循环中: 控制条件语句所用到的变量, 在循环结束后, 就不能再被访问了 —— 因为for循环结束后, 这个变量的作用域结束, 就会被Java虚拟机标记为不可用, 之后再被垃圾回收, 这样做提高了内存的使用效率.

② while循环中: 控制条件语句所用到的变量, 在循环结束还可以继续使用, 如果要继续使用, 就用while循环.

(3) 三种循环体的区别的示例代码:

/**
 * 比较三种循环的区别
 */
public class DifferentBetweenLoop {
    public static void main(String[] args) {
        // for循环: 初始变量在循环结束后就会失效
        for (int x = 1; x <= 10; x++) {
            System.out.println("for: 热泪盈眶, 向着太阳");
        }
        // 这里的x无法继续访问
        // System.out.println("x=" + x);

        // while循环: 初始变量在循环结束后还能继续使用
        int y = 1;
        while (y <= 10) {
            System.out.println("while: 时间是最好的见证者");
            y++;
        }
        System.out.println("y=" + y);  // y=11

        // do...while循环: 初始变量在循环结束后还能继续使用
        // 而且: 即使while中的条件不满足, 也至少会执行一次循环体语句
        int z = 0;
        do {
            System.out.println("do-while: 活得干净, 并且自我");
            z++;
        } while (z > 10);
        System.out.println("z=" + z);
    }
}

3 控制循环语句

3.1 控制跳转语句break

(1) break的使用场景:

在switch选择语句中;

在循环语句中.

(2) break的作用:

跳出单层循环, 让循环提前结束.

(3) break的使用示例:

/**
 * 循环依次输出1-5之间的数, 如果要输出的数能被3整除, 则退出循环
 */
public class BreakDemo {

    public static void main(String[] args) {
        // 直接写break, 编译器会报出: Break outside switch or loop的错误.
        // break;

        for (int x = 1; x <= 5; x++) {
            // 满足某一条件, 立即跳出for循环
            if (x % 3 == 0) {
                break;
            }
            System.out.println("x=" + x + " == HelloWorld");
        }
        // 这里的运行结果:
        // x = 1 == HelloWorld
        // x = 2 == HelloWorld
    }
}

3.2 控制跳转语句continue

(1) continue的使用场景:

在循环语句中.

(2) continue的作用:

在单层循环中, continue的作用与break相同, 也就是立即跳出当前循环.

(3) break和continue的区别:

break: 退出当前循环, 也就是不再执行这个循环操作了.

continue: 退出本次循环, 继续下次循环.

—— 这两个语句如果单独存在, 它们后面都不可以有其他语句, 因为执行不到.

(4) continue的使用示例:

/**
 * 循环依次输出1-5之间的数, 如果要输出的数能被3整除, 则继续下次循环
 */
public class ContinueDemo {
    public static void main(String[] args) {
        // 直接写continue, 编译器会报出: Continue outside of loop的错误.
        // continue;

        for (int x = 1; x <= 5; x++) {
            if (x % 3 == 0) {
                // break直接结束当前循环, 也就是说不再执行这个循环了.
                // break;
                continue;
            }
            System.out.println("x=" + x + " == HelloWorld");
        }
        // 这里的运行结果:
        // x = 1 == HelloWorld
        // x = 2 == HelloWorld
        // x = 4 == HelloWorld
        // x = 5 == HelloWorld
    }
}

3.3 循环结构的应用

(1) 在多重循环中, 通过标号决定要执行的循环结构:

/**
 * 演示设置标号, 跳转到指定的循环结构
 */
public class BreakAndContinue {
    public static void main(String[] args) {
        // 设置外部循环的标号
        Outer:
        for (int x = 0; x < 3; x++) {
            // 设置内部循环的标号
            Inner:
            for (int y = 0; y < 3; y++) {
                // 如果y+1=x, 就跳出外层循环
                if (y + 1 == x) {
                    break Outer;
                } else {
                    System.out.println("x = " + x);
                }
            }
        }
    }
}
// 上述代码的结果是:
x = 0
x = 0
x = 0

(2) 循环结构的应用场景之 – 无限循环:

while (true) {
    // do something
}
for ( ; ; ) {
    // do something
}

无限循环存在的原因是: 开发人员在编码的时候不能提前预知循环体要执行多少次, 而要根据程序运行期间的某些动态变量来控制循环 —— 满足某一个预想的条件后再退出循环.

（全文完）

微信关注《瘦风的南墙》 在移动端阅读文章