Thinking in Java 读书笔记 第四章 控制执行流程

章四 控制流

前言 很认真的用CSDN的Markdown写的，结果现在一片乱码，现在连用MarkDwon编辑器都打不开，也没有备份，网站的bug真是很蠢。这篇大家可以不用看了，反正也是很基础的内容，可以看别人的。

  本章主要讲控制流，主要内容包括条件语句，迭代语句和一些控制流中常见的关键字。下文将按照上面三个主题将本章内容重新编排，进行整理。需要说明的是，Java的控制流与C/C++近乎一样，无需花大量时间重复学习，只需对不同处进行对比了解即可。
  需要说明的一点是，在新版的JDK中，switch语句的选择因子除了int型，Enum，还可以是String。

4.1 条件语句

  所有条件语句都利用条件表达式的真或假来决定执行路径
  再次强调，Java里整型与布尔型不能互相转换：while(1) //illegal here

4.1.1 if-else条件语句

   if-else语句是最基本条件语句，其中，else语句可选，其规范格式如下：

        if(boolean-expression) {
            //statements here
        } else {
            //statements here
        }
   
   
1
2
3
4
5
   
   

    
    
   
   

  上述代码中，statements可以为简单语句或复合语句块。else语句可以没有，也可在if语句和else语句之间加入若干个else if语句，构成多路选择语句。

4.1.2 switch语句

  switch语句可以简洁方便的实现多路选择。根据整数表达式的值，从一系列case语句中选择一个区执行，其格式如下：

        switch(integral-selector) {
        case integral-value1: statements;
                              break;
        case integral-value2: statements:
                              break;
        //……
        default: statements;
        }
   
   
1
2
3
4
5
6
7
8
   
   

    
    
   
   

  上式中，integral-selector为能产生整数值的表达式(或者为String，enum)。若值为整型，应该为int型，或能转化为int型的byte，short，char，long类型不行。
  case语句后为statements，无需{}，且以break语句结尾。确实不用加break语句时，需要添加go through注释说明。最后以default语句结尾。

4.2 迭代语句

  迭代语句包括while，do-while和for，用以控制循环。在循环中，语句会重复执行，直到起控制作用的布尔表达式结果为假为止。

4.2.1 while与do-while

  while语句的格式如下：

        while(boolean-expression) {
            //statements
        }
   
   
1
2
3
   
   

    
    
   
   

  do-while语句的格式如下：

        do {
            //statements
        } while (boolean-expression)
   
   
1
2
3
   
   

    
    
   
   

  while和do-while唯一的区别就是do-while中的语句至少执行一次。

4.2.2 for语句和Foreach语法

  for循环往往更为常用。for循环需要在第一次迭代之前进行初始化，随后进行条件测试，且在每一次迭代结束前，进行某种形式的步进，for循环的格式如下：

        for(initialization; boolean-expression; step) {
            //statements;
        }
   
   
1
2
3
   
   

    
    
   
   

  重点：注意初始化变量的作用域

逗号操作符：
  Java中唯一可以使用逗号表达式的地方就是for循环中，可以用于初始化和步进部分。通过使用逗号表达式，可以初始化多个相同类型的变量。
  示例：for(int i = 1, j = i + 4; i < 5; ++i, --j)

Foreach语法
  Java SE5引入新的更简洁的语法用以数组和容器，即foreach语法。需要主要的是，它是一种语法，通过简化for循环的控制表达式，得到特定效果。格式如下：

        int[] arr = {1,2,3,4};
        for(int element : arr) {
            System.out.println(element);
        } 
   
   
1
2
3
4
   
   

    
    
   
   

  foreach语法的引入使得代码方便读写，在C++11中，也引入了该语法。

4.3 关键字return，break和continue，goto

return的作用：

• 在控制流中，可以通过合理使用return语句而回避else语句

• 在方法中：

  • 返回void的方法中，可以不显式写return语句，方法尾部会有隐式的return语句；
  • 若返回不为void，则必须确保每一个代码路径都有return语句。

break，continue和标签
  在任何迭代语句的主体部分，都可以用break语句和continue语句控制循环的流程。其中，break用于退出循环；而continue则退出当前迭代，执行剩下的循环。
  Java保留了goto关键字，但并未使用它。Java铜鼓使用标签并限制其能力，从而使这一语言特性更有效可靠。需要记住的重点是：Java中需要使用标签的唯一理由是嵌套循环存在，并想从多层嵌套中break或continue，因此，标签起作用的唯一地方在于迭代语句之前。下面是程序示例：

        label:
        while(boolean-expression) { //outer iteration
            while(boolean-expression) { //inner iteration
                //statements;
                break; // condition 1
                //statements;
                continue; //condition 2
                //……
                continue label; //condition 3
                //……
                break label; //condition 4
            }

        }
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   

    
    
   
   

break，while和标签在循环语句中共存在四种情况：

1. break中断并跳出当前循环
2. continue退出内层迭代，执行剩下的循环
3. 带标签的continue到达标签位置，重新进入紧接在标签后的循环
4. 带标签的break会中断并跳出标签所指的循环。

无穷while循环

while(true)  //while(1) is illegal here
for( ; ;)
   
   
1
2
   
   

    
    
   
   

练习10：找出四位数中的吸血鬼数字，写的代码有点乱，还是厚颜贴上来吧。

package chapter3;

public class VampireNumber {

    public static void main(String[] args) {
        for(int index = 1000; index <= 9999; ++index) {
            if(isVampireNumber(index)) {
                System.out.println(index);
            } else {
                continue;
            }
        }
    }

    public static boolean isVampireNumber(int num) {
        //get the number of ecah digits
        int[] digits = new int[4];
        digits[0] = num % 10;
        digits[1] = num % 100 /10;
        digits[2] = num /100 % 10;
        digits[3] = num /1000;


        for(int outer = 0; outer < 4; ++outer) {
            for(int inner = 0; inner != outer && inner < 4; ++inner) {
                boolean[] digitsStatus = { true,true,true,true};


                digitsStatus[outer] = false;
                digitsStatus[inner] = false;

                int first = 0, second = 0, third = 0,fouth = 0;
                first = digits[outer];
                second = digits[inner];
                for(int i = 0; i < 4; ++i) {
                    if(digitsStatus[i] == true) {
                        third = digits[i];
                        digitsStatus[i] = false;
                        break;
                    }
                }
                for(int i = 0; i < 4; ++i) {
                    if(digitsStatus[i] == true) {
                        fouth = digits[i];
                    }
                }

                int value1 = digits[outer] * 10 + digits[inner];
                int value2 = third * 10 + fouth;
                int value3 = fouth * 10 + third;
//              System.out.println(""+first+second+third+fouth);
                if(value1*value2 == num || value1 * value3 == num)
                    return true;
                else
                    continue;
            }
        }
        return false;
    }

}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61