1.流程控制

1.1流程控制语句概述

1.2流程控制语句分类

1.3顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

  2. /**
  3.  * 顺序结构
  4.  */
  6. public class constant {
  7.     public static void main(String[] args) {
  8.         System.out.println("开始");
  9.         System.out.println("语句1");
  10.         System.out.println("语句2");
  11.         System.out.println("语句3");
  12.         System.out.println("语句4");
  13.         System.out.println("语句5");
  14.         System.out.println("结束");
  15.     }
  16. }
  17. 结果
  18. 开始
  19. 语句1
  20. 语句2
  21. 语句3
  22. 语句4
  23. 语句5
  24. 结束 
  25. 从上往下依次执行

1.4分支结构（if，switch 语句控制）

1.4.1 if语句格式1

  1. 格式：
  2. if（关系表达式）{语句体}

执行流程：
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句体
3.如果关系表达式的值为false就不执行语句体
4.继续执行后面的语句的内容

  2. /**
  3.  * if 语句格式
  4.  * if（关系表达式）{
  5.  * 语句体
  6.  * }
  7.  * 执行流程
  8.  * 1.首先计算关系表达式中的值
  9.  * 2.如果关系表达式的值为true就执行语句体
  10.  * 3.如果关系表达式的值为false就不执行语句体
  11.  * 4.继续执行后面的语句内容
  12.  */
  14. public class constant {
  15.     public static void main(String[] args) {
  16.         System.out.println("开始");
  17.         // 声明2个int变量
  18.         int a = 2;
  19.         int b = 3;
  20.         // 需求判断a和b的值是否相等，如果相等，就在控制台输出a等于b
  21.         if (a == b) {
  22.             System.out.println("a等于b");
  23.         }
  24.         ;
  25.         System.out.println("结束");
  26.     }
  27. }

1.4.2 if语句格式2

  1. 格式
  2. if（关系表达式）{语句体}else{语句2}

执行流程
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句1
3.如果关系表达式的值为false就执行语句2
4继续执行后面代码。

  1. /**
  2.  * 格式
  3.  * if（关系表达式）{语句体}else{语句2}
  4.  * 执行流程
  5.  * 1.首先计算关系表达式的值
  6.  * 2.如果关系表达式的值为true就执行语句1
  7.  * 3.如果关系表达式的值为false就执行语句2
  8.  * 4继续执行后面代码。
  9.  */
  11. public class constant {
  12.     public static void main(String[] args) {
  13.         System.out.println("开始");
  14.         // 声明2个int变量
  15.         int a = 2;
  16.         int b = 3;
  17.         // 需求判断a和b的值是否相等，如果相等，就在控制台输出a等于b,如果a不等于b，则控制台输出a不等于b
  18.         if (a == b) {
  19.             System.out.println("a等于b");
  20.         } else {
  21.             System.out.println("a不等于b");
  22.         }
  23.         ;
  24.         System.out.println("结束");
  25.     }
  26. }

案例 ：奇偶数
需求：任意给出一个整数，请用程序实现判断整数是奇数还是偶数，并在控制台输出该整数时奇数还是偶数
分析：1为了体现任意给出一个整数，采用键盘录入一个数据
使用键盘录入功能需要导包
import java.util.Scanner
创建对象
Scanner sr=new Scanner（System.in）
接收数据
int number =sr.nextlnt（）;
2,判断整数是偶数还是奇数要分两种情况进行判断，使用if…else 结构。

  1. if(){}else{}

3.判断是否偶数需要使用取余运算符实现功能number%2==0

  1. if（number%2==0）{}else{}

4.根据判断情况，在控制台输出相应的内容

  1. if（mumber%2==0）{
  2. System.out。println（number+“是偶数”）
  3. }else{
  4. System.out。println（number+“是奇数”）
  5. }
  2. /**
  3.  * 格式：
  4.  * 需求：任意给一个整数，请程序实现判断整数是偶数还是奇数，并在控制台输出该整数时奇数还是偶数、
  5.  */
  6. //为了体现任意给出一个整数，采用键盘录入一个数据
  7. //1.使用键盘录入功能需要导包
  8. import java.util.Scanner;
  10. public class constant {
  11.     public static void main(String[] args) {
  12.         // 创建对象
  13.         Scanner myScanner = new Scanner(System.in);
  14.         // 接收数据
  15.         int number = myScanner.nextInt();
  16.         // 2 判断整数是偶数还是奇数 分两种情况进行判断，使用if...else
  17.         if (number % 2 == 0) {
  18.             System.out.println(number + "是偶数");
  19.         } else {
  20.             System.out.println(number + "是奇数");
  21.         }
  23.     }
  24. }

格式：

  1. if（关系表达式1）{语句1}else if（关系表达式2）{语句2}else{语句体}

执行流程：
1.首先计算关系表达式1的值
2.如果值为true就执行语句1，如果值为false就计算关系表达式2的值
3.如果值为true就执行语句体2;如果值为false就计算关系表达式3的值
4.。。。。。
5.如果没有任何关系表达式为true，就执行语句体n+1

  2. /**
  3.  * 格式：
  4.  * if(关系表达式1){语句1}else if(关系表达式2){语句2}else{语句3}
  5.  * 执行了流程：首先计算关系式1的值
  6.  * 2.如果值为true就执行语句体1，如果值为false就计算关系表达式的值
  7.  * 3.如果值为true就执行语句体2，如果值为false就输出语句3
  8.  */
  9. //为了体现任意给出一个整数，采用键盘录入一个数据
  10. //1.使用键盘录入功能需要导包
  11. import java.util.Scanner;
  13. public class constant {
  14.     public static void main(String[] args) {
  15.         // 创建对象
  16.         Scanner sc = new Scanner(System.in);
  18.         // 需求：键盘录入一个星期（1，2，3，4，5，6，7）输出对应的是星期一，二，三，四，星期日
  19.         System.out.println("请输入一个星期数（1-7）");
  20.         // 接收数据
  21.         int week = sc.nextInt();
  22.         if (week == 1) {
  23.             System.out.println("星期一");
  24.         } else if (week == 2) {
  25.             System.out.println("星期二");
  26.         } else if (week == 3) {
  27.             System.out.println("星期三");
  28.         } else if (week == 4) {
  29.             System.out.println("星期四");
  30.         } else if (week == 5) {
  31.             System.out.println("星期五");
  32.         } else if (week == 6) {
  33.             System.out.println("星期六");
  34.         } else if (week == 7) {
  35.             System.out.println("星期日");
  36.         } else {
  37.             System.out.println("输入有误");
  38.         }
  40.     }
  41. }

案例：考试奖励
小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，
请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
90-94 去游乐场
95-100分 购买属于自己的自行车
80-89分 变形金刚
80分以下，揍一顿
1.小明的考试未知，可以采用键盘录入的方式获取值，使用键盘录入功能需要导包，创建对象，接收数据

  1. import java.util.Scanner;
  2. Scanner sc=new Scanner（System.in）;
  3. int score=sc.nextInt（）;

2.由于奖励种类较多，属于多种判断，采用if…else,=…if 格式实现

  1. if（）{}else if（）{}else if（）{}else{}

3.为每种判断设置对应的条件

  1. if（score>=95&&score<=100）{}
  2. else if(score>=90&&score<=94){}
  3. else if(score>=80&&score<=89){}
  4. else if(score<=80){}

4.为每种判断设置对应的奖励

  1. System.out.println（"山地自行车一辆"）
  2. System.out.println（"游乐场玩一次"）
  3. System.out.println（"变形金刚玩具一个"）
  4. System.out.println（"胖揍一顿"）


2.switch语句

  1. 格式：
  2. switch（表达式）{
  3. case值1：
  4.    语句体1：
  5.    break;
  6. case值2：
  7.     语句体2：
  8.     break;
  9.   .....
  10.   default：
  11.        语句体n+1;
  12.      [break]
  13. }
  14. 执行流程：
  15. 1.首先计算表达式的值
  16. 2.依次和case 后面的值进行比较，如果相应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束
  17. 3.如果所有的case后面的值和表达式的值不匹配，就会执行default里面的语句体，然后程序结束掉。
  2. /**
  3.  * 格式：switch(表达式){
  4.  * case值1：
  5.  *    语句1：
  6.  *   break;
  7.  * case值2：
  8.  *   语句体2：
  9.  * break
  10.  * default：
  11.  * 语句体n+1
  12.  * [break]
  13.  * }
  14.  * 格式说明：
  15.  * 表达式的值：取值为byte,short,int,char,Jdk5，以后可以是枚举，JDK7以后可以是String
  16.  * case：后面跟的是要和表达式进行比较的值
  17.  * break：表示中断，结束的意思，用来结束switch语句
  18.  * default：表示所有情况都不匹配，就执行该行代码，和if语句中else 相似
  19.  * 执行顺序：
  20.  * 首先计算表达式的值
  21.  * 依次和case 中的值进行比较，如果有对应的值，就执行相应的语句，在执行的过程中，遇到break就会结束
  22.  * 如果所有的case后面的值和表达式不匹配，就会执行default里面的语句体，然后程序结束掉。
  23.  */
  24. //为了体现任意给出一个整数，采用键盘录入一个数据
  25. //1.使用键盘录入功能需要导包
  26. import java.util.Scanner;
  28. public class constant {
  29.     public static void main(String[] args) {
  30.         // 创建对象
  31.         Scanner scObject = new Scanner(System.in);
  33.         // 需求：键盘录入一个星期（1，2，3，4，5，6，7）输出对应的是星期一，二，三，四，星期日
  34.         System.out.println("请输入一个星期数（1-7）");
  35.         // 接收数据
  36.         int week = scObject.nextInt();
  37.         switch (week) {
  38.             case 1:
  39.                 System.out.println("星期一");
  40.                 break;
  41.             case 2:
  42.                 System.out.println("星期二1");
  43.                 break;
  44.             case 3:
  45.                 System.out.println("星期三");
  46.                 break;
  47.             case 4:
  48.                 System.out.println("星期四");
  49.                 break;
  50.             case 5:
  51.                 System.out.println("星期五");
  52.                 break;
  53.             case 6:
  54.                 System.out.println("星期六");
  55.                 break;
  56.             case 7:
  57.                 System.out.println("星期日");
  58.                 break;
  59.             default:
  60.                 System.out.println("输入的星期数有误");
  61.                 break;
  62.         }
  64.     }
  65. }

案例：春夏秋冬
需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断月份属于那个季节，并输出。
分析：

  1. 键盘录入月份数据，使用变量接收
    1. improt java.util.Scanner
    2. Scanner object1=new Scanner(System.in)
    3. int month=sc.nexInt();
    2.多情况判断，这里采用switch实现
    1. switch（month）{
    2. case x：
    3. case x：
    4. case x：
    5. default：
    6. }
    3.在每种情况中，完成输入对应的季节（选择几个） ```javascript case 3： System.out.println（”春季”）; break; case 6： System.out.println（”夏季”）; break; case 9 ： System.out.println(“秋季”); break case 12： System.out.println(“冬季”) break
  1. ```javascript
  3. /**
  4.  * 案例：春夏秋冬
  5.  * 需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于那个季节，并输出.
  6.  * 春：3，4，5，
  7.  * 夏：6，7，8
  8.  * 秋：9，10，11，
  9.  * 冬：12，1，2
  10.  */
  11. //键盘录入
  12. import java.util.Scanner;
  14. public class constant {
  15.     public static void main(String[] args) {
  16.         // 创建对象
  17.         Scanner scObject = new Scanner(System.in);
  18.         int month = scObject.nextInt();
  19.         // 多情况判断，这里采用switch语句实现
  20.         // 在每种情况中，完成输出对应的季节
  21.         switch (month) {
  22.             case 1:
  23.                 System.out.println("冬季");
  24.                 break;
  25.             case 2:
  26.                 System.out.println("冬季");
  27.                 break;
  28.             case 3:
  29.                 System.out.println("春季");
  30.                 break;
  31.             case 4:
  32.                 System.out.println("春季");
  33.                 break;
  34.             case 5:
  35.                 System.out.println("春季");
  36.                 break;
  37.             case 6:
  38.                 System.out.println("夏季");
  39.                 break;
  40.             case 7:
  41.                 System.out.println("夏季");
  42.                 break;
  43.             case 8:
  44.                 System.out.println("夏季");
  45.                 break;
  46.             case 9:
  47.                 System.out.println("秋季");
  48.                 break;
  49.             case 10:
  50.                 System.out.println("秋季");
  51.                 break;
  52.             case 11:
  53.                 System.out.println("秋季");
  54.                 break;
  55.             case 12:
  56.                 System.out.println("冬季");
  57.                 break;
  58.             default:
  59.                 System.out.println("输入月份有误");
  60.                 break;
  61.         }
  62.         /**
  63.          * case 穿透
  64.          */
  65.         switch (month) {
  66.             case 1:
  67.             case 2:
  68.             case 3:
  69.             case 4:
  70.                 System.out.println("冬季");
  71.                 break;
  73.             case 5:
  74.             case 6:
  75.             case 7:
  76.             case 8:
  77.                 System.out.println("春季");
  78.                 break;
  80.             case 9:
  81.             case 10:
  82.             case 11:
  83.             case 12:
  84.                 System.out.println("秋季");
  85.                 break;
  86.             default:
  87.                 System.out.println("输入月份有误");
  88.                 break;
  89.         }
  90.     }
  91. }

3循环结构（for,while，do….while 语句控制）

1.1循环结构

循环结构：
初始化语句：用于表示循环开启的起始状态，简单说就是循环开始的时候什么样，
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否执行下去。
循环结构对应的语法：
初始化语句：这里可以是一条或者多条语句，这里语句可以完成一些初始化操作。
条件判断句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体例如a<3
循环体语句：这里可以是任意语句，这些语句将反复执行
条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果，常见的i++，i—，这样的操作。

1.2 for 循环语句格式

  1. 格式：
  2.  for （初始化语句;条件判断语句;条件控制语句）{
  3.  循环体语句
  4.  }

执行流程：
1.执行初始化语句

  1. 执行条件判断语句，看结果是true还是false

    如果是false， 循环结束
    如果是true ，循环继续执行
    3.执行循环体语句
    4.执行条件控制语句
    5 回到2继续执行。 ```javascript /**

    • 格式：for(初始化语句;条件判断语句;条件控制语句){
    • 循环体
    • }
    • 执行流程：
    • 1，执行初始化语句
    • 2.执行条件判断句，看结果为true，还是false
    • 如果是false ，循环结束
    • 如果是true， 循环继续
    • 3.执行循环体语句
    • 4.执行条件控制语句
    • 5，回到2继续 */

public class constant { public static void main(String[] args) { for (int i = 0; i <= 10; i += 2) { System.out.println(“第” + i + “次”); } }

}

  1. 案例:输出数据<br />需求：在控制台输出1-5和5-1数据
  2. ```javascript
  3. 分析：
  4. 1.反复进行输出动作，使用循环结构
  5. for（初始化语句;条件判断语句;条件控制语句）{}
  6. 2.从1开始到5结束，设置初始化开始
  7. for（int i=1;条件判断语句;条件控制语句）{}
  8. 3.从1开始到5结束，设置判断条件为没有到5的时候继续执行，执行超过5程序结束
  9. for（int i=1;i<=5;条件控制语句）{}
  10. 4.从1到5，每次增加1，设置条件控制每条+1
  11. for（int i=1;i<=5;i++）{}
  1. /**
  2.  * 案例：输出数据
  3.  * 需求：在控制台输出1-5和5-1数据
  4.  */
  6. public class constant {
  7.     public static void main(String[] args) {
  8.         for (int i = 1; i <= 5; i++) {
  9.             System.out.println(i);
  10.         }
  11.         for (int j = 5; 1 <= j && j <= 5; j--) {
  12.             System.out.println(j);
  13.         }
  14.     }
  16. }

案例：求和
需求：求1-5之间的数据和，并把求和结果在控制台输出
分析：
1.求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
int sum =0;
2.从1开始到5结束的数据，使用循环结构完成
for（int i=1;i<=5;i++）{}
3.将反复进行的事情写入循环结构内部，此外反复进行的事情是将数据i加到用于保存最终求和的变量sum中
for（int i=1;i<=5;i++）{sum+=i}
4.当循环执行完毕时，最终数据打印出来。

  1. /**
  2.  * 案例：求和
  3.  * 需求：求1-5之间的数据和，并把求和结果在控制台输出
  4.  */
  6. public class constant {
  7.     public static void main(String[] args) {
  8.         int sum = 0;
  9.         for (int i = 1; i <= 5; i++) {
  10.             sum = sum + i;
  12.         }
  13.         System.out.println(sum);
  14.     }
  16. }

案例：求偶数和
需求：求1-100之间的偶数和，并把求和结果在控制台输出
分析：1.对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅时结束条件不一样

  1. int sum=0;
  2. for（int i=1;i<=100;i++）{
  3. }

3.限制条件是偶数才参与运算条件，因此条件应该判断是否为偶数

  1. int sum=0;
  2. for（int i=1;i<=100;i++）{
  3.   if（i%2==0）{
  4.   sum+=i
  5.   }
  6. }
  1. /**
  2.  * 案例：求偶数和
  3.  * 需求：求1-100之间的偶数和，并把求和结果在控制台输出
  4.  */
  6. public class constant {
  7.     public static void main(String[] args) {
  8.         int sum = 0;
  9.         for (int i = 1; i <= 100; i++) {
  10.             if (i % 2 == 0) {
  11.                 sum += i;
  12.             }
  13.         }
  14.         System.out.println(sum);
  15.     }
  17. }

while 循环语句

基本格式：

  1. while（条件判断句）{
  2. 循环体语句;
  3. 条件控制语句;
  4. }

执行流程：
1.执行语句
2.执行条件判断语句，看其结果是true还是false
如果是false 循环结束
如果是true 继续执行
3，执行循环体语句
4.执行条件控制语句
5，回到2继续

  1. /**
  2.  * 格式: while（布尔表达式）{
  3.  * //循环内容
  4.  * }
  5.  * 需求：
  6.  */
  8. public class constant {
  9.     public static void main(String[] args) {
  10.         // 需求：在控制台输出5次""Hello World"
  11.         int a = 0;
  12.         while (a <= 5) {
  13.             System.out.print("Hello World");
  14.             a += 1;
  15.         }
  16.         for (int i = 0; i <= 5; i++) {
  17.             System.out.print("Hello World");
  18.         }
  20.     }
  22. }

案例：珠穆朗玛峰
需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。
请问：我折叠多少次，可以折成珠穆朗玛峰高度。
折叠一次厚度为原来的一倍
案例分析：
1.因为要反复折叠，所以要使用循环，但不知道折叠多少次，这种情况下更适合while循环

  1. while（条件判断句）{循环体}

2.循环的执行过程中每次纸张折叠，纸张的厚度要加倍，因此需要先定义纸张的厚度，在循环中使厚度加倍。

  1. double  paper=0.1 //初始厚度
  2. while（条件判断句）{
  3. paper*=2
  4. }
  1. 折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
    1. int zf=8844430;//珠穆朗玛峰高度
    2. while（paper<=zf）{.....}
    4.设置一个计数器，在循环中执行累加，对应叠加多少次。
    1. int count=0;
    2. while （paper<=zf）{
    3. count++
    4. }
    代码： ```javascript /**
    • 案例：珠穆朗玛峰
    • 需求：世界最高山峰是珠穆朗玛峰（8844.43豪米）,假如我有一张足够大的纸，它的厚度是0.1毫米。
    • 请问：我折叠多少次，可以折成珠穆朗玛峰的高度
    • 折叠一次厚度为原来的一倍 */

public class constant { public static void main(String[] args) { // 纸张厚度 double hd = 0.1; // 珠峰高度 int zf = 8844430; // 定义计时器 int count = 0; // 因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更合适使用while循环 // 折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度 while (hd <= zf) { hd *= 2; count++;

  1.     }
  2.     System.out.println(count + "次");
  3. }

}

  1. <a name="dUcn2"></a>
  2. ## do...while循环语句
  3. 基本格式： 
  4. ```javascript
  5. do {
  6. 循环体语句;
  8. }while（条件判断语句）

完整格式：

  1. 初始化语句
  2. do{
  3. 循环体语句;
  4.   条件控制语句;
  5. }while（条件判断语句）

执行流程：
1.执行初始化语句
2.执行循环体语句
3.执行条件控制语句
4.执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
5.回到2继续

  1. public class Test {
  2.    public static void main(String[] args){
  3.       int x = 10;
  5.       do{
  6.          System.out.print("value of x : " + x );
  7.          x++;
  8.          System.out.print("\n");
  9.       }while( x < 20 );
  10.    }
  11. }

三种循环的区别

三种循环的区别：
for 循环和while 循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
do….while 循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for 和while 的区别：
条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量，对于while 循环来说不属于其语法结构中，在while循环结束后，该变量还可以继续使用。

跳转控制语句控制

continue 用在循环中，基于条件控制，跳出某次循环体内容的执行，继续下一次的执行
break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的循环体