Java流程控制

Posted 2020-12-01 放弃不难，但坚持一定很酷

4.流程控制

4.1关于代码的三种结构

①顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

②分支结构

根据条件，选择性地执行某段代码。有if…else和switch-case两种分支语句。

③循环结构

根据循环条件，重复性的执行某段代码。有while(){}、do{}while()、for(;;){}三种循环语句。（注：JDK1.5提供了for each循环，方便的遍历集合、数组元素）

4.2分支结构

4.2.1条件判断： if-else语句

第一种结构：

if(boolean表达式){                                    java语句;                             }

第二种结构：

if(boolean表达式){                                    java语句;                             }else{                                    java语句;                             }

第三种结构：

if(boolean表达式){                                    java语句;                             }else if(boolean表达式){                                    java语句;                             }else if(boolean表达式){                                    java语句;                             }

第四种结构：

if(boolean表达式){                                    java语句;                             }else if(boolean表达式){                                    java语句;                             }else {                                    java语句;                             }

注意：

①一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。即在if语句中只要有一个分支执行，则整个if语句结束。上面的结构二和四可以保证一定会有一个分支语句执行，因为他们都有else语句。

②如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序。如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。

③分支语句中，如果只有一条java语句，大括号可以省略。不推荐使用，别人这样写能看懂就行。

if(isSuccess)                      System.out.println("登录成功");                else                      System.out.println("登录失败");

④例题：

系统给定人的年龄.[1-100]

系统给定程序，通过人的年龄，来判断这个人处于生命的哪个阶段：

[1-5] 幼儿 [6-18] 少年 [19-35] 青年 [36-55] 中年 [56-100] 老年

public class IfTest02{        public static void main(String[] args){        //该程序假定年龄是合法的。               int age = 56;               /*if(age>=1 && age<=5){                      System.out.println("幼儿");               }else if(age<=18){                      System.out.println("少年");               }else if(age <= 35){                      System.out.println("青年");               }else if(age<= 55){                      System.out.println("中年");               }else{                      System.out.println("老年");               }*/            //String不是基本数据类型，是引用类型               String grade = "老年";               if(age>=1 && age<=5){                      grade = "幼儿";               }else if(age<=18){                      grade = "少年";               }else if(age <= 35){                      grade = "青年";               }else if(age<= 55){                      grade = "中年";               }               System.out.println(grade);        }}

4.2.2选择结构：switch语句

格式：

switch(变量){ case 常量1:语句1;break; case 常量2:语句2;break; … … case 常量N:语句N;break; default:语句;break; }

规则：

①switch(表达式)中表达式的返回值必须是下述几种类型之一：byte，short，char，int，枚举，String；

②case子句中的值必须是常量，且所有case子句中的值应是不同的；

③default是可以省略的，并且其位置也是灵活的，但是通常将其放在case语句之后，当没有匹配的case时，执行default；

④break语句用来在执行完一个case分支后使程序跳出switch语句块；break语句也可以没有，如果没有break，程序会顺序执行到switch结尾。

switch和if语句的对比：

⑤如果判断的具体数值不多，而且符合byte、 short 、int、 char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。

⑥其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

4.3循环结构

l  循环语句功能

• 在某些条件满足的情况下，反复执行特定代码的功能

l  循环语句的四个组成部分

• 初始化部分（init_statement）
• 循环条件部分（test_exp）
• 循环体部分（body_statement）
• 迭代部分（alter_statement）

l  循环语句分类

• for 循环
• while 循环
• do/while 循环

4.3.1 for 循环

for(表达式1;表达式2;表达式3){                       java语句;                }

 

表达式1是初始化表达式，最先执行，只执行一次。表达式2必须是boolean类型的表达式。

for循环开始执行，先执行表达式1，并只执行一次。进而判断表达式2的结果，如果是true，则执行java语句。再执行表达式3，然后再判断表达式2的结果，直到表达式2的结果是false，则for循环结束。

 

 

注：①死循环

for(;;){                      System.out.println("Test");                }

doc环境下按ctrl+c 停止，强制退出。

②关于for循环的嵌套，所有控制语句都可以嵌套在一起使用。

public class ForTest02{               public static void main(String[] args){                      for(int i=5;i>0;i--){                             for(int j=0;j<i;j++){                                    System.out.print(j+" ");                             }                             //换行                //System.out.println();                             System.out.print("\\n");                      }               } }

练习：①使用嵌套的for循环打印九九乘法表

              1*1=1

              2*1=2 2*2=4

              .......

              9*1=9...............9*9=81

public class ForTest03{        public static void main(String[] args){               for(int i=1;i<=9;i++){//一共有9行                      for(int j=1;j<=i;j++){//每行有i个等式                             System.out.print(i + "*"+ j +"=" + (i*j) + " ");                      }                      System.out.println();               }        }}

②计算1-100之间所有奇数的求和。

public class ForTest04{        public static void main(String[] args){               /*               int sum = 0;               for(int i=1;i<=100;i++){                                           if(i%2 != 0){                          //奇数               //追加                             sum += i;                      }               }               System.out.println(sum);               */        //加入人为因素        //效率高.               int sum = 0;               for(int i=1;i<=99;i+=2){                      sum += i;               }               System.out.println(sum);        } }

4.3.2 while 循环语句（while循环的次数是：0-N次）

while(boolean表达式){                             java语句;                        }

4.3.3 do-while 循环语句（该循环执行的次数是：1-N）

do{                             java语句;                       }while(boolean表达式);

注：①不同的循环结构之间可以相互转换

    ②while和do-while的区别：do-while程序至少会执行一次。while先判断符合条件才执行，do-while循环先执行一次再判断。

       ③死循环：

while(true){                      System.out.println("Test");               }

④嵌套循环：循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。若外层循环执行m次，内层循环执行n次，整个程序执行m*n次。

  ⑤格式：①初始化条件②循环条件③迭代部分④循环体

for(①;②;③){               ④ }

① while(②){               ④               ③ }

① do{               ④               ③ }while(②);

 

【题目1】

打印下面图形

******

******

******

for(int i = 0;i < 3;i++){        for(int j = 0;j < 6;j++){               System.out.print("*");        }        System.out.println(); }

说明：外层循环控制行数，内层循环控制列数

【题目2】输出100内的质数。（两种）

法一：

class TestPrimeNumber{        public static void main(String[] args){               boolean flag = false;               long start = System.currentTimeMillis();//获取系统当前的毫秒数               for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历                      //如何判断i是否为一个质数                      for(int j = 2;j <= Math.sqrt(i);j++){                             if(i % j == 0){                                    flag = true;                                    break;                             }                      }                      if(!flag){//if(flag == false){//System.out.println(i);}                      flag = false;               }               long end = System.currentTimeMillis();               System.out.println("所花费的时间为：" + (end - start));               //35535--加上break：10059--使用Math.sqrt():}}

法二：

class TestPrimeNumber1{        public static void main(String[] args){               //boolean flag = false;               long start = System.currentTimeMillis();//获取系统当前的毫秒数               l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历                      //如何判断i是否为一个质数                      for(int j = 2;j <= Math.sqrt(i);j++){                             if(i % j == 0){                                    //flag = true;                                    //break;                                    continue l;}}                      //if(!flag){//if(flag == false){                             System.out.println(i);                      //}                      //flag = false;}               long end = System.currentTimeMillis();               System.out.println("所花费的时间为：" + (end - start));               //35535--加上break：10059--使用Math.sqrt():}}

4.2.4 无限循环结构

for(;;){    ...    if(  ){        break;    }    ... }

或者

while(true){    ...    if(  ){        break;    }    ... }

往往我们在无限循环结构内部提供循环的终止条件，使用break关键字。否则，此循环将无限制的执行下去，形成死循环！死循环是我们要避免的。

4.4 break&continue

4.4.1 break

使用switch-case结构或者循环结构中，一旦执行到break，就跳出当前循环体，默认情况下结束离它最近的一个循环。

 

 

4.4.2 continue

使用在循环结构中，一旦执行到continue，就跳出当次循环。

for(int i = 1;i <= 10;i++){               if(i % 4 == 0){                      //break; //123                      continue;  //123567910               }               System.out.print(i); }

在嵌套循环中，使用带标签的break和continue，可通过标签指明要终止的是哪一层语句块。

 

 

label:for(int i = 1;i < 5;i++){

                          for(int j = 1;j <= 10;j++){

                                 if(j % 4 == 0){

                                    //break;

                                    //continue;

                                    //break label;

                                    continue label;

                                            }

                                  System.out.print(j);

}

                           System.out.println();

}

4.4.3 return

①并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。

②与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

注意：

①break只能用于switch语句和循环语句中。

②continue 只能用于循环语句中。

③二者功能类似，但continue是终止本次循环，break是终止本层循环。

④break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

⑤标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。