初识Java ~ (二) # Java 中程序的执行流程，（万字长文）特别细~ 可收藏~

大家好~ ，我是清汉

时隔一月，懒惰的我终于将 Java 初识系列文章，第二篇程序执行流程码出来了~

初识Java ~ (一) 从0开始，Java基础知识，双手奉上~ 可收藏！！

应该不算太晚吧，这一个月的学习自我感觉进步飞快，虽然写文章的进度慢了点，哈哈~

话不多说，赶紧上~

声明：未打广告，全文知识梳理来源于《JAVA入门1-2-3》豆瓣评分9.0

注：例中所有 >>> 符号后为输出结果

- -snip- - 为代码省略位置

文章目录

知识框图
- 引言
- Java 中的程序执行流程（思维导图）
- - - 代码执行机制
    - - 顺序执行
        if... else.. 语句
    - 循环语句
    - - while 语句
        do...while 语句
        for 语句
        continue 与 break 关键字
    - 拓展
    - - switch 语句
        标签
    - 本篇小结

知识框图

引言

Java 中的程序是按什么顺序执行的呢?它有什么样的流程呢？
- 下文中我们将揭示 Java 程序（代码）的执行过程，深入了解 Java 的程序执行流程机制。

Java 中的程序执行流程（思维导图）

代码执行机制

顺序执行

不知道 “小伙伴们” 有没有发现，在我们本系列文章的第一篇中，文章所有的代码示例都是从 main() 方法的第一行开始执行，直到 main() 方法的最后一行。
public static void main(String[] args) {
// 第一行 ⬇
// 第二行... ⬇
// ... ... ⬇
// 最后一行 ⬇
}

由此我们可以简单的得出一个结论，Java 中的代码执行流程是按顺序的、从上到下依次执行的。

但是 Java 语言中的程序执行流程真的就如此简单吗？会不会显得很死板？
当然 Java 语言不可能就只是这样了，目前只是我们初学 Java 总结出来的一些结论，也只是管中窥豹而已。让我们迈着轻快的步伐继续深入探索 Java 的世界吧。。。

if… else… 语句

程序执行不可能只有一条路，Java 这么高级的语言怎么能像头倔驴一样，一条道走到黑呢？因为这样不够灵活，只能处理一些很简单的逻辑，而且在实际开发应用中，会有各种各样的复杂逻辑需要处理，所以一条道走到黑是没有前途的。
这些我们能想到的事情，Java 那一帮聪明绝顶的开发者肯定也能想得到了。所以 Java 给我们提供 if… else… 语句。
有了 if… else… 语句后，我们程序的执行就有了分枝。之前我们是一条道走到黑，现在我们就有了很多分岔路可以选择，使程序的执行更加灵活，也可以处理更加复杂的逻辑了。

下面就让我们看一下这个 if… else… 语句如何使用吧！

// if...else.. 语句实例

public class PriceAndAmount {
    public static void main(String[] args) {
        // 创建两个 整型变量 赋值为负数；
        int price  = -5; 
        int amount = -10;
        
		// 使用 if 语句检查两个变量是否都大于0， 
		// 大于0 返回 true,否则返回 false;
        if (price > 0 && amount > 0) { 
        	// 两个变量做乘法运算，结果赋值给新创建的 int类型变量
            int totalCost = price * amount; 
            
            System.out.print(totalCost); // 向控制台输出结果
        }
        else {
            System.out.println("price与amount的值必须大于0，否则无法计算。");
        }
    }
}
// >>> price与amount的值必须大于0，否则无法计算。

if…else… 语句是 Java 语法中用来支持程序根据一个 boolean （布尔）值来让程序的执行流程进行跳转的语句。
if…else… 语句的结构：
- if (一个 boolean 表达式或者是一个 boolean 值) {
- // 如果if() 括号中的是 true 则执行 {} 大括号内的代码
- } else {
- // 如果if() 括号中的是 false 则执行 else 大括号内的代码
- }
可以将 if…else… 理解为：如果…否则…
如果满足条件执行这段代码，否则就执行另一段代码

当然 if…else… 语句也不是必须成对使用还有以下几种使用方法，现在一一介绍给大家

1. 单 if()

// 单个 if 语句实例

public class IfDemo1 {

    public static void main(String[] args) {

        int a = 0, b = 1;

        if (a > 0) {
            System.out.println("变量 a 大于0，打印a：" + a);
        }
        System.out.println("变量 a 不大于0，前面的 if 语句不满足条件，n程序跳过 if 语句体中的内容执行到此处，打印 b：" + b);
    }
}
// >>> 变量 a 不大于0，前面的 if 语句不满足条件，
// >>> 程序跳过 if 语句体中的内容执行到此处，打印 b：1

2. 多 if()

// 多个if 语句实例

public static void main(String[] args) {

        int a = 0, b = 1, c = 2;

        if (a > 0) {
            System.out.println("变量 a 大于0，打印a：" + a);
        }
        if (b == 0) {
            System.out.println("变量 b等于0，打印b：" + b);
        }
        if (c == 1) {
            System.out.println("变量 c等于1，打印b：" + c);
        }
        System.out.println("程序顺序执行，前面三个 if 语句都不满足条件，跳过 if 语句体中的内容执行到此处");
    }
}
// >>> 程序顺序执行，前面三个 if 语句都不满足条件，跳过 if 语句体中的内容执行到此处

3. if()...else if()...else 语句

// if()...else if()...else 语句实例

public class CountScrip {
    public static void main(String[] args) {
        int totalCost = 350;

        if (totalCost < 100) {
            System.out.println("不足100元，不送优惠券");
        }
        else if (totalCost <= 500) {
            System.out.println("满100元，送55元优惠券");
        }
        else {
            System.out.println("500元以上，送155元优惠券");
        }
    }
}

// >>> 满100元，送55元优惠券

if()…else if()…else 语句

这种语句结构，可以理解为：
如果…再如果…否则

过程如下：

第一个 if 如果满足条件则不执行后面的 else if…else
第一个 if 如果不满足条件，则判断 else if 是否满足条件
else if 满足条件执行，后面 else 跳过
else if 不满足条件，则执行 else

通过学习 if 语句我们知道了，Java 程序不光是只会一条道走到黑，还可以通过 if 语句来选择不同的分岔路。
虽然程序有了岔路，可以选择不同的代码执行，但是整个程序还是一往无前 ”不回头“，还是感觉不太聪明的样子。
而且再实际应用中，有时候要循环往复了处理多次一样的代码，那这又该怎么办呢？难道要每执行一次，就要敲一遍相同的代码？虽然有复制粘贴可以使用，但2遍3遍还好，若是几万次呢？难道也重复复制粘贴？
显然复制粘贴是不合理的，这样代码量也忒大了，而且都是重复的，我们不是赋值粘贴的机器人，我们是赋予程序灵魂的程序员”不是“？

下面隆重介绍我们 Java 中的循环语句

循环语句

在 Java 中我们循环语句有三种，分别是：
while
do…while
for

具体如何使用，功能是什么？
下面让我们娓娓道来~

while 语句

// while 语句实例


public class SettleAccountsUsingWhile {
    public static void main(String[] args) {
        int times = 5; // 设定收银次数作为 while 循环条件。

        while (times > 0) {
            // 创建两个 int类型 变量，并分别赋值
            int price = 5;      // 商品价格
            int amount = 10;    // 商品数量

            if (price > 0 && amount > 0) { // 判断两个变量是否大于 0;
                int totalCost = price * amount;
                System.out.println(totalCost);
            } else {
                System.out.println("price与amount的值必须大于0，否则无法计算。");
            }
            times -= 1; // 收银次数减 1,循环 5次 后为 0,不满足 while循环 条件，退出循环。
        }
        System.out.println("完成今天结账工作，收银员可以下班了");
    }
}
// >>> 50
// >>> 50
// >>> 50
// >>> 50
// >>> 50
// >>> 完成今天结账工作，收银员可以下班了

while 的功能
- while 语句可以根据一个 boolean 表达式的值来将一段代码执行 0 次到无数次。
- 可以理解为：当满足条件时，就一直循环执行 while语句 {} 大括号内的代码。条件不满足时，循环结束。

while 语句的结构：

while(一个 boolean 表达式或者是一个 boolean 值) {
// 要执行的代码
}

while 语句的执行流程

⬆ ➡ 计算条件表达式的值
⬆ ⬇
⬆ while 语句条件表达式的值 ➡ false
⬆ ⬇ ⬇
⬆ true while 语句执行结束
⬆ ⬇
⬆ ⬅ 执行 while 语句{}内的代码

do…while 语句

// do...while语句实例


public class SettleAccountsUsingDoWhile {
    public static void main(String[] args) {
        int times = 5;

        do { // // do while语句，循环体。无论是否满足表达式条件，都要先执行一遍代码块。
            // 创建两个 int类型 变量，并分别赋值
            int price = 5;      // 商品价格
            int amount = 10;    // 商品数量

            if (price > 0 && amount > 0) { // 判断两个变量是否大于 0;
                int totalCost = price * amount;
                System.out.println(totalCost);
            } else {
                System.out.println("price与amount的值必须大于0，否则无法计算。");
            }
            times -= 1;
        } while (times > 0); // do while语句，条件表达式放在循环体后面，且要加分号;
        System.out.println("完成今天结账工作，收银员可以下班了");
    }
}

// >>> 50
// >>> 50
// >>> 50
// >>> 50
// >>> 50
// >>> 完成今天结账工作，收银员可以下班了

do…while 的功能
- 我们这里 do…while 的代码实现实例与 while 的代码实现实例基本一致，都可以得到相同的结果，只不过把 while 替换为了do…while;
- 其中不同的是：do…while 语句{}大括号内的代码会先执行一遍，再去判断条件表达式。

do…while 语句的结构：

do {
// 要执行的代码
} while(一个 boolean 表达式或者是一个 boolean 值)

do…while 语句的执行流程

执行 while 语句{}内的代码
⬆ ⬇
true 计算条件表达式的值
⬆ ⬇
⬆ ⬅ do...while 条件表达式的值
⬇
false
⬇
while 语句执行结束

for 语句

public class SettleAccountsUsingFor {
    public static void main(String[] args) {
        //for (初始化语句; 条件语句; 条件变化语句;)
        for (int times = 0; times < 5; times++) {
         // 循环的次数为 5
         // times 不小于5的时候结束循环
         // 从0开始，0-1-2-3-4，共5次

            // 创建两个 int类型 变量，并分别赋值
            int price = 5;      // 商品价格
            int amount = 10;    // 商品数量

            if (price > 0 && amount > 0) { // 判断两个变量是否大于 0;
                int totalCost = price * amount;
                System.out.println(totalCost);
            } else {
                System.out.println("price与amount的值必须大于0，否则无法计算。");
            }
        }
        System.out.println("完成今天结账工作，收银员可以下班了");
    }
}

// >>> 50
// >>> 50
// >>> 50
// >>> 50
// >>> 50
// >>> 完成今天结账工作，收银员可以下班了

for 语句的功能
- 循环执行 for {} 大括号内的的代码，直到不满足循环条件。

for 语句的语法结构
for (初始化语句;条件语句;条件变化语句) {
// 要执行的代码
}

初始化语句，首先执行且只执行一遍，它会创建一个变量，这个变量会在后面的条件语句、条件变化语句中使用。
条件语句，用来判断循环体（for {} 大括号内的的代码）是否执行，true 执行，false 不执行。
条件变化语句在每次循环体（）执行完毕后执行，一般用来改变条件语句中使用的条件，常用的是变量 ++，–（自增、自减）操作。

for 语句的执行流程

初始化语句
⬇
⬆ ➡ 条件语句 ➡ false
⬆ ⬇ ⬇
⬆ true for 语句执行结束
⬆ ⬇
⬆ 循环体
⬆ ⬇
⬆ ⬅ 条件变化语句

continue 与 break 关键字

下面介绍两个用在循环中的关键字：continue 和 break，这两个关键字用在循环体中可以让我们的代码更加灵活。
具体的功能与使用方法下面我们逐个演示~

continue 关键字

// continue 关键字 演示实例

public class ContinueDemo {

    public static void main(String[] args) {

        for (int i = 1; i <= 5; i++) {
            if (i == 2) {
                continue;
                // 注意：continue 关键字之后的代码不会执行
                // Java 语法规定，continue 要放在代码块的最后一行
            }
            System.out.println("i 的值为：" + i);
        }
    }
}
// >>> i 的值为：1
// >>> i 的值为：3
// >>> i 的值为：4
// >>> i 的值为：5

continue 关键字的功能
- 通过上面的实例，输出控制台的结果可以得出结论：当循环体中执行到 continue 关键字的时候， continue 后面的代码将不再执行，而是转而计算循环条件表达式并根据值来判断是否执行下次循环体。
- 所以上面的实例中，输出打印结果没有 2；
- continue 在所有的循环中都有一样的效果，不管是 while、do…while、for 循环。
- Java 语法规定，continue 要放在代码块的最后一行

break 关键字

// break 关键字实例

public class BreakDemo {

    public static void main(String[] args) {
        // 声明变量 a
        int a = 1;
        // 使用 while 循环，条件表达式为 true
        while (true) {
            // 向控制台输出 a 的值
            System.out.println("a 的值为：" + a);
            // 使用 if 语句判断，当 a 等于 5 的时候，执行 break 语句
            if (a == 5) {
                break;
            }
            // 变量 a 执行自增操作
            a++;
        }
    }
}

// >>> a 的值为：1
// >>> a 的值为：2
// >>> a 的值为：3
// >>> a 的值为：4
// >>> a 的值为：5

break 关键字的功能
- break 关键字的语义是终止其所在的循环。
- Java 语法规定，break要放在代码块的最后一行
- 上例代码，我们使用了 while 循环，而且条件判断处赋值为 true；也就是说，循环会一直执行下去，直到永远~
- 但是，我们在 while 代码块中添加了一个 if 语句判断，当符合判断条件的时候就会执行 break 语句，执行后 while 循环也就结束了。
- 最后我们通过控制台的打印输出可以看出，a 的值打印到了 5，而不是一直累加下去。

拓展 switch 语句

switch 语句并不是循环语句，而是像 if 语句一样的分支语句。
它的作用跟 if 语句类似，也是给我们的程序制造分叉路口，根据不同的条件，选择不同的路。
好了，接下来让我们看看 switch 语句该如何使用吧~

// switch 语句实例

public class SwitchDemo1 {

    public static void main(String[] args) {
        int goodsNumber = 4; // 创建一个int类型变量并赋值为4

        switch (goodsNumber) { // 参数必须是一个 int类型或者char类型变量

            // 如果条件值1与goodsNumber值相等，则代码从此处执行
            // case语句只能在switch语句中，可以包含0到多个
            case 1:
                System.out.println("此商品属于食品分部");
                break;

            case 2: // 如果条件值2与goodsNumber值相等，则代码从此处执行
                System.out.println("此商品也属于食品分部");
                break;
            case 3:
                System.out.println("此商品属于百货分部");
                break;
            case 4:
                System.out.println("此商品也属于百货分部");
                break;
            case 5:
                System.out.println("此商品也也属于百货分部");
                break;

            // 如果 goodsNumber 的值在前面 case 里找不到，代码从此处执行
            default:
                System.out.println("无此商品");
                break;
        }
        System.out.println("switch 语句执行完毕");
    }
}

// >>> 此商品也属于百货分部
// >>> switch 语句执行完毕

switch 语句的语法结构
switch(待匹配值) {
case 条件值1:
代码块
case 条件值2:
代码块
case 条件值 .. :
代码块
... ... ...
default:
代码块
}

switch 语句功能

根据匹配值去选择执行哪个case代码块，若匹配值无法与 case 的值匹配，则会执行 default 代码块。
通常我们会在 case 代码块结尾处，添加一条 break 语句，来结束 switch 语句。
之所以这么做是因为 switch 语句有击穿的特性。
下例，将演示此特性。

public class UsingSwitch {
    public static void main(String[] args) {
        int goodsNumber = 3; 

        switch (goodsNumber) { 
        
            case 1: 
                System.out.println("此商品属于食品分部");
                break;
            case 2: 
                System.out.println("此商品也属于食品分部");
                break;
            case 3:
           		System.out.println("此商品属于玩具部");
            case 4:
            	System.out.println("此商品属于食材部");
            case 5:
                System.out.println("此商品也属于百货分部");
                break;

            default:
                System.out.println("无此商品");
                break;
        }
        System.out.println("switch 语句执行完毕");
    }
}
// >>> 此商品属于玩具部
// >>> 此商品属于食材部
// >>> 此商品也属于百货分部
// >>> switch 语句执行完毕

击穿⚡
- 上例中可以看到我们的匹配值是 3，但是与之对应的 case 3 没有以 break 语句作为结束。
- 程序在执行完成 case 3 的代码后，又去执行了 case 4 的代码，并且 case 4 的代码也并没有以 break 结束。
- 所以程序又去执行了 case 5 的代码，case 5 的代码是以 break 结束的。
- 到此结束 switch 语句的执行。
击穿的利弊
- 好处：当 case 中多个代码重复的时候，可以省略其中重复的代码，多次击穿执行最后的代码。
- 坏处：我们 switch 语句的功能就是给程序提供，分支（给出很多的路），若是将多条路都打通了，那我们的 switch 语句还有什么意义呢？

标签

在存在多个循环语句的情况下，标签配合 break 可以指定跳出那个循环语句。
具体实现方式下例将会演示。

// 标签的演示实例

public class LoDemo {

    public static void main(String[] args) {
        
        // 使用 while 循环，并定义一个标签 w1
        w1:while (true) {
            // 嵌套一个 for 循环，并定义一个标签 f1
            f1:for (int i = 0; i < 5; i++) {
                // 嵌套一个 switch 语句
                switch (i) {
                    case 1:
                        System.out.println("i 的值为：" + i);
                        break;
                    case 2:
                        System.out.println("i 的值为：" + i);
                        // 此处指定 break 语句跳出的循环为 w1
                        // 也就是 while 循环
                        break w1;
                    case 3:
                        System.out.println("i 的值为：" + i);
                        break;
                    case 4:
                        System.out.println("i 的值为：" + i);
                        break;
                    case 5:
                        System.out.println("i 的值为：" + i);
                        break;
                    default:
                        break;
                }
            }
        }
    }
}

// >>> i 的值为：1
// >>> i 的值为：2

上例中，当代码执行到 switch 语句的 case 2 代码块的 break w1;时, break 语句不会跳出当前的 switch 语句，而是会跳出标签所在的 while 语句，然后 while 循环结束，程序执行完毕。
上例中，我们还给 for 循环也加了标签，也就是说我们也可以指定跳出 for 循环。在这里我们没有演示，只跳出 for 循环而不跳出 while 循环的效果，因为 while 的判断条件是 true，也就是个死循环。若是 case 2 中跳出的是 for 循环，那控制台会一直输出什么内容呢？（有兴趣的小伙伴可以自己尝试一下）

本篇小结

Java 不是一个直肠子
分支语句：
- if 语句
  - 根据一个条件判断 if 语句的代码块是否执行。
- if…else 语句
  - 根据条件判断是执行 if 还是 else 的代码块。
- if…else if…else 语句
  - 根据条件判断是执行 if 、else if 还是 else 的代码块。
- switch 语句
  - 根据一个 int 或者 char 变量，与 case 语句中的值匹配，来决定执行哪段代码。
  - 理解穿透特性。
- 应熟练使用，对于嵌套起来使用，应做到条理清晰，需要代码量的支持。
循环语句：
- while 语句
- do…while 语句
- for 语句
- 三种循环本质上作用都是一样的，在确定循环次数的情况下尽量使用 for 循环，在不确定循环次数的情况下尽量使用 while 循环，设定条件结束循环，不然会造成死循环。
熟练使用 continue 与 break 关键字，理解每个关键字的功能。
拓展的标签功能有时会帮你解决编程时遇到的难题。

文章中若是有什么不对的地方，欢迎大家指出纠错，共同进步！！

感谢，每一位认真阅读到这里的少侠！来个手滑三联吧，不迷路~

下期见，等你哟~

初识Java ~ (二) # Java 中程序的执行流程，（万字长文）特别细~ 可收藏~

Java相关栏目本月热门文章