第4章 控制执行流程

第四章 控制执行流程

4.1 true和false

所有条件语句都利用表达式的真或假来决定执行路径。
上章的关系操作运算符可以用来构造条件语句。
Java不允许我们将一个数字作为布尔值使用。

4.2 if-else

// 格式
if (Boolean-exp) {
	statement;
}  // 省略else

if (Boolean-exp) {
	statement;
} else {
	statement;
}

// 例子
import static util.Print.*;
public class Demo01 {
    static int result;
    static void test(int val, int target) {
        if (val < target) {
            result = -1;
        } else if (val > target) {
            result = 1;
        } else {
            result = 0; // Match
        }
    }
    public static void main(String[] args) {
        test(10, 5);
        print(result);
        test(5, 10);
        print(result);
        test(5, 5);
        print(result);
        /*
         * 1
         * -1
         * 0
         */
    }
}

4.3 迭代

while、do-while和for用来控制循环，将它们划分为迭代语句。语句会重复执行，直到控制条件为“假”为止。

// 格式
while(Boolean-exp) {
	statement;
}
// 例子
public class Demo02 {
    public static boolean condition() {
        boolean result = Math.random() < 0.7; // 产生0到1之间，不包括1的double值
        System.out.println(result + ", ");
        return result;
    }
    public static void main(String[] args) {
        while (condition()) {
            System.out.println("Inside 'while'");
        }
        System.out.println("Exited 'while'");
    }
    /*
     * true,
     * Inside 'while'
     * true,
     * Inside 'while'
     * true,
     * Inside 'while'
     * false,
     * Exited 'while'
     */
}

4.3.1 do-while

do-while区别于while的就是 do-while中的语句至少会执行一次，即便表达式第一次计算结果就是false。
while需要判断条件表达式，才决定是否执行循环体语句。

// 格式
do {
	statement;
} while(Boolean-exp)

4.3.2 for

// 格式
for(initialization; Boolean-exp; step) {
	statement;
}

格式解释：
	initialization 初始化表达式
	Boolean-exp 布尔表达式
	step 步进运算，（一般用于更新布尔表达式中的变量值）

// 例子
public class Demo03 {
    public static void main(String[] args) {
        for (char c = 0; c < 128; c++) {
            if (Character.isLowerCase(c)) {
                System.out.println("Value: " + (int) c + ", Character: " + c);
            }
        }
    }
    /*
     * Value: 97, Character: a
     * Value: 98, Character: b
     * Value: 99, Character: c
     * Value: 100, Character: d
     * Value: 101, Character: e
     * ...
     */
}

4.3.3 逗号操作符

使用在for循环控制表达式中，在初始化表达式中定义多个变量，多个步进运算

public class Demo04 {
    public static void main(String[] args) {
        for (int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
            System.out.println("i: " + i + ", j: " + j);
        }
        /*
         * i: 1, j: 11
         * i: 2, j: 4
         * i: 3, j: 6
         * i: 4, j: 8
         */
    }
}

4.4 Foreach语法

foreach还可以用于任何Iterable对象

import java.util.Random;
public class Demo05 {
    public static void main(String[] args) {
        Random rand = new Random(47);
        int f[] = new int[3];
        for (int i = 0; i < f.length; i++) {
            f[i] = rand.nextInt(100);
        }
        // foreach
        for (int x : f) {
            System.out.println(x);
        }
        /*
         * 58
         * 55
         * 93
         */
    }
}

许多for语句会在一个整型值序列中步进

import static util.Range.*;

public class Demo06 {
    public static void main(String[] args) {
        for (int i : range(10)) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i : range(5, 10)) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i : range(5, 20, 3)) {
            System.out.print(i + " ");
        }
        System.out.println();
        /*
         * 0 1 2 3 4 5 6 7 8 9
         * 5 6 7 8 9
         * 5 8 11 14 17
         */
    }
}

package util;

/**
 * @author alex2ice
 * @description Range类
 */
public class Range {
    public static int[] range(int bound) {
        return range(0, bound);
    }
    public static int[] range(int start, int end) {
        int size = end - start;
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = start + i;
        }
        return arr;
    }
    public static int[] range(int start, int end, int step) {
        int size = (end - 1 - start) / step + 1;
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = start + step * i;
        }
        return arr;
    }
}

4.5 return

Java中的多个关键词表示无条件分支，它们只是表示这个分支无需任何测试即可发生。这些关键词包括return，break，continue和一种与其他语言中的goto类似的跳转到标号语句的方式。
return关键词有两方面的用途：
	指定一个方法返回什么值（假设返回值类型不是void）
	导致当前的方法退出，并返回那个值。
如果一个方法声明返回void之外的类型，就必须确保每一条代码路径都将返回一个值

import static util.Print.*;

public class Demo01 {
    static int test(int testval, int target) {
        if (testval > target)
            return +1;
        else if (testval < target)
            return -1;
        else
            return 0; // Match
    }
    public static void main(String[] args) {
        print(test(10, 5));
        print(test(5, 10));
        print(test(5, 5));
        /*
         * 1
         * -1
         * 0
         */
    }
}

4.6 break和continue

break用于强行退出循环，不执行循环中剩余的语句。
continue停止执行当前的迭代，然后退回循环起始处，开始下一次迭代。

import static util.Range.*;
public class Demo06 {
    public static void main(String[] args) {
        System.out.println();
        for (int i : range(100)) {
            if (i == 74)
                break; // 跳出循环，i不会 大于等于 74
            if (i % 9 != 0)
                continue; // 忽略下面语句，继续下一轮循环 不是9的倍数的i值会被跳过，不会执行下一句输出
            System.out.print(i + " ");
        }
        System.out.println();
        int i = 0;
        // 无限循环
        while (true) {
            i++;
            int j = i * 27;
            if (j == 1269)
                break;
            if (i % 10 != 0)
                continue;
            System.out.print(i + " ");
        }
    }
}

4.7 臭名昭著的goto 标签

Java对标签进行了限制，标签唯一起作用的地方刚好是在迭代语句之前
标签
	一般的continue会退回到最内层循环的开头，并继续执行
	带标签的continue会回到标签的位置，并重新进入紧接在那个标签后面的循环
	一般的break会中断并跳出当前循环
	带标签的break会中断并跳出标签所指的循环
在Java中使用标签的唯一理由就是因为有循环嵌套存在，且想从多层嵌套中break或continue

import static util.Print.*;

public class Demo07 {
    public static void main(String[] args) {
        int i = 0;
        outer: // 标签和迭代语句之间不能有语句
        while (true) {
            inner: for (; i < 10; i++) {
                print("i: " + i);
                if (i == 2) {
                    print("continue");
                    continue;
                }
                if (i == 3) {
                    print("break");
                    i++;
                    break;
                }
                if (i == 7) {
                    print("continue outer");
                    i++;
                    continue outer;
                }
                if (i == 8) {
                    print("break outer");
                    break outer;
                }
                for (int j = 0; j < 5; j++) {
                    if (j == 3) {
                        print("continue inner");
                        continue inner;
                    }
                }
            }
        }
    }
}
/*
 * i: 0
 * continue inner
 * i: 1
 * continue inner
 * i: 2
 * continue
 * i: 3
 * break
 * i: 4
 * continue inner
 * i: 5
 * continue inner
 * i: 6
 * continue inner
 * i: 7
 * continue outer
 * i: 8
 * break outer
 */

4.8 switch

可以和enum枚举类配合使用

// 格式
switch (integral-selector) {
	case integral-value1: statement; break;
	case integral-value2: statement; break;
	case integral-value3: statement; break;
	...
	default: statement;
}