Java 的流程控制是什么样子的

本文转载自微信公众号「蜗牛互联网」，作者蜗牛互联网。转载本文请联系蜗牛互联网公众号。

从策划到设计制作，每一步都追求做到细腻，制作可持续发展的企业网站。为客户提供做网站、网站设计、网站策划、网页设计、申请域名、网络空间、网络营销、VI设计、 网站改版、漏洞修补等服务。为客户提供更好的一站式互联网解决方案,以客户的口碑塑造优易品牌,携手广大客户,共同发展进步。

本文大纲：

为什么需要流程控制

平时我们做一件事，一般都会有个固定流程。

比如你想吃苹果，你需要找到冰箱，打开冰箱门，取出苹果，回到沙发上，然后开吃。

这个顺序基本不能调换，你不能在打开冰箱门之前去取苹果。按顺序来控制，这是一种流程。

那如果你想吃香蕉，你会发现流程类似，只是从冰箱里取出香蕉就好了。

在这个过程里，你会发现你最终吃什么，取决于你的选择。你要吃苹果，你从冰箱里取苹果，你要吃香蕉，你从冰箱里取香蕉。按选择来控制，这也是一种流程。

那还有种情况，一根香蕉不够你吃，你还想吃几根，直到你不想吃，那你就会重复上面的流程，当你吃饱的时候，就终止了。这种重复执行按照某个条件来终止的控制，也是一种流程。

计算机是现实世界的电子化表达，那么在计算机的世界里，程序运行也需要这样的流程控制。

无论是机器语言，还是汇编语言，还是高级程序设计语言，都会涉及这个概念，它决定了你写的代码会按照怎样的路径运行，也决定着计算机和用户之间的交互方式。

我们看看 Java 语言的流程控制是什么样的?

输入和输出

我们编程都是为了解决某个实际问题，比如写一个加法程序，我们是为了获得两个数的和是多少。

那你会发现，程序有个重要的特点，就是接收输入，然后进行处理，最后输出结果。

那 Java 是怎么接收输入的呢?

Scanner 介绍

Java 提供了 Scanner 工具类，我们可以通过这个工具类来获取用户的输入。基本的语法如下：

 
 
 
 
      
  
  
  
  1. // 用标准的输入流构建一个 Scanner 对象 
    2.   
  
  
  
  2. Scanner scanner = new Scanner(System.in); 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4. // 读取输入的一行并获取字符串 
    5.   
  
  
  
  5. String nextLineStr = scanner.nextLine(); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. // 读取输入的字符串，会忽略掉字符串两边的空格，因为空格起分隔符或结束符的作用 
    8.   
  
  
  
  8. String nextStr = scanner.next(); 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10. // 读取输入的整数，非整数会抛异常(InputMismatchException) 
    11.   
  
  
  
  11. int nextInt = scanner.nextInt(); 
    12.

System.in 是标准的输入流，使用它可以接收键盘输入或其他指定数据源的数据。

Scanner 是一个简单的文本扫描器，通过它可以解析基本类型和字符串。new Scanner(System.in) 可以构建出一个扫描器对象，scanner.nextLine()可以读取输入的一行并获取字符串，scanner.next() 也可以获取字符串，不过不能支持两边有空格的字符串，scanner.nextInt() 可以读取输入的整数，int 换成其他基本类型同样也适用。

Scanner 使用

我们可以看下样例代码：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Scanner; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * 输入演示 
    7.   
  
  
  
  7.  * 
    8.   
  
  
  
  8.  * @author 蜗牛 
    9.   
  
  
  
  9.  * @from 公众号：蜗牛互联网 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. public class InputDemo { 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.     public static void main(String[] args) { 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.         // 用标准的输入流构建一个 Scanner 对象 
    16.   
  
  
  
  16.         Scanner scanner = new Scanner(System.in); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.         // 读取输入的一行并获取字符串 
    19.   
  
  
  
  19.         String nextLineStr = scanner.nextLine(); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.         // 读取输入的字符串，会忽略掉字符串两边的空格，因为空格起分隔符或结束符的作用 
    22.   
  
  
  
  22.         String nextStr = scanner.next(); 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         // 读取输入的整数，非整数会抛异常(InputMismatchException) 
    25.   
  
  
  
  25.         int nextInt = scanner.nextInt(); 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.         System.out.println("---以下为打印值---"); 
    28.   
  
  
  
  28.         System.out.println("nextLineStr:" + nextLineStr); 
    29.   
  
  
  
  29.         System.out.println("nextStr:" + nextStr); 
    30.   
  
  
  
  30.         System.out.println("nextInt:" + nextInt); 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32.     } 
    33.   
  
  
  
  33. } 
    34.

你会发现，样例代码里有一个 import java.util.Scanner; ，Scanner 是 Java 类库里的一个类，所以需要 import 语法引入一下，才能使用。

样例代码有三次控制台输入，我们输入以下数据看下输出：

 
 
 
 
      
  
  
  
  1. 我是蜗牛    
    2.   
  
  
  
  2.    蜗牛666     
    3.   
  
  
  
  3. 8 
    4.

第一行输入的字符串后边有空格，第二行输入的字符串前后都有空格。输出如下：

---以下为打印值---

 
 
 
 
      
  
  
  
  1. ---以下为打印值--- 
    2.   
  
  
  
  2. nextLineStr:我是蜗牛    
    3.   
  
  
  
  3. nextStr:蜗牛666 
    4.   
  
  
  
  4. nextInt:8 
    5.

你会发现 nextLineStr 后边的空格还在，nextStr 前后的空格都没有了。

我们再看一种输入：

 
 
 
 
      
  
  
  
  1. 我是蜗牛    
    2.   
  
  
  
  2.    蜗牛666  7 
    3.

当我们输入两行后，再回车，程序就直接输出结果了：

 
 
 
 
      
  
  
  
  1. nextLineStr:我是蜗牛    
    2.   
  
  
  
  2. nextStr:蜗牛666 
    3.   
  
  
  
  3. nextInt:7 
    4.

由此可见 nextLine()和 next() 之间的不同，nextInt() 是 next() 基础上的类型转换，特点可以认为和 next() 一致。

 
 
 
 
      
  
  
  
  1. 起始符 分隔符 特点 
    2.   
  
  
  
  2. nextLine()  任何字符    回车(Enter)   可以获得带空格的字符串 
    3.   
  
  
  
  3. next()  非空白字符   空格  不能获得带空格的字符串 
    4.

输出

在之前的代码中，我们都是通过 System.out.println() 的方式，把内容输出到控制台的。

其中 System.out 是标准的输出流，通过它不只可以做显示输出，也可以写入到指定的输出目标，比如文件。

println 是 print line 的缩写，表示输出并换行。如果输出不想换行，可以使用 print() 。此外，Java 也支持用 printf() 进行格式化输出，以方便阅读。

以下是示例代码：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. /** 
    4.   
  
  
  
  4.  * 输出演示 
    5.   
  
  
  
  5.  * @author 蜗牛 
    6.   
  
  
  
  6.  * @from 公众号：蜗牛互联网 
    7.   
  
  
  
  7.  */ 
    8.   
  
  
  
  8. public class OutputDemo { 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     public static void main(String[] args) { 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.         // 输出并换行 
    13.   
  
  
  
  13.         System.out.println("---开始演示---"); 
    14.   
  
  
  
  14.         // 输出不换行 
    15.   
  
  
  
  15.         System.out.print("打印不换行["); 
    16.   
  
  
  
  16.         System.out.print("1 "); 
    17.   
  
  
  
  17.         System.out.print("2 "); 
    18.   
  
  
  
  18.         System.out.print("3"); 
    19.   
  
  
  
  19.         System.out.print("]"); 
    20.   
  
  
  
  20.         // 只换行 
    21.   
  
  
  
  21.         System.out.println(); 
    22.   
  
  
  
  22.         // 格式化输出 
    23.   
  
  
  
  23.         double d = 66600000.8888; 
    24.   
  
  
  
  24.         // 不进行格式化的处理结果：6.66000008888E7 
    25.   
  
  
  
  25.         System.out.println("不进行格式化的处理结果：" + d); 
    26.   
  
  
  
  26.         System.out.printf("默认格式化：%f", d); 
    27.   
  
  
  
  27.         System.out.printf("; 无小数格式化：%.0f", d); 
    28.   
  
  
  
  28.         System.out.printf("; 一位小数格式化：%.1f", d); 
    29.   
  
  
  
  29.         System.out.printf("; 两位小数格式化：%.2f", d); 
    30.   
  
  
  
  30.     } 
    31.   
  
  
  
  31. } 
    32.

输出结果如下：

 
 
 
 
      
  
  
  
  1. ---开始演示--- 
    2.   
  
  
  
  2. 打印不换行[1 2 3] 
    3.   
  
  
  
  3. 不进行格式化的处理结果：6.66000008888E7 
    4.   
  
  
  
  4. 默认格式化：66600000.888800; 无小数格式化：66600001; 一位小数格式化：66600000.9; 两位小数格式化：66600000.89 
    5.

%f 就是 Java 为浮点数提供的格式化功能的占位符，系统默认会把浮点数格式化成 6 位小数输出，当然你也可以仿照样例指定小数位输出。

除了浮点数，Java 的格式化功能还提供了多种占位符，可以把各种数据类型格式化成指定的字符串，以下是常用的占位符：

占位符说明
%d格式化输出整数
%x格式化输出十六进制整数
%f格式化输出浮点数
%e格式化输出科学计数法表示的浮点数
%s格式化字符串

注意，由于 % 表示占位符，因此，连续两个 %% 表示一个 % 字符本身。

三种流程控制结构

知道了输入和输出在 Java 世界里的表达方式，我们再看下在程序处理中涉及到的流程控制有哪些。

顺序结构

程序基本的流程结构就是顺序结构，Java 也是如此。如果没有特别指明，程序都是按照顺序一行一行执行。

选择结构

但很多时候，我们需要判断一个东西是否可行，然后才去执行一段逻辑。比如加法程序，我们得要求参与运算的值是数字而不能是字符串。

那这样的流程控制可以通过选择结构来实现。

if单选择结构

如果只是想针对某个条件特殊处理下，处理前后的逻辑不变，此时可以使用if单选择结构。

语法如下：

 
 
 
 
      
  
  
  
  1. if(布尔表达式){ 
    2.   
  
  
  
  2.  //布尔表达式结果为 true 时执行的语句 
    3.   
  
  
  
  3. } 
    4.

以下是打印两个整数的最大值的示例代码：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Scanner; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * if 单选择结构 
    7.   
  
  
  
  7.  * 
    8.   
  
  
  
  8.  * @author 蜗牛 
    9.   
  
  
  
  9.  * @from 公众号：蜗牛互联网 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. public class IfSingleChoiceDemo { 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.     public static void main(String[] args) { 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.         // 用标准的输入流构建一个 Scanner 对象 
    16.   
  
  
  
  16.         Scanner scanner = new Scanner(System.in); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.         System.out.println("请输入整数a:"); 
    19.   
  
  
  
  19.         int a = scanner.nextInt(); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.         System.out.println("请输入整数b:"); 
    22.   
  
  
  
  22.         int b = scanner.nextInt(); 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         // 初始化最大值为 a 的值 
    25.   
  
  
  
  25.         int max = a; 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.         // b 比 a 大的请求下，把 b 的值赋给 max 
    28.   
  
  
  
  28.         if (a < b) { 
    29.   
  
  
  
  29.             max = b; 
    30.   
  
  
  
  30.         } 
    31.   
  
  
  
  31.         System.out.println("max:" + max); 
    32.   
  
  
  
  32.     } 
    33.   
  
  
  
  33. } 
    34.

我们用数字 a 初始化了变量 max，只有发现 b 比 a 大的时候，才会把 b 的值赋给 max。也就是 当 a=10 并且 b=9 时，if 花括号里的逻辑是走不到的，当 a=10 并且 b=11 时，if 花括号里的逻辑会走到。

if双选择结构

有时候我们遇到某个条件，会有两种不同的逻辑，此时可以使用if双选择结构。

语法如下：

 
 
 
 
      
  
  
  
  1. if(布尔表达式){ 
    2.   
  
  
  
  2.  //布尔表达式结果为 true 时执行的语句 
    3.   
  
  
  
  3. }else{ 
    4.   
  
  
  
  4.  //布尔表达式结果为 false 时执行的语句 
    5.   
  
  
  
  5. } 
    6.

以下是打印整数绝对值的示例代码：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Scanner; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * if双选择结构 
    7.   
  
  
  
  7.  * 
    8.   
  
  
  
  8.  * @author 蜗牛 
    9.   
  
  
  
  9.  * @from 公众号：蜗牛互联网 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. public class IfDoubleChoiceDemo { 
    12.   
  
  
  
  12.     public static void main(String[] args) { 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         // 用标准的输入流构建一个 Scanner 对象 
    15.   
  
  
  
  15.         Scanner scanner = new Scanner(System.in); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.         System.out.println("请输入整数a:"); 
    18.   
  
  
  
  18.         //10,-10 切换 
    19.   
  
  
  
  19.         int a = scanner.nextInt(); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.         // 初始化绝对值变量 
    22.   
  
  
  
  22.         int abs; 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         if (a < 0) { 
    25.   
  
  
  
  25.             abs = -a; 
    26.   
  
  
  
  26.         } else { 
    27.   
  
  
  
  27.             abs = a; 
    28.   
  
  
  
  28.         } 
    29.   
  
  
  
  29.         System.out.println("abs:" + abs); 
    30.   
  
  
  
  30.     } 
    31.   
  
  
  
  31. } 
    32.

我们用 abs 初始化了绝对值变量，针对待判定的整数 a，当它的值是 10 或者 -10 时，会走 if 的不同分支执行不一样的逻辑。

if多选择结构

当我们遇到的条件不只一个的时候，我们执行逻辑的情况可能会超过两个，此时可以使用if多选择结构。

语法如下：

 
 
 
 
      
  
  
  
  1. if(布尔表达式1){ 
    2.   
  
  
  
  2.  //布尔表达式1结果为 true 时执行的语句 
    3.   
  
  
  
  3. }else if(布尔表达式2){ 
    4.   
  
  
  
  4.  //布尔表达式2结果为 true 时执行的语句 
    5.   
  
  
  
  5. }     
    6.   
  
  
  
  6. else{ 
    7.   
  
  
  
  7.  //布尔表达式结果为 false 时执行的语句 
    8.   
  
  
  
  8. } 
    9.

以下是百分制成绩评优良差的示例代码：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Scanner; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * if 多选择结构 
    7.   
  
  
  
  7.  * 
    8.   
  
  
  
  8.  * @author 蜗牛 
    9.   
  
  
  
  9.  * @from 公众号：蜗牛互联网 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. public class IfMultiChoiceDemo { 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.     public static void main(String[] args) { 
    14.   
  
  
  
  14.         // 用标准的输入流构建一个 Scanner 对象 
    15.   
  
  
  
  15.         Scanner scanner = new Scanner(System.in); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.         System.out.println("请输入你的成绩（百分制）:"); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.         //58,68,88,96,120 切换 
    20.   
  
  
  
  20.         int score = scanner.nextInt(); 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.         if (score > 0 && score < 60) { 
    23.   
  
  
  
  23.             System.out.println("不合格"); 
    24.   
  
  
  
  24.         } else if (score >= 60 && score < 80) { 
    25.   
  
  
  
  25.             System.out.println("合格"); 
    26.   
  
  
  
  26.         } else if (score >= 80 && score < 90) { 
    27.   
  
  
  
  27.             System.out.println("良好"); 
    28.   
  
  
  
  28.         } else if (score >= 90 && score <= 100) { 
    29.   
  
  
  
  29.             System.out.println("优秀"); 
    30.   
  
  
  
  30.         } else { 
    31.   
  
  
  
  31.             System.out.println("非法输入"); 
    32.   
  
  
  
  32.         } 
    33.   
  
  
  
  33.     } 
    34.   
  
  
  
  34. } 
    35.

成绩分数评优良差的程序存在区间多级判断，比较适合if多选择结构。

if嵌套选择结构

当我们遇到的条件里，又能拆出多个条件，有不同的执行逻辑时，可以使用if嵌套选择结构。if嵌套选择结构可以认为是if多选择结构的变种。

语法如下：

 
 
 
 
      
  
  
  
  1. if(布尔表达式1){ 
    2.   
  
  
  
  2.  //布尔表达式1结果为 true 时执行的语句 
    3.   
  
  
  
  3.      
    4.   
  
  
  
  4.     if(布尔表达式2){ 
    5.   
  
  
  
  5.         //布尔表达式2结果为 true 时执行的语句 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. } 
    8.

以下是百分制成绩评优良差变形后的示例代码：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Scanner; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * if嵌套选择结构 
    7.   
  
  
  
  7.  * 
    8.   
  
  
  
  8.  * @author 蜗牛 
    9.   
  
  
  
  9.  * @from 公众号：蜗牛互联网 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. public class IfNestChoiceDemo { 
    12.   
  
  
  
  12.     public static void main(String[] args) { 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         // 用标准的输入流构建一个 Scanner 对象 
    15.   
  
  
  
  15.         Scanner scanner = new Scanner(System.in); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.         System.out.println("请输入你的成绩（百分制）:"); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.         //58,68,88,96,120 切换 
    20.   
  
  
  
  20.         int score = scanner.nextInt(); 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.         if (score >= 0 && score <= 100) { 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.             if (score < 60) { 
    25.   
  
  
  
  25.                 System.out.println("不合格"); 
    26.   
  
  
  
  26.             } else if (score < 80) { 
    27.   
  
  
  
  27.                 System.out.println("合格"); 
    28.   
  
  
  
  28.             } else if (score < 90) { 
    29.   
  
  
  
  29.                 System.out.println("良好"); 
    30.   
  
  
  
  30.             } else { 
    31.   
  
  
  
  31.                 System.out.println("优秀"); 
    32.   
  
  
  
  32.             } 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.         } else { 
    35.   
  
  
  
  35.             System.out.println("非法输入"); 
    36.   
  
  
  
  36.         } 
    37.   
  
  
  
  37.     } 
    38.   
  
  
  
  38. } 
    39.

和普通的 if多选择结构 的代码不同在于，if嵌套选择做了两层选择，第一层是输入的合法性，第二层是对成绩做分级。

switch选择结构

我们有时候遇到的条件比较有限，并且就是判断一个变量与一系列中某个值是否相等，然后命中不同的值，会走向不同的逻辑。此时就可以使用switch选择结构。

语法如下：

 
 
 
 
      
  
  
  
  1. switch(var){ 
    2.   
  
  
  
  2.     case value1: 
    3.   
  
  
  
  3.         // var 命中 value1 时执行的语句 
    4.   
  
  
  
  4.         break; 
    5.   
  
  
  
  5.     case value2: 
    6.   
  
  
  
  6.         // var 命中 value2 时执行的语句 
    7.   
  
  
  
  7.         break; 
    8.   
  
  
  
  8.     //可以有任意数量的case语句 
    9.   
  
  
  
  9.     // 默认的请求，上边都没命中，会走到该分支 
    10.   
  
  
  
  10.     default: 
    11.   
  
  
  
  11.         //以上 case 都未命中或者未 break 会走到这里 
    12.   
  
  
  
  12. } 
    13.

我们如果把上边提到的几个程序打包给用户使用，那就可以通过 switch 来提供统一的入口，引导用户键入1来路由到求最大值的程序里，键入2路由到求绝对值的程序里，键入3路由到成绩分数评优良差的程序里。示例代码如下：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Scanner; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * switch选择结构 
    7.   
  
  
  
  7.  * 
    8.   
  
  
  
  8.  * @author 蜗牛 
    9.   
  
  
  
  9.  * @from 公众号：蜗牛互联网 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. public class IfSwitchChoiceDemo { 
    12.   
  
  
  
  12.     public static void main(String[] args) { 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         // 用标准的输入流构建一个 Scanner 对象 
    15.   
  
  
  
  15.         Scanner scanner = new Scanner(System.in); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.         System.out.println("请选择你要运行的程序(键入1表示求最大值，键入2表示求绝对值，键入3表示成绩分数评优良差):"); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.         int choice = scanner.nextInt(); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.         switch (choice) { 
    22.   
  
  
  
  22.             case 1: 
    23.   
  
  
  
  23.                 System.out.println("--开始求两个数的最大值--"); 
    24.   
  
  
  
  24.                 IfSingleChoiceDemo.main(null); 
    25.   
  
  
  
  25.                 break; 
    26.   
  
  
  
  26.             case 2: 
    27.   
  
  
  
  27.                 System.out.println("--开始求绝对值--"); 
    28.   
  
  
  
  28.                 IfDoubleChoiceDemo.main(null); 
    29.   
  
  
  
  29.                 break; 
    30.   
  
  
  
  30.             case 3: 
    31.   
  
  
  
  31.                 System.out.println("--开始成绩分数评优良差--"); 
    32.   
  
  
  
  32.                 IfMultiChoiceDemo.main(null); 
    33.   
  
  
  
  33.                 break; 
    34.   
  
  
  
  34.             default: 
    35.   
  
  
  
  35.                 System.out.println("非法输入"); 
    36.   
  
  
  
  36.         } 
    37.   
  
  
  
  37.     } 
    38.   
  
  
  
  38. } 
    39.

跑一下这个程序，键入 1 你会发现开始执行求最大值的子程序里，最大值打印后整个程序就结束了，这说明 break 起到了当前分支阻断程序的作用。一旦命中 break 代码，后边的 case 2、case 3、default 都不会走到。

当然不是每个 case 都需要有 break 的，当你有两个 case 的逻辑一致，就可以忽略 break 进行 case 合并，比如当键入 4 的时候，我要求和 3 效果一致，可以改成下面这样：

 
 
 
 
      
  
  
  
  1. case 3: 
    2.   
  
  
  
  2. case 4: 
    3.   
  
  
  
  3.     System.out.println("--开始成绩分数评优良差--"); 
    4.   
  
  
  
  4.     IfMultiChoiceDemo.main(null); 
    5.   
  
  
  
  5.     break; 
    6.

没有 break 的 case 逻辑会穿透到下一个 case，使用下一个 case 的代码逻辑。

注意，switch选择结构是if多选择结构特殊场景下的变种，JavaSE 8 支持的变量类型有 byte、short、int、char、String、ENUM。

循环结构

程序有时候会重复运行一段逻辑，如果按顺序结构+选择结构来组织代码的话，这种情况下需要写很多重复的代码才能实现。比如我要得到从 1 到 5 的和：

 
 
 
 
      
  
  
  
  1. 1+2+3+4+5=? 
    2.

我的代码可能就是这样：

 
 
 
 
      
  
  
  
  1. package cn.java4u.flowcontrol; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. /** 
    4.   
  
  
  
  4.  * while 循环结构演示 
    5.   
  
  
  
  5.  * 
    6.   
  
  
  
  6.  * @author 蜗牛 
    7.   
  
  
  
  7.  * @from 公众号：蜗牛互联网 
    8.   
  
  
  
  8.  */ 
    9.   
  
  
  
  9. public class WhileCircleDemo { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11.     public static void main(String[] args) { 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         int a = 1; 
    14.   
  
  
  
  14.         int sum = 0; 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.         System.out.println("当前a的值为:" + a); 
    17.   
  
  
  
  17.         // a 累加到 sum 中 
    18.   
  
  
  
  18.         sum = sum + a; 
    19.   
  
  
  
  19.         // a 自身加一 
    20.   
  
  
  
  20.         a = a + 1; 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.         System.out.println("当前a的值为:" + a); 
    23.   
  
  
  
  23.         sum = sum + a; 
    24.   
  
  
  
  24.         a = a + 1; 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26.         System.out.println("当前a的值为:" + a); 
    27.   
  
  
  
  27.         sum = sum + a; 
    28.   
  
  
  
  28.         a = a + 1; 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30.         System.out.println("当前a的值为:" + a); 
    31.   
  
  
  
  31.         sum = sum + a; 
    32.   
  
  
  
  32.         a = a + 1; 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.         System.out.println("当前a的值为:" + a); 
    35.   
  
  
  
  35.         sum = sum + a; 
    36.   
  
  
  
  36.          
    37.   
  
  
  
  37.         System.out.println("sum:" + sum); 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39.     } 
    40.   
  
  
  
  40. } 
    41.

你会发现重复逻辑很多，在 a = 5 的时候，累加才结束，结果才输出。那如果有种机制能把这些重复的逻辑用简洁的方式表达，那写代码就会方便很多。

这种机制就是循环结构。

while循环结构

最常用的循环结构是 while 循环，语法如下：

 
 
 
 
      
  
  
  
  1. while(布尔表达式){ 
    2.   
  
  
  
  2.  //循环内容 
    3.   
  
  
  
  3. } 
    4.
  • 只要布尔表达式为 true，循环就会一直执行下去。
  • 我们大多数情况是会让循环停止下来的，因此需要一个让布尔表达式为 false 的方式来停止循环。
  • 少部分情况时需要循环一直执行，比如服务器的请求响应监听等。
  • 循环条件如果一直是 true，就会造成无限循环，应尽量避免这种情况，否则会造成程序卡死崩溃。

用 while 来表达求和代码如下：

 
 
 
 
      
  
  
  
  1. // 初始化值 
    2.   
  
  
  
  2. a = 1; 
    3.   
  
  
  
  3. sum = 0; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. while (a <= 5) { 
    6.   
  
  
  
  6.     // a 累加到 sum 中 
    7.   
  
  
  
  7.     sum += a; 
    8.   
  
  
  
  8.     // a 自身加一 
    9.   
  
  
  
  9.     a++; 
    10.   
  
  
  
  10. } 
    11.   
  
  
  
  11. System.out.println("while sum:" + sum); 
    12.

do while循环结构

观察 while 语句，你会发现，只要不满足条件，就不能进入循环。但有时候我们需要即使不满足条件，也至少要执行一次。那此时用 do while 循环就比较合适，语法如下：

 
 
 
 
      
  
  
  
  1. do{ 
    2.   
  
  
  
  2.  //循环内容 
    3.   
  
  
  
  3. }where(布尔表达式) 
    4.
  • 不同于 while 循环结构的先判断后执行的方式，do while 循环结构是先执行后判断。
  • do while 中的循环内容会被至少执行一次。

用 do while 来表达求和代码如下：

 
 
 
 
      
  
  
  
  1. // 初始化值 
    2.   
  
  
  
  2. a = 1; 
    3.   
  
  
  
  3. sum = 0; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. do { 
    6.   
  
  
  
  6.     // a 累加到 sum 中 
    7.   
  
  
  
  7.     sum += a; 
    8.   
  
  
  
  8.     // a 自身加一 
    9.   
  
  
  
  9.     a++; 
    10.   
  
  
  
  10. } while (a <= 5); 
    11.   
  
  
  
  11. System.out.println("do while sum:" + sum); 
    12.

for循环结构

在求和代码中，我们会发现，a 就像一个计数器，通过 a = 1 初始化一个值，然后在每次循环中加一来当成我们求和时要加的那个数，a <= 5 作为计数器循环检测条件，决定了我们的累加是加到 5 还是 100，只要改成 a <= 100，累加到 100 就不会再执行循环。

这种其实是迭代处理的通用结构：初始值、终止条件和计数器。于是 Java 提供了 for 循环结构，用来简化这种场景下的 while 循环，语法如下：

 
 
 
 
      
  
  
  
  1. for(计数器初始化; 布尔表达式; 循环后更新计数器){ 
    2.   
  
  
  
  2.  //循环内容 
    3.   
  
  
  
  3. } 
    4.

用 for 来表达求和代码如下：

 
 
 
 
      
  
  
  
  1. sum = 0; 
    2.   
  
  
  
  2. for (a = 1; a <= 5; a++) { 
    3.   
  
  
  
  3.     sum += a; 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5. System.out.println("for sum:" + sum); 
    6.

for each循环结构

有些时候，我们拿到一堆数处理，其实并不关心他们的次序，只要能遍历到就可以。比如数组里的几个值，我不关心值的索引，我只想知道这些值的总和是多少。此时就可以用 for each 循环结构，它可以很简单的遍历数组，语法如下：

 
 
 
 
      
  
  
  
  1. for(元素类型 元素变量 : 数组或迭代器){ 
    2.   
  
  
  
  2.  //循环内容 
    3.   
  
  
  
  3. } 
    4.
  • for each 是对 for 特殊场景下的简化，处理对象是数组或者迭代器对象。
  • 和 for 循环结构相比，for each 循环结构不再体现计数器的初始化和更新，因此也无法指定遍历顺序，也不能获取数组或迭代器索引。

用 for each 来表达求和代码如下：

 
 
 
 
      
  
  
  
  1. int[] array = {1, 2, 3, 4, 5}; 
    2.   
  
  
  
  2. sum = 0; 
    3.   
  
  
  
  3. for (int temp : array) { 
    4.   
  
  
  
  4.     sum += temp; 
    5.   
  
  
  
  5. } 
    6.   
  
  
  
  6. System.out.println("for each sum:" + sum); 
    7.

循环结构的中断

循环结构都会有个布尔表达式作为循环检测条件，如果布尔表达式为 false 时，就会终止循环，这是循环中断的一种方式。

除此之外，Java 还提供了另外两种循环结构中断的方式。

一种是 break。语法如下：

 
 
 
 
      
  
  
  
  1. 循环结构{ 
    2.   
  
  
  
  2.     //中断前代码 
    3.   
  
  
  
  3.     if(中断布尔表达式){ 
    4.   
  
  
  
  4.   break; 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6.     //中断后代码 
    7.   
  
  
  
  7. } 
    8.
  • 中断布尔表达式返回 true 时，命中 break ，直接退出整个循环结构，中断后代码不再执行。

求和示例代码如下：

 
 
 
 
      
  
  
  
  1. int a = 1; 
    2.   
  
  
  
  2. int sum = 0; 
    3.   
  
  
  
  3. while (a <= 5) { 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     // a 为 3 的时候中断 
    6.   
  
  
  
  6.     if (a == 3) { 
    7.   
  
  
  
  7.         break; 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     // a 累加到 sum 中 
    11.   
  
  
  
  11.     sum += a; 
    12.   
  
  
  
  12.     // a 自身加一 
    13.   
  
  
  
  13.     a++; 
    14.   
  
  
  
  14. } 
    15.   
  
  
  
  15. System.out.println("while sum:" + sum); 
    16.

实际对 1 和 2 进行求和，因为 a 为 3 的时候退出了循环。

注意：循环结构如果存在嵌套，break 只会退出当前层循环结构，不会退出外层循环结构。

另一种是 continue，语法如下：

 
 
 
 
      
  
  
  
  1. 循环结构{ 
    2.   
  
  
  
  2.     //中断前代码 
    3.   
  
  
  
  3.     if(中断布尔表达式){ 
    4.   
  
  
  
  4.   continue; 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6.     //中断后代码 
    7.   
  
  
  
  7. } 
    8.
  • 中断布尔表达式返回 true 时，命中 continue ，该循环结构当次调用中断，中断后代码当次不再执行，进入循环结构的下次调用。

示例代码如下：

 
 
 
 
      
  
  
  
  1. int i = 0; 
    2.   
  
  
  
  2. while (i <= 5) { 
    3.   
  
  
  
  3.     i++; 
    4.   
  
  
  
  4.     // i 为 3 的时候中断 
    5.   
  
  
  
  5.     if (i == 3) { 
    6.   
  
  
  
  6.         System.out.println("命中 continue"); 
    7.   
  
  
  
  7.         continue; 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.     System.out.println("i=" + i); 
    10.   
  
  
  
  10. } 
    11.

输出：

 
 
 
 
      
  
  
  
  1. i=1 
    2.   
  
  
  
  2. i=2 
    3.   
  
  
  
  3. 命中 continue 
    4.   
  
  
  
  4. i=4 
    5.   
  
  
  
  5. i=5 
    6.   
  
  
  
  6. i=6 
    7.

会发现 i 的值为 3 的时候命中 continue 逻辑，当次循环不会继续往下走，但会进入下一次循环。

简单讲，break 跳出当前层循环，循环结构中止，continue 跳出当次循环调用，当次调用中止。二者都要配合 if 使用。

小结

本文从现实案例引出了流程控制的概念，映射到编程领域，我们把一个程序的执行，抽象成输入-处理-输出的过程。然后介绍了在 Java 的世界里，输入和输出的实现方式，接着讲解了在处理的过程中，常用的三种流程控制结构：顺序结构、选择结构和循环结构，并列出了演示代码。读者可以仿照案例实践一把，相信你会有更深刻的印象。感谢你的阅读和分享，欢迎留言互动和点赞!

分享名称：Java 的流程控制是什么样子的
网页网址：http://www.36103.cn/qtweb/news7/36657.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

面包屑导航知识

同城分类信息

做手机网站　　 　西部信息机房　　 　雅安托管服务器　　 　营销型网站建设　　 　成都定制网站建设　　 　定制网站　　 　双流做网站　　 　四川胜锦安防　　 　成都圣月制冷　　 　重庆电商网站建设　　 　广安网站建设　　 　高防服务器租用　　 　网络营销推广　　 　阿坝网站设计　　 　成都网站制作　　 　小谭建站　　 　柔性防护网　　 　成都SEO优化公司　　 　犀浦防护栏定制　　 　成都网站建设公司