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

一、流程控制

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

1、赋值语句

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

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

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

2、分支语句

①if...else...

语法格式:

if(条件表达式){

语句1;

}else{

语句2;

}

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

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

View Code

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

 1 public class Test06 {
 2     
 3     public static void main(String[] args) {
 4         
 5         int x = 3;
 6         int y = 4;
 7         
 8         if (x != y) {
 9             if (x < y) {
10                 System.out.println("完全正确");
11             }else {
12                 System.out.println("部分正确");
13             }
14         }else {
15             System.out.println("完全错误");
16         }
17                 // output result: 完全正确 
18         
19         if (x != y) {
20             if (x > y) {
21                 System.out.println("完全正确");
22             }else {
23                 System.out.println("部分正确");
24             }
25         }else {
26             System.out.println("完全错误");
27         }
28             // output result: 部分正确 
29             
30         if (x == y) {
31             if (x > y) {
32                 System.out.println("完全正确");
33             }else {
34                 System.out.println("部分正确");
35             }
36         }else {
37             System.out.println("完全错误");
38         }
39                 // output result: 完全错误
40     }
41 }

View Code

②switch语句

switch(表达式){

case c1:

语句组1;

break;

case c2:

语句组2;

break;

default

语句组;

break;

}

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

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

View Code

这个程序中有两个没有见到过的关键字: 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

View Code

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

 1 package Review;
 2 
 3 public class Test08 {
 4 
 5     public static void main(String[] args) {
 6         int sum = 0;
 7         for (int a = 0 ; a < 20; a++) {
 8             
 9             sum += a;
10             break;
11         }
12         System.out.println(sum);
13     }
14 }

View Code

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

 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) {
12                 case 1:
13                     System.out.println("今天是星期一");
14             
15                 case 2:
16                     System.out.println("今天是星期二");
17                 break;
18         
19                 case 3:
20                 System.out.println("今天是星期三");
21                 break;
22     
23                 default:
24                 System.out.println("都没有");
25           }
26        }
27     }
28 }
29 
30 /* output result: 
31 1
32 今天是星期一
33 今天是星期二
34 */

View Code

switch 的综合性程序:

 1 import java.util.*;
 2 
 3 public class Test09 {
 4 
 5     public static void main(String[] args) {
 6         
 7         
 8         // 输入一个成绩 判断它成绩再哪个阶段
 9            for(int i = 0; i < 100; i++) {
10                 Scanner s = new Scanner(System.in);
11                 int grade = s.nextInt();
12 
13         if (grade <= 100 && grade >= 0) {
14         
15             int x1 = grade / 10;
16             
17             switch(x1) {
18             
19                 case 9: case 10:
20                     System.out.println("优秀!");
21                     break;
22                 case 8:
23                     System.out.println("优良");
24                     break;
25                 case 7:
26                     System.out.println("良");
27                     break;
28                 case 6:
29                     System.out.println("及格");
30                     break;
31                 default:
32                     System.out.println("拖出去宰了");
33                     break;
34              }        
35         }else{
36                 System.out.println("输入错误");
37         }
38     }
39 }
40 }

View Code

3、循环语句

for 语句

语句的表达式:

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

循环体语句;

}

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

  1 /**
  2  * 银行账户取钱程序(输入账户最多三个,输入密码最多三次,取钱取到没钱为止)
  3  * */
  4 import java.util.*;
  5 
  6 import java.math.*;
  7 
  8 public class Test10 {
  9 
 10     public static void main(String[] args) {
 11         
 12         String cs = "no";
 13         String k = "yes";
 14 
 15         int y = 80000;
 16 
 17         String account = "cheng";      // 账号
 18          String password = "1";  // 密码
 19         
 20          System.out.print("请输入你的账户:" );
 21         Scanner s = new Scanner(System.in);
 22         String str = s.next();  // 
 23             
 24         // 循环账户重复输入
 25         for(int i =0; i < 3; ++i) {
 26             
 27             // 判断账户输入是否正确
 28             if (str.equals(account) == true) {
 29                 
 30                 System.out.print("请输入你的密码:" + " ");
 31                 Scanner sc = new Scanner(System.in);
 32                 String stri = sc.next();
 33                 
 34                 // 循环密码重复输入
 35                 for ( int j = 0; j < 3; j++) {
 36                     
 37                     // 判断密码输入是否正确
 38                     if (stri.equals(password) == true) {
 39                         
 40                         System.out.println("你的账户余额有:" + y);
 41                         System.out.print("请输入你要取出的金额:" );
 42                         
 43                         Scanner sca = new Scanner(System.in);
 44                         int amount = sca.nextInt();
 45                         
 46                         int p = y / 100;
 47                         int balance = y - amount;
 48                         
 49                         System.out.println("你的账户余额有" + balance);
 50                         
 51                         // 判断账户余额是否为0
 52                         if (balance <= 0) {
 53                             System.out.println("你的银行卡没有money,你个穷屌丝");
 54                             System.out.println("银行卡已退出,请取走你的银行卡");
 55                             break;
 56                         }
 57                         
 58                         // 循环取钱次数
 59                         for(int g = 0; g < p - 1; ++g) {
 60                             
 61                             System.out.print("你是否还需再取出金额: " );
 62                             Scanner scan = new Scanner(System.in);
 63                             String strin= scan.next();
 64                             
 65                             // 判断是否要继续取钱
 66                             if(strin.equals(k)) {
 67                                 
 68                                 System.out.print("请再次输入你要取出的金额:" );
 69                                 amount = sca.nextInt();
 70                                 balance = balance - amount;
 71                                 
 72                                 // 判断账户金额是否为0
 73                                 if (balance <= 0) {
 74                                     System.out.println("你的银行卡没有money,你个穷屌丝");
 75                                     System.out.println("银行卡已退出,请取走你的银行卡");
 76                                     break;
 77                                 }else {
 78                                     System.out.println("你的账户余额有" + balance);    
 79                                 }
 80                             }else if (strin.equals(cs)) {
 81                                 System.out.println("银行卡已退出,请取走你的银行卡");
 82                             }else {
 83                                 System.out.println("小鬼, 你连 yes 和  no 都打不清 还想继续取钱 没门");
 84                                 break;
 85                             }
 86                             break;
 87                         }
 88             
 89                         break;
 90                     }else if (j < 2) {
 91                         System.out.print("请再次输入你的密码:" );
 92                         stri = sc.next();
 93                         
 94                     }else {
 95                         System.out.println("密码输入次数太多,请取回卡!");
 96                         break;
 97                     }
 98                 }
 99                     break;
100             }else if ( i < 2) {
101                 System.out.print("请再次输入你的账户:" );
102                 str = s.next();
103        
104             }else {
105                 System.out.println("账户输入超时,请取回卡!");
106                 break;
107             }
108         }
109     }
110  }

View Code

while 语句

语句表达式：

while（条件表达式）{

循环体语句；

}

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

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

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

 1 public class Test12 {
 2 
 3     public static void main(String[] args) {
 4 
 5         int sum01 = 0;
 6         int sum02 = 0;
 7         // for 循环
 8         for(int i = 0;  i<10; i++){
 9             sum01 += i;
10             System.out.print(sum01 + " ");
11         }
12         //System.out.println(sum01);
13         System.out.println();
14         System.out.println("-------------------");
15 
16         int j = 0;
17         while (true){   
18             sum02 += j;
19             ++j;
20            System.out.print(sum02 + " ");
21         }
22         //System.out.println(sum02);
23     }
24 }

View Code

do...while...

语法表达式：

do{

语句；

}while（条件表达式）；

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

都会先执行出语句内容；

 1 public class Test13 {
 2 
 3     public static void main(String[] args) {
 4 
 5         int i = 1;
 6         int sum = 0;
 7         do {
 8             sum += i;
 9             i++;
10         }while(i < 10);
11 
12         System.out.println(sum);
13 
14         int j = 1;     
15         int sum01 = 0;
16         do {             
17             sum01 += j;
18             j++;
19         }while(j < -1);  // 该循环体先执行语句，在执行 while 的条件表达式
20         System.out.println(sum01);
21     }
22 }

View Code

break 与 continue 的用法与区别

break的用法：

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

 1 public class Test14 {
 2 
 3     public static void main(String[] args) {
 4 
 5         for(int i = 0; i < 10; i++){
 6             System.out.print("你好！" + " ");
 7             break;
 8         }
 9 
10         System.out.println("大家好！");
11         // output result: 你好！ 大家好！
12         // 该程序添加 break 与不添加的区别；不添加 break 则 for 循环会一直执行到条件表达式为假为止，则输出结果将会为：
13         // 你好!(10 次输出) 大家好！
14         // 而添加 break 后，程序顺序执行到 break 后直接跳出 for 循环执行后面的语句；输出结果为：
15         // 你好！（1 次输出）大家好！
16 
17         System.out.println();
18 
19         /*for(int i = 0; i < 10; i++) {
20             break;
21             System.out.print("你好！" + " ");  // Unreachable statement : 不能达到的声明
22     }
23         System.out.println("大家好！"); */
24         // 如果 break 放在 for 循环的执行语句前呢？
25         // 很明显程序直接在编译阶段出现了 error： 无法访问 18 行的执行代码；所以这种代码方式是错误的，不能这样书写；
26 
27         for(int i = 0; i < 10; i++) break;{
28             System.out.print("你好！" + " ");
29         }
30         System.out.println("大家好！");
31         // 再看看这方式；这个程序的执行顺序是什么样的
32         // 当执行 for 括号中的语句完后，本应该执行大括号中语句块，但在这之前先遇见了 break 语句，按照 break 的特性直接
33         // 跳过本循环的其余语句，执行后面的语句，奇妙的事情发生了，因为有了 break 语句造成了之前 for 循环留下的语句块，
34         // 使得该语句块的程序与 for 循环分隔成为独立的程序，所以 break 执行后 37 行的语句成为独立的语句单独顺序执行
35         // output result: 你好！ 大家好！
36 }
37 }

View Code

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

 1 public class Test15 {
 2     public static void main(String[] args) {
 3 
 4         int x = 20;
 5         out:for( int  i = 2; i < 10; i++){  // out： ---> 标记
 6             System.out.println("begin i = " +" "+ i);
 7 
 8             while(x < 1000){
 9                 System.out.println("i = " + i +" " +", x = " + x);
10                 if (x * i >= 80) {
11                     break out;
12                     /** break 与 break out 的区别：
13                      *      先谈谈 break out 的用法: 首先有一个 out：的标记，该标记用于当出现 break out 语句执行时，跳到该标记的位置，
14                      *      以这个位置为出发点，跳过这个出发点所包含的整个语句块，随后执行下一个语句块，从这个程序可以看出，out： 标记在了 
15                      *      for 循环上，也就是说当程序执行到 break out 后直接跳过这个 for 循环本身，直接执行 for 循环以外的程序*/
16                 }else{
17                     x += 5;
18                 }
19             }
20         }
21         System.out.println("after out look");
22     }
23 }
24 
25 /** 所以 break 与 break out 的区别就一目了然了：break 跳过本块余下语句，转到块尾，执行块后的语句，而 break out 是跳到所标记的位置，然后跳过
26  *  out：所标记的整个循环语句块，执行其余的语句块，
27  *  
28  *  break out 自然就拥有了 break 所没有的选择性
29  * */

View Code

continue的用法：

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

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

 1 public class Test16 {
 2     public static void main(String[] args) {
 3 
 4         out: for(int i = 0; i < 10; i++){
 5 
 6                     for (int j = 0; j < 20; j++) {
 7 
 8                         if (j > i){
 9                             System.out.println();
10                          // break;  // 当 if 判断正确输出 11 行 ，执行到此处时跳过本程序的剩余语句，也就是跳过从12行开始到23行的所有执行
11                                     // 程序，直接执行 24 行 System.out.print("*  ")；
12                             // 为什么 for 中 嵌套 if 语句时 if 中的 break 语句是对 for 进行跳转？
13                                     // if 本身也是一个分支跳转语句，所以 if 与 break 连用时不考虑 break 是否只对 if 进行跳转
14                                     // 它们两个作为一个整体在 for 中 ，所以 break 结束的是 for 余下的循环执行程序
15                             continue out;
16                         }
17                      // break; // 跳过 8 行 for 循环，直接执行 24 行 System.out.print("*  ")；
18                         System.out.print("*  ");
19                         /**  continue 的用法是结束当此循环执行下一次循环,当然 也可以与标号连用，语法上： continue out 其用法：
20                          *   结束当次循环执行 out： 所标记的程序起点。
21                          * */
22                     }// System.out.print("*  ");
23 
24         }
25     }
26 }
27 /** output result:
28  *   *
29  *   *  *
30  *   *  *  *
31  *   *  *  *  *
32  *   *  *  *  *  *
33  *   *  *  *  *  *  *
34  *   *  *  *  *  *  *  *
35  *   *  *  *  *  *  *  *  *
36  *   *  *  *  *  *  *  *  *  * */

View Code