Java基础: 控制语句，循环语句

控制语句（if / switch) 

if (有单选择结构, 双选择结构, 多选择结构)

        int age  = (int)(Math.random() * 100);
        System.out.println("age is " + age + ", you're ");
        if (age < 15){
            System.out.print("children, enjoy playing!");
        }else if (age < 25){
            System.out.print("teenager, enjoy studying!");
        }else if (age <45){
            System.out.print("adult, enjoy making money!");
        }else if (age <85){
            System.out.print("senior people, enjoy life!");
        }

 

switch (多选择结构)

switch一般只用于多值的判断，而if else一般用于区间的判断，当然也可以用于多值的判断。

到达"break"程序结束，所以下面例子1，2，3都print同一句话。

swith一般判断条件的值为int, java 1.7以后也可以用string, if else可以完全替代switch。

 

int month  = (int)(Math.random() * 12 + 1);
        System.out.println("Month: " + month);
        switch (month){
            case 1:
            case 2:
            case 3:
                System.out.println("It is Spring now!");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("It is Summer now!");
                break;
            case 7:
            case 8:
            case 9:
                System.out.println("It is Autumn now!");
                break;
            case 10:
            case 11:
            case 12:
                System.out.println("It is Winter now!");
                break;
        }

 

 

循环语句 while, for , do while 

while: 

 //while练习, 循环累加到100
        int i = 0;
        int sum = 0;

        while(i <=100){
            sum += i;
            i++;
        }

        System.out.println(sum);

 

 一定要写  i++， 否则每一次循环i的值没有改变，判断条件永远满足，程序会一直循环下去，最终陷入死循环。

 

for: (和while相比，for的初始值，判断条件，步进迭代全部写在了一起)

        //for练习, 循环累加到100
        int sum = 0;

        for (int i = 1; i<=100; i++){
            sum += i;
        }
        System.out.println(sum);
    }

/**
*程序执行步骤
*1. 执行初始化语句: i= 1;
*2. 判断：i <= 100;
*3. 执行循环体: sum+=1;
*4. 步进迭代: i ++
*5. 回到第二步继续判断
*/

 

写个死循环非常简单,让判断条件一直成立就可以

for(;;){
    System.out.println("循环到永远")
}


//也可以
while(true){
    System.out.println("循环到永远")
}

 

 

嵌套循环

本质就是在一个循环里面,再套一个循环. 一般就是套两层.

        //嵌套循环练习, 打印99乘法表
        for (int i = 1; i<=9; i++){
            for (int j = 1; j<=i; j++){
                System.out.print(j + "*" + i + "= " +(i*j) +"\t" );    //先把一行打印出来

            }
            System.out.println();  //换行

        }

输出结果
1*1= 1    
1*2= 2    2*2= 4    
1*3= 3    2*3= 6    3*3= 9    
1*4= 4    2*4= 8    3*4= 12    4*4= 16    
1*5= 5    2*5= 10    3*5= 15    4*5= 20    5*5= 25    
1*6= 6    2*6= 12    3*6= 18    4*6= 24    5*6= 30    6*6= 36    
1*7= 7    2*7= 14    3*7= 21    4*7= 28    5*7= 35    6*7= 42    7*7= 49    
1*8= 8    2*8= 16    3*8= 24    4*8= 32    5*8= 40    6*8= 48    7*8= 56    8*8= 64    
1*9= 9    2*9= 18    3*9= 27    4*9= 36    5*9= 45    6*9= 54    7*9= 63    8*9= 72    9*9= 81    

 

 

break / continue

break: 中止整个循环.  continue: 中止本次循环，继续下一次

        //break练习,0-100随机多少次可以随机到88
        int count = 0; //定义计数器
        System.out.println("Game begin!");
        while (true){
            count++; //每循环一次计数器+1
            int i = (int)(Math.random() * 100);
            System.out.println(i);
            if (i == 88){
                break; //循环到88时, 退出循环
            }
        }
        System.out.println("Game over, used " + count + " times to get 88!");
    }

        //continue练习,输出100-150之间不能被3整除的数, 打印出来, 每行输出5个


        int count = 0; //定义计数器
        for (int i = 100; i<150; i++){
            if (i%3 ==0){
                continue; //如果是3的倍数,跳出本次循环,进入下一次循环
            }
            System.out.print(i +"\t"); //否则,代表不是3的倍数,输出该数字
            count++;  //每输出一个数,计数器+1
            if (count%5==0){    //如果计数器已经到达5,换行
                System.out.println();
                count = 0;
            }
        }

 

带标签的break / continue， 可以帮助从内部循环跳到外部循环（不常用）

      //带标签的continue练习,打印101-150之间所有的质数(只能被1和自己整除)
        outloop: for (int i = 101; i<150; i++){
            for (int j =2; j<i/2; j++){
                if (i%j==0){
                    continue outloop;
                }
            }
            System.out.print(i + "\t");
        }

 

 

递归和迭代

递归就是在自己的方法里面call自己，迭代就是循环，递归非常的没有效率，因为call了太多的方法

    //递归练习,算阶乘可以用到递归 10*9*8*...*1
    static int factorial(int n){
        if (n==1){
            return 1;
        }else {
            return n * factorial(n -1);
        }
    }

    //用迭代循环代替递归, 实现相同的阶乘功能, 且速度会快很多, 因为不用打开巨量的方法
    static int factorialLoop (int m){
        int result = 1;
        while (m>1){
            result *= m*(m-1); //当m=10, result = 10 *9, 当m=9, result = result(10*9)*（8*7） 
            m-=2;
        }
        return result;
    }