flow_control.jpeg
本文大纲: Java 的流程控制是什么样子的 - 图2

为什么需要流程控制

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

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

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

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

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

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

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

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

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

输入和输出

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

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

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

Scanner 介绍

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

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

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

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

Scanner 使用

我们可以看下样例代码:

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

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

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

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

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

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

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

我们再看一种输入:

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

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

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

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

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

输出

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

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

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

以下是示例代码:

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

输出结果如下:

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

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

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

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

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

三种流程控制结构

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

顺序结构

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

选择结构

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

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

if单选择结构

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

语法如下:

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

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

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

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

if双选择结构

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

语法如下:

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

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

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

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

if多选择结构

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

语法如下:

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

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

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

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

if嵌套选择结构

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

语法如下:

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

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

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

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

switch选择结构

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

语法如下:

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

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

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

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

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

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

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

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

循环结构

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

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

我的代码可能就是这样:

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

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

这种机制就是循环结构。

while循环结构

最常用的循环结构是 while 循环,语法如下:

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

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

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

do while循环结构

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

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

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

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

for循环结构

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

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

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

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

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

for each循环结构

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

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

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

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

循环结构的中断

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

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

一种是 break。语法如下:

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

求和示例代码如下:

  1. int a = 1;
  2. int sum = 0;
  3. while (a <= 5) {
  4. // a 为 3 的时候中断
  5. if (a == 3) {
  6. break;
  7. }
  8. // a 累加到 sum 中
  9. sum += a;
  10. // a 自身加一
  11. a++;
  12. }
  13. System.out.println("while sum:" + sum);
  • 实际对 1 和 2 进行求和,因为 a 为 3 的时候退出了循环。

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

另一种是 continue,语法如下:

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

示例代码如下:

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

输出:

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

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

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

小结

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