Java------流量控制语句

一、流程控制  

     在进行后面复习之前,要永远记住一句话,在没有任何控制程序的加持下,程序的运行时自上而的顺序依次运行,没有例外!

1、赋值语句

      字面意思:在一个表达式中当一个值赋给某个变量后,这个表达式就成一个赋值语句.

      值得注意的是 java 中不单单只有进行数值运算才可进行赋值, 其实创建的对象的过程也是可以看成赋值的过程.

      最容易混淆的点是:java 的赋值运算符是 = ;但是它不等同数学中的等号,在java中(其他语言) = 属于赋值运算符 , 而 java 中的 == 才可以近似看成数学中的等号,在java中 == 长用作 判断两个操作数是否相等,不单单是等于;

2、分支语句

     ①if...else...

     语法格式:

      if(条件表达式){

          语句1;                     

      }else{ 

           语句2;

      }

    当然 if...else... 不仅仅只是这样固定的方式,它随着程序员的需求有不同的表现形式:

 1 public class Test06 {
 2     
 3     public static void main(String[] args) {
 4         
 5         int x = 3;
 6         int y = 4;
 7         
 8         // 第一种表现形式
 9         if (x == y) {
10             System.out.println("true");
11         }else {
12             System.out.println("false");
13         }
14         // output result: false;
15         
16         // 第二种表现形式
17         if (x != y) {
18             System.out.println("true");
19         } 
20         // output result: true;
21         
22         // 第三种表现形式
23         if(x == y) {
24             System.out.println("true");
25         }
26         else if(x < y){
27             System.out.println("true");
28         }else {
29             System.out.println("false");
30         }
31         // output result: true;
32         // 第三中表现形式可以不断的增加 else if 
33         // 从输出结果可以看出,当分支程序的条件表达式的 result 一 
34         // 直是 false 则不断的往下继续判断剩余的分支程序else 终止
35         // 当一个分支程序一段分支的条件表达式的 result 是true,则输 
36         // 出该分支程序的值,剩余的分支段不执行
37     }
38 }

    if...else...还有一个重点与难点:关于 if 语句的嵌套:

public class Test06 {
    
    public static void main(String[] args) {
        
        int x = 3;
        int y = 4;
        
        if (x != y) {
            if (x < y) {
                System.out.println("完全正确");
            }else {
                System.out.println("部分正确");
            }
        }else {
            System.out.println("完全错误");
        }
                // output result: 完全正确 
        
        if (x != y) {
            if (x > y) {
                System.out.println("完全正确");
            }else {
                System.out.println("部分正确");
            }
        }else {
            System.out.println("完全错误");
        }
            // output result: 部分正确 
            
        if (x == y) {
            if (x > y) {
                System.out.println("完全正确");
            }else {
                System.out.println("部分正确");
            }
        }else {
            System.out.println("完全错误");
        }
                // output result: 完全错误
    }
}

    ②switch语句

    switch(表达式){

    case c1:

             语句组1;

             break;

    case c2:

             语句组2;

             break;

   

    default

             语句组;

             break;

    }

    注意: switch 中的表达式的计算结果必须是 int 型或 char 型(short 与 byte 的使用要提升). 禁止使用浮点型与 long 型,并且 switch 中的表达式是与 case 中的 c1... 进行关系运算   

 1 import java.util.*;
 2 
 3 public class Test07 {
 4 
 5     public static void main(String[] args) {
 6         
 7           for(int i = 0; i < 10;++i) {
 8                 Scanner s = new Scanner(System.in);
 9                 int x = s.nextInt();
10         
11             // switch (x ==y) {    // 这样的表达式是错误的:因为这个表达式不是条件表达式,这个表达式是与下面的任何 case 进行关系运算
12                 switch (x) {
13                     case 1:
14                         System.out.println("今天是星期一");
15                         break;
16             
17                     case 2:
18                         System.out.println("今天是星期二");
19                         break;
20         
21                     case 3:
22                         System.out.println("今天是星期三");
23                         break;
24         
25                     default:
26                         System.out.println("都没有");
27                         break;
28            }
29        }
30    }
31 }                                                            

    这个程序中有两个没有见到过的关键字: break 和 default:

     1、 default:  表示在 switch 语句中 任何一个 case 都没有与之相对应的结果,则进入 default 执行语句组,其实与 if 语句的 else 的本质相同; 

      这里产生了一个疑问, default 放置在 switch 语句中任何位置对整个程序有什么影响?

            default 放置在任何的位置(switch 的首位置),判断其对switch语句的影响取决于 break 与 switch - case 之间的判断结果:

            ① 如果没有 break 且 witch - case 之间的判断结果为假 -------------> 输出 default 的语句组且往下继续执行输出与 default 最近的 case 语句组

            ② 如果有 break 且 witch - case 之间的判断结果为假 ----------------> 输出 default 的语句组

            ③ 如果有break 且 witch - case 之间的判断结果为真 -----------------> 不输出 default 的语句组,而是输出真值 

            ④ 如果没有break 且 witch - case 之间的判断结果为真 --------------> 不输出 default 的语句组,而是输出真值 

     2、break :(1).结束当前整个循环，执行当前循环下边的语句.忽略循环体中任何其它语句和循环条件测试.

                      (2).只能跳出一层循环，如果你的循环是嵌套循环，那么你需要按照你嵌套的层次，逐步使用break来跳出。[逐层判断，逐步跳出]

 1 public class Test08 {
 2 
 3     public static void main(String[] args) {
 4         
 5             int k = 0;
 6             int sum = 0;
 7         
 8             for (int a = 0 ; a < 20; a++) {
 9                          k += a; 
10                  for(int b = 1; b < 5; b ++) {
11                         sum += b;
12                         break;  // 此处的break 结束 for(b) 的循环,并直接往下执行
13         }
14             // break;
15            System.out.println(sum);   // 上一行的 break 执行 已经结束了 整一个 for(a) 循环,所有在其后面再加入语句则会编译错误 
16            break; // 此处的break 结束 for(a) 的循环,并直接往下执行
17     }
18         System.out.println(k);
19         System.out.println(sum);
20     }    
21 }        
22 // output result: 1 0 1               

                      (3).break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。

package Review;

public class Test08 {

    public static void main(String[] args) {
        int sum = 0;
        for (int a = 0 ; a < 20; a++) {
            
            sum += a;
            break;
        }
        System.out.println(sum);
    }
}

                      (4).当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。 总的来说：就近原则，结束当前的整个判断。

import java.util.*;

public class Test07 {

    public static void main(String[] args) {
        
          for(int i = 0; i < 10;++i) {
            Scanner s = new Scanner(System.in);
            int x = s.nextInt();
        
            switch (x) {
                case 1:
                    System.out.println("今天是星期一");
            
                case 2:
                    System.out.println("今天是星期二");
                break;
        
                case 3:
                System.out.println("今天是星期三");
                break;
    
                default:
                System.out.println("都没有");
          }
       }
    }
}

/* output result: 
1
今天是星期一
今天是星期二
*/    

   

      switch 的综合性程序:

import java.util.*;

public class Test09 {

    public static void main(String[] args) {
        
        
        // 输入一个成绩 判断它成绩再哪个阶段
           for(int i = 0; i < 100; i++) {
                Scanner s = new Scanner(System.in);
                int grade = s.nextInt();

        if (grade <= 100 && grade >= 0) {
        
            int x1 = grade / 10;
            
            switch(x1) {
            
                case 9: case 10:
                    System.out.println("优秀!");
                    break;
                case 8:
                    System.out.println("优良");
                    break;
                case 7:
                    System.out.println("良");
                    break;
                case 6:
                    System.out.println("及格");
                    break;
                default:
                    System.out.println("拖出去宰了");
                    break;
             }        
        }else{
                System.out.println("输入错误");
        }
    }
}
}

3、循环语句

      for 语句

     语句的表达式: 

     for(初始语句; 条件表达式;迭代语句){

                循环体语句;

     }

    关于 for 循环与 if 语句的嵌套使用代码程序:

/**
 * 银行账户取钱程序(输入账户最多三个,输入密码最多三次,取钱取到没钱为止)
 * */
import java.util.*;

import java.math.*;

public class Test10 {

    public static void main(String[] args) {
        
        String cs = "no";
        String k = "yes";

        int y = 80000;

        String account = "cheng";      // 账号
         String password = "1";  // 密码
        
         System.out.print("请输入你的账户:" );
        Scanner s = new Scanner(System.in);
        String str = s.next();  // 
            
        // 循环账户重复输入
        for(int i =0; i < 3; ++i) {
            
            // 判断账户输入是否正确
            if (str.equals(account) == true) {
                
                System.out.print("请输入你的密码:" + " ");
                Scanner sc = new Scanner(System.in);
                String stri = sc.next();
                
                // 循环密码重复输入
                for ( int j = 0; j < 3; j++) {
                    
                    // 判断密码输入是否正确
                    if (stri.equals(password) == true) {
                        
                        System.out.println("你的账户余额有:" + y);
                        System.out.print("请输入你要取出的金额:" );
                        
                        Scanner sca = new Scanner(System.in);
                        int amount = sca.nextInt();
                        
                        int p = y / 100;
                        int balance = y - amount;
                        
                        System.out.println("你的账户余额有" + balance);
                        
                        // 判断账户余额是否为0
                        if (balance <= 0) {
                            System.out.println("你的银行卡没有money,你个穷屌丝");
                            System.out.println("银行卡已退出,请取走你的银行卡");
                            break;
                        }
                        
                        // 循环取钱次数
                        for(int g = 0; g < p - 1; ++g) {
                            
                            System.out.print("你是否还需再取出金额: " );
                            Scanner scan = new Scanner(System.in);
                            String strin= scan.next();
                            
                            // 判断是否要继续取钱
                            if(strin.equals(k)) {
                                
                                System.out.print("请再次输入你要取出的金额:" );
                                amount = sca.nextInt();
                                balance = balance - amount;
                                
                                // 判断账户金额是否为0
                                if (balance <= 0) {
                                    System.out.println("你的银行卡没有money,你个穷屌丝");
                                    System.out.println("银行卡已退出,请取走你的银行卡");
                                    break;
                                }else {
                                    System.out.println("你的账户余额有" + balance);    
                                }
                            }else if (strin.equals(cs)) {
                                System.out.println("银行卡已退出,请取走你的银行卡");
                            }else {
                                System.out.println("小鬼, 你连 yes 和  no 都打不清 还想继续取钱 没门");
                                break;
                            }
                            break;
                        }
            
                        break;
                    }else if (j < 2) {
                        System.out.print("请再次输入你的密码:" );
                        stri = sc.next();
                        
                    }else {
                        System.out.println("密码输入次数太多,请取回卡!");
                        break;
                    }
                }
                    break;
            }else if ( i < 2) {
                System.out.print("请再次输入你的账户:" );
                str = s.next();
       
            }else {
                System.out.println("账户输入超时,请取回卡!");
                break;
            }
        }
    }
 }

    while 语句

     语句表达式：

     while（条件表达式）{

     循环体语句；

     }

     while 与 for 都是相同的循环体结构，并且两者都可以相互的转换使用，但是两者还是有些许区别：

             从结构上可以可以看出，for 中有更多的语句，使得 for 循环的可读性更高；

             从应用上来看，for 多用于循环次数明确的场景，while 多用于循环次数不够明确的场景，并且 while 的条件表达式，只要它的判定是 true 他就会一直无限的执行下去；而 for 循环都是条件表达式明确的

public class Test12 {

    public static void main(String[] args) {

        int sum01 = 0;
        int sum02 = 0;
        // for 循环
        for(int i = 0;  i<10; i++){
            sum01 += i;
            System.out.print(sum01 + " ");
        }
        //System.out.println(sum01);
        System.out.println();
        System.out.println("-------------------");

        int j = 0;
        while (true){   
            sum02 += j;
            ++j;
           System.out.print(sum02 + " ");
        }
        //System.out.println(sum02);
    }
}

      

      do...while...

      语法表达式：

       do{

           语句；

       }while（条件表达式）；

       从这个 do...while... 的语法格式，与程序顺序执行 可以看出 do...while... 的执行顺序是先执行语句然后进行判断，为真 返回上级继续执行，为假结束执行，也就是说无论 while 的判断是否真假， do...while...

都会先执行出语句内容；

public class Test13 {

    public static void main(String[] args) {

        int i = 1;
        int sum = 0;
        do {
            sum += i;
            i++;
        }while(i < 10);

        System.out.println(sum);

        int j = 1;     
        int sum01 = 0;
        do {             
            sum01 += j;
            j++;
        }while(j < -1);  // 该循环体先执行语句，在执行 while 的条件表达式
        System.out.println(sum01);
    }
}

      break 与 continue 的用法 与 区别

     break的用法：

     1、在 switch 与 循环体中 break 的作用是跳过本语句块中余下的所有语句，转到块尾，执行其后的语句；

public class Test14 {

    public static void main(String[] args) {

        for(int i = 0; i < 10; i++){
            System.out.print("你好！" + " ");
            break;
        }

        System.out.println("大家好！");
        // output result: 你好！ 大家好！
        // 该程序添加 break 与不添加的区别；不添加 break 则 for 循环会一直执行到条件表达式为假为止，则输出结果将会为：
        // 你好!(10 次输出) 大家好！
        // 而添加 break 后，程序顺序执行到 break 后直接跳出 for 循环执行后面的语句；输出结果为：
        // 你好！（1 次输出）大家好！

        System.out.println();

        /*for(int i = 0; i < 10; i++) {
            break;
            System.out.print("你好！" + " ");  // Unreachable statement : 不能达到的声明
    }
        System.out.println("大家好！"); */
        // 如果 break 放在 for 循环的执行语句前呢？
        // 很明显程序直接在编译阶段出现了 error： 无法访问 18 行的执行代码；所以这种代码方式是错误的，不能这样书写；

        for(int i = 0; i < 10; i++) break;{
            System.out.print("你好！" + " ");
        }
        System.out.println("大家好！");
        // 再看看这方式；这个程序的执行顺序是什么样的
        // 当执行 for 括号中的语句完后，本应该执行大括号中语句块，但在这之前先遇见了 break 语句，按照 break 的特性直接
        // 跳过本循环的其余语句，执行后面的语句，奇妙的事情发生了，因为有了 break 语句造成了之前 for 循环留下的语句块，
        // 使得该语句块的程序与 for 循环分隔成为独立的程序，所以 break 执行后 37 行的语句成为独立的语句单独顺序执行
        // output result: 你好！ 大家好！
}
}

     2、在块中和标号配合使用，其语法格式是： break 标号；

public class Test15 {
    public static void main(String[] args) {

        int x = 20;
        out:for( int  i = 2; i < 10; i++){  // out： ---> 标记
            System.out.println("begin i = " +" "+ i);

            while(x < 1000){
                System.out.println("i = " + i +" " +", x = " + x);
                if (x * i >= 80) {
                    break out;
                    /** break 与 break out 的区别：
                     *      先谈谈 break out 的用法: 首先有一个 out：的标记，该标记用于当出现 break out 语句执行时，跳到该标记的位置，
                     *      以这个位置为出发点，跳过这个出发点所包含的整个语句块，随后执行下一个语句块，从这个程序可以看出，out： 标记在了 
                     *      for 循环上，也就是说当程序执行到 break out 后直接跳过这个 for 循环本身，直接执行 for 循环以外的程序*/
                }else{
                    x += 5;
                }
            }
        }
        System.out.println("after out look");
    }
}

/** 所以 break 与 break out 的区别就一目了然了：break 跳过本块余下语句，转到块尾，执行块后的语句，而 break out 是跳到所标记的位置，然后跳过
 *  out：所标记的整个循环语句块，执行其余的语句块，
 *  
 *  break out 自然就拥有了 break 所没有的选择性
 * */

     continue的用法：

     1、是结束此次循环执行下一次循环； 

     2、在块中和标号配合使用，其语法格式是：continue 标号；

public class Test16 {
    public static void main(String[] args) {

        out: for(int i = 0; i < 10; i++){

                    for (int j = 0; j < 20; j++) {

                        if (j > i){
                            System.out.println();
                         // break;  // 当 if 判断正确输出 11 行 ，执行到此处时跳过本程序的剩余语句，也就是跳过从12行开始到23行的所有执行
                                    // 程序，直接执行 24 行 System.out.print("*  ")；
                            // 为什么 for 中 嵌套 if 语句时 if 中的 break 语句是对 for 进行跳转？
                                    // if 本身也是一个分支跳转语句，所以 if 与 break 连用时不考虑 break 是否只对 if 进行跳转
                                    // 它们两个作为一个整体在 for 中 ，所以 break 结束的是 for 余下的循环执行程序
                            continue out;
                        }
                     // break; // 跳过 8 行 for 循环，直接执行 24 行 System.out.print("*  ")；
                        System.out.print("*  ");
                        /**  continue 的用法是结束当此循环执行下一次循环,当然 也可以与标号连用，语法上： continue out 其用法：
                         *   结束当次循环执行 out： 所标记的程序起点。
                         * */
                    }// System.out.print("*  ");

        }
    }
}
/** output result:
 *   *
 *   *  *
 *   *  *  *
 *   *  *  *  *
 *   *  *  *  *  *
 *   *  *  *  *  *  *
 *   *  *  *  *  *  *  *
 *   *  *  *  *  *  *  *  *
 *   *  *  *  *  *  *  *  *  * */