Java编程思想学习(四)----第四章：控制执行流程

　　在Java中，涉及的关键字包括if-else、while、do-while、for、return、break 以及选择语句switch。然而，Java并不支持goto语句（该语句引起许多反对意见，但它仍是解决某些特殊问题的最便利的方法）。在Java中，仍然可以进行类似goto那样的跳转，但比起典型的goto，有了很多限制。

4.1 true和false

　　所有条件语句都利用条件表达式的真或假来决定执行路径。

4.2 if-else

//:control/IfElse.java
import static net.mindview.util.Print.*;

public class IfElse{
    static int result = 0;
    static void test(int testval, int target){
        if (testval > target)
            result = +1;
        else if (testval < 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);
    }
}/*Output
1
-1
0
*///:~

4.3 迭代

　　while、do-while和for用来控制循环，有时将它们划分为迭代语句(iteration statement)。语句会重复执行，直到起控制作用的布尔表达式( boolean expression)得到“假”的结果为止。

while(boolean-expression)
    statement

do
    statement
while(boolean-expression);

while和do-while唯一的区别就是do-while中的语句(statement)至少会执行一次，即便表达式第一次就被计算为false。

4.3.2 for

//:control/ListCharacters.java

public class ListCharacters{

    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);
    }

}/*Output
    value:97 Character:a
    value:98 Character:b
    value:99 Character:c
    value:100 Character:d
    value:101 Character:e
    value:102 Character:f
    value:103 Character:g
    value:104 Character:h
    value:105 Character:i
    value:106 Character:j
    value:107 Character:k
    value:108 Character:l
    value:109 Character:m
    value:110 Character:n
    value:111 Character:o
    value:112 Character:p
    value:113 Character:q
    value:114 Character:r
    value:115 Character:s
    value:116 Character:t
    value:117 Character:u
    value:118 Character:v
    value:119 Character:w
    value:120 Character:x
    value:121 Character:y
    value:122 Character:z
    *///:~

c的作用域就是for控制的表达式的范围内。

4.3.3 逗号操作符

　　逗号用作分隔符时用来分隔函数的不同参数。（如：function(a,b,c)）

　　通过使用逗号操作符，可以在for语句内定义多个变量，但是它们必须具有相同的类型。

//:control/CommaOperator.java

public class CommaOperator
{
    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);
    }
}/*Output
    i = 1, j = 11
    i = 2, j = 4
    i = 3, j = 6
    i = 4, j = 8
    *///:~

4.4 Foreach语法

for(float x : f) {}

这条语句定义了一个float类型的变量x，继而将每一个float元素赋值给x。

尽管range()使得foreach语法可以适用于更多的场合，并且这样做似乎可以增加可读性，但是它的效率会稍许降低。

4.5 return

　　关键词包括return、break、continue和一种与其他语言中的goto类似的跳转到标号语句的方式。

　　如果在返回void的方法中没有return语句，那么在该方法的结尾处会有一个隐式的return，因此在方法中并非总是必须要有一个return语句。但是，如果一个方法声明它将返回void之外的其他东酉，那么必须确保每一条代码路径都将返回一个值。

4.6 break和continue

　　在任何迭代语句的主体部分，都可用break和continue控制循环的流程。其中，break用于强行退出循环，不执行循环中剩余的语句。而continue则停止执行当前的迭代，然后退回循环起始处，开始下一次迭代。

　　无穷循环的第二种形式是for(；；)。编译器将while(true)与for(；；)看作是同一回事。

4.7 臭名昭著的goto

 　　Java没有goto。然而，Java也能完成一些类似于跳转的操作，这与break和continue这两个关键词有关。它们其实不是一个跳转，而是中断迭代语句的一种方法。之所以把它们纳入goto问题中一起讨论，是由于它们使用了相同的机制：标签。

//:control/LabeledFor.java
import static net.mindview.util.Print.*;

public class LabeledFor
{
    static void init(String s)
    {
        print(s + "初始化了一次");
    }

    static void step(String s)
    {
        print(s + " step了一次"); 
    }


    public static void main(String[] args)
    {
        int i = 0;
        outer:
        for (init("outer"); true; step("outer"))
        {
            inner:
            for (init("inner"); i < 10; step("inner"), i++)
            {
                Print.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 k = 0; k < 5; k++)
                {
                    if (k == 3)
                    {
                        print("continue inner");
                        continue inner;
                    }
                }
            }
        }
    }
}/*Output
    outer初始化了一次
        inner初始化了一次
            i = 0
            continue inner
          inner step了一次
            i = 1
            continue inner
          inner step了一次
            i = 2
            continue
          inner step了一次
            i = 3
            break
      outer step了一次
        inner初始化了一次
            i = 4
            continue inner
          inner step了一次
            i = 5
            continue inner
          inner step了一次
            i = 6
            continue inner
          inner step了一次
            i = 7
            continue outer
      outer step了一次
        inner初始化了一次
            i = 8
            break outer
    *///:~可以得知continue之后会执行step，break不会

如果想在中断循环的同时退出，简单地用一个return即可。return会结束整个方法，break label跳出循环后循环后面的代码还会依次执行。

4.8 switch

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

由于Random.nextInt(26)会产生0到26之间的一个值，所以在其上加上一个偏移量“a”，即可产生小写字母。

int c = rand.nextInt(26) + 'a' ;

Random.nextInt()将产生0~25之间的一个随机int值，它将被加到“a”上。这表示“a”将自动被转换为int以执行加法。

练习9：(4)一个斐波那契数列是由数字
1、1、2、3、5、8、13、21、34等等组成的，其中每一个数字（从第三个数字起）都是前两个数字的和。创建一个方法，接受一个整数参数，并显示从第一个元素开始总共由该参数指定的个数所构成的所有斐波那契数字。例如，如果运行java
Fibonacci 5（其中Ffbonaccl是类名），那么输出就应该是 1、1、2、3、5。
练习10：(5)吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排序。以两个0结尾的数字是不允许的，例如，下列数字都是“吸血鬼”数字：
1260 = 21 * 60 ; 1827 = 21 * 87 ; 2187 = 27 * 81
写一个程序，找出4位数的所有吸血鬼数字（Dan Forhan推荐）。

@Test
    public void exercises9() {
        float f[] = new float[5];
        for(int i=0; i< 5; i++) {
            if(i == 0) {
                f[i] = 1;
            }else if(i == 1) {
                f[i] = 1;
            }else {
                f[i] = f[i-1] + f[i-2];
            }
            System.out.println(f[i]);
        }
    }
    @Test
    public void exercises10() {
        Integer x = 1111;
        System.out.println(x.toString().length());
        for(int i = 9; i < 100; i ++) {
            for(int j = 9; j < 100; j ++) {
                int product = i * j;
                if(product%100 != 0 && String.valueOf(product).length() == 4) {
                    System.out.println(product + " = " + i + "*" + j);
                }
            }
        }
        
        
    }