一、程序执行的基本流程

1.1 什么是程序执行逻辑

程序逻辑控制指的是通过特定的语法结构，控制代码的执行顺序和方式。在Java中，主要有三种基本的控制结构：

顺序结构:代码按照书写顺序从上到下执行

**分支结构:**根据条件来判断执行哪一部分的代码

**循环结构:**重复执行某段代码,直到达到你的要求

1.2 一个简单的java代码

在外面深入讨论逻辑控制之前,我想先举一个非常简单的例子来给大家了解一下我们代码的基本顺序结构

public class text {
    public static void main(String[] args) {
        System.out.println("Hello World");
        System.out.println("这是第一行");
        System.out.println("这是第二行");
        System.out.println("-----------------");
        System.out.println("程序执行完毕");
    }
}

通过这个代码,我们先不进行分析,直接运行一下,看看我们最后的打印结果是什么样的

编辑

大家可以很明显的看出来,我们这个代码的执行顺序是从上往下依次执行的,也就是输出结果严格按照代码的书写顺序显示,这就是最简单的顺序结构.

1.3 代码块的概念

在Java中，一对大括号{}定义了一个代码块。代码块中的语句被视为一个整体，这在逻辑控制中非常重要.

    public static void main(String[] args) {
    //接下来是一个代码行
        System.out.println("这里是代码行");
        System.out.println("--------------------");
        //接下里是代码块
        {
            System.out.println("代码行第一行");
            System.out.println("代码行第二行");
        }
        System.out.println("--------------------");
        System.out.println("程序结束");
    }
}

大家可以看到,由{}包围的是代码块,而单独一句的为代码行,这里我也通过注释的形式写出来了.

理解代码块的概念对学习等会的条件和循环结构至关重要。

二、条件判断

条件判断——让程序学会做决定

在我们的日常生活中,总会有一些条件来影响我们的一个判断,就例如:

如果今天天气预报说有雨,那我就带伞,如果没有,就不带伞

如果今天妈妈不在家,那我就在外面吃饭,如果在,在家里吃

如果今天我带的钱足够,那我就买下这个东西,如果不够,那就不买

在我们的编程世界中,就有很多这样的案例,在遇到这个情况的时候,我们的Java就提供了几种条件判断语句,那么让我们从最简单的开始.

2.1 if语句

if语句是Java中最基本的条件判断结构，语法如下：

if (条件){
    //如果为真,执行里面的代码
}

让我们看一个具体的例子:

    public static void main(String[] args) {
        //如果成绩满60分,那就及格了,否则就不及格
        int score = 80;
        if (score >= 60) {
            System.out.println("恭喜你,考试及格了");
        }
        System.out.println("抱歉,你没有及格");
    }

让我们看看这个代码,这就是很简单的一个条件语句,拿人类的语言来说,就是你的score(考试成绩)如果大于60分,那么你就及格,然后打印“恭喜你,考试及格了”

也就是你先定义了一个int变量score,并且给其赋值80,在条件if里,你需要score大于等于60,如果满足条件,则进入if代码块并执行,如果没有则直接跳过.

2.2布尔表达式

布尔表达式：条件的核心

条件判断的核心是布尔表达式，即结果为true或false的表达式。Java中常用的比较运算符有：

> 大于

< 小于

>= 大于等于

<= 小于等于

== 等于

!= 不等于

public class BooleanExpression {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("a > b: " + (a > b));   // false
        System.out.println("a < b: " + (a < b));   // true
        System.out.println("a == b: " + (a == b)); // false
        System.out.println("a != b: " + (a != b)); // true

        // 这些比较结果可以直接用在if语句中
        if (a < b) {
            System.out.println("a小于b");
        }
    }
}

2.3 if-else语句

if-else语句：二选一的选择

很多时候，我们不仅想在条件成立时做某事，还想在条件不成立时做另一件事。这时就需要if-else语句：

if(条件){

}else{

}

实际运用案例:

public class text {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 60) {
            System.out.println("恭喜你，考试及格了！");
        } else {
            System.out.println("很遗憾，考试不及格！");
        }

        // 判断奇偶数的例子
        int number = 7;
        if (number % 2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "是奇数");
        }
    }
}

这里是两个例子,第一个例子就是我在if语句时候使用的例子,在这里加了else,也就是if里面的条件你没有满足,则会执行else里面的代码

第二个例子先是定义了一个int类型的变量number,并赋值7.如果number % 2的值等于0,则说明这个数是偶数(打印if里面的代码).反之.

2.4 if-else if-else语句

if-else if-else语句：多条件判断

当有多个条件需要判断时，可以使用if-else if-else结构：

我们继续拿学习成绩这个例子:

public class text {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 70) {
            System.out.println("中等");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
    }
}

大家可以看到,我在这个例子里面使用了多个else,其实就是在我们需要完成多个条件的时候,单单if-else语句不能满足我们的需求,这时候就要用到if-else if-else.

2.5 嵌套if语句

if语句中可以再包含if语句，这称为嵌套if：

    static void main(String[] args) {
        int age = 20;
        boolean hasID = true;
        if (age >= 18) {
            //检查有没有身份证
            if(hasID){
                System.out.println("可以进入网吧");
            }else {
                System.out.println("没有身份证，不能进入");
            }
        }else {
            System.out.println("年龄不符合要求，不能进入");
        }
    }

多个if条件语句可以帮助你进行更为复杂的判断.

2.6 逻辑运算符

逻辑运算符：组合多个条件

有时候我们需要同时满足多个条件，或者满足多个条件之一。这时就需要逻辑运算符：

&& 逻辑与（并且）：两个条件都为真时结果为真

|| 逻辑或（或者）：至少一个条件为真时结果为真

! 逻辑非（取反）：将真变假，假变真

public class text {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;
        boolean hasMoney = false;

        // 使用&&（与）运算符
        if (age >= 18 && hasTicket) {
            System.out.println("可以观看电影");
        } else {
            System.out.println("不能观看电影");
        }

        // 使用||（或）运算符
        if (hasTicket || hasMoney) {
            System.out.println("可以购买电影票");
        } else {
            System.out.println("无法购买电影票");
        }

        // 使用!（非）运算符
        if (!hasMoney) {
            System.out.println("钱包空空如也");
        }

        // 复杂条件示例
        boolean isWeekend = true;
        boolean isHoliday = false;
        boolean hasWork = false;

        if ((isWeekend || isHoliday) && !hasWork) {
            System.out.println("今天可以休息");
        }
    }
}

我们根据这个结果来分析一下这个代码

使用&&（与）运算符

// 使用&&（与）运算符 if (age >= 18 && hasTicket) { System.out.println("可以观看电影"); } else { System.out.println("不能观看电影"); }

两个条件都满足才能执行相应代码块的内容,在if条件里面,age >= 18 和 hasTicket 都是为真,所以打印“可以观看电影”

// 使用||（或）运算符

boolean hasTicket = true; boolean hasMoney = false; if (hasTicket || hasMoney) { System.out.println("可以购买电影票"); } else { System.out.println("无法购买电影票"); }

两个条件有一个正确就能执行相应代码块的内容,在if条件里面,hasTicket为真,所以直接打印了“可以购买电影票”

// 使用!（非）运算符

// 使用!（非）运算符 boolean hasMoney = false; if (!hasMoney) { System.out.println("钱包空空如也"); }

这里我们能看到原来定义hasMoney的时候赋的是false,按道理来说这里应该是不正确的,但是为什么还是打印了“钱包空空如也呢”,这就是!运算符的功能,“!”表示非,拿简单的话来说,就是负负得正,所以这个时候hasMoney为ture,从而执行下面的代码块

boolean isWeekend = true; boolean isHoliday = false; boolean hasWork = false; if ((isWeekend || isHoliday) && !hasWork) { System.out.println("今天可以休息"); }

if ((isWeekend || isHoliday) && !hasWork) 这句的意思是

isWeekend 和 isHoliday其一满足就继续执行

(isWeekend || isHoliday) && !hasWork 两者都为真则执行对应的代码块,前面的(isWeekend || isHoliday)为真,如果!hasWork也为真,则整个if语句为真

!hasWork 我们看到boolean hasWork = false;但是有!运算符,所以haswork为ture

2.7switch语句

switch语句：多分支选择

基础写法:

当需要根据一个变量的不同值执行不同的代码时，除了使用多个if-else if，还可以使用switch语句，它更清晰易懂：

    public static void main(String[] args) {
        int dayOfWeek = 3;

        switch (dayOfWeek) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("无效的日期");
                break;
        }
    }

关键点说明：

switch后面的括号中是要判断的变量或表达式

case后面跟的是可能的值

break语句用于退出switch结构，如果没有break，程序会继续执行下一个case

default是可选的，当所有case都不匹配时执行

在这个代码里面,switch里面的要判断的变量是dayOfWeek.我们实现定义好了dayOfWeek = 3

那么当我们运行代码的时候,当程序遇到了case 3:的时候,就会执行case 3的代码,我们可以运行一下是不是这样

编辑

如果说我们的dayofWeek的值为7,也就是case后面的值所没有的,则会返回default.

进阶写法:

在java12后的版本,swithc语句有了更为简洁的写法

public static void main(String[] args) {
        int dayOfWeek = 3;

        // 增强型switch写法
        switch (dayOfWeek) {
            case 1 -> System.out.println("星期一");
            case 2 -> System.out.println("星期二");
            case 3 -> System.out.println("星期三");
            case 4 -> System.out.println("星期四");
            case 5 -> System.out.println("星期五");
            case 6 -> System.out.println("星期六");
            case 7 -> System.out.println("星期日");
            default -> System.out.println("无效的日期");
        }

        // switch还可以返回值
        String dayType = switch (dayOfWeek) {
            case 1, 2, 3, 4, 5 -> "工作日";
            case 6, 7 -> "周末";
            default -> "无效";
        };

        System.out.println("今天是" + dayType);
    }

大家可以看到这种写法相较于最基础的写法来说,大大的便利了我们程序员的写代码速度.

2.8 三元运算符

Java还提供了一个简洁的条件运算符，也称为三元运算符：

条件 ? 表达式1 : 表达式2

如果条件为真,则返回第一个表达式的值;如果为假,返回第二个表达式的值

    static void main(String[] args) {
        int a = 10;
        int b = 20;

        //使用三元操作符
        int max = (a > b) ? a : b;
        System.out.println(max);
    }

那么我们运行一下会发现,最后的打印出来的是“20”.这是因为三目运算符的条件为假,那么我们就会返回第二个表达式的值,也就是20.

再举个例子,使用三元运算符来判断奇偶数:

    public static void main(String[] args) {
        int number = 15;
        String type = (number % 2 == 0) ? "偶数" : "基数";
        System.out.println(number + "是" + type);
    }

三元运算符可以使代码更简洁，但过度使用可能会降低可读性。

三、循环结构

3.1 为什么需要循环？

大家可以想象一下,你想打印1 ~ 100的数字,在没有学习循环结构的情况下,你的方案可能是这样的:

    public static void main(String[] args) {
        System.out.println("1");
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        //此处省略
        System.out.println("......");
        System.out.println("100");
    }

但是如果大家学习了循环结构后,我们就可以使用简洁的代码来优雅的完成1 ~ 100的数字打印.

循环结构让程序能够重复执行特定的代码块，大大提高了代码的复用性和效率。

3.2 for循环

for循环是我们最常用的循环.for循环通常用于已知循环次数的情况，语法如下：

for (初始化; 循环条件; 更新) {
    // 循环体
}

那我们该如何使用for循环来打印1 ~ 100的数字呢,其实很简单:

    public static void main(String[] args) {
        //打印1 ~ 100的值
        int i = 0;
        for (i = 0; i <= 100; i++) {
            System.out.println(i);
        }
    }

大家能看到,如果单单使用System.out.println()函数需要100行代码,而我们使用for循环的话仅仅需要3行代码即可

那么我们可以看到:

i = 0是我们的初始化,意思是将0赋值给i这个变量

i <= 100是循环条件,意思就是i<=100之前(如果条件为真，执行循环体),该语句一直循环,到101则不符合条件,跳出循环

i++是更新,这是自增1

for循环的另一种语法格式

for (元素类型 元素变量 : 数组或集合) {
    // 循环体
}

这里讲到了数组到时候我再拿出来细说:

public class Main {
    public static void main(String[] args) {
        // 定义一个整数数组，里面有5个数字
        int[] numbers = {10, 20, 30, 40, 50};

        // 使用增强 for 循环，逐个打印数组里的每个数字
        for (int num : numbers) {
            System.out.println(num);
        }
    }
}

int num : numbers

元素类型 : int

元素变量 : num

数组或集合 : numbers

3.3 while 循环

while循环在不确定循环次数，但知道循环条件时使用:

while (循环条件) {
    // 循环体
}

我们来举一个非常简单的例子:

public static void main(String[] args) {
        // 简单while循环
        int count = 1;
        while (count <= 5) {
            System.out.println("计数: " + count);
            count++; // 不要忘记更新循环变量，否则会无限循环
        }

3.4 do-while循环

do-while循环：至少执行一次的循环

do-while循环与while循环类似，但它会先执行循环体，再检查条件，因此循环体至少执行一次：

do {
    // 循环体
} while (循环条件);

    public static void main(String[] args) {
        int count = 0;
        do {
            System.out.println("计数" + count);
            count++;
        }while (count <= 5);
    }

这是非常简单的do while循环的语法,但是大家可以看到这并不能体现开始就执行代码的特性,那么我们来看看下面这个代码

// 即使条件一开始就不满足，也会执行一次
    public static void main(String[] args) {
        int a = 10;
        do {
            System.out.println("至少运行一次,无论条件是否为真");
            a++;
        }while (a < 5);
    }

3.5 三种循环的对比

循环类型	特点	适用场景
`for` 循环	循环次数已知，结构紧凑	遍历数组、固定次数的循环
`while` 循环	先判断后执行，可能一次都不执行	条件控制，循环次数不确定
`do-while` 循环	先执行后判断，至少执行一次	菜单显示、用户输入验证等

四、循环控制语句

4.1break语句

break语句：立即退出循环

    public static void main(String[] args) {
        for (int i = 0; i <= 10; i++) {
            if(i == 5){
                System.out.println("循环到5提前结束,使用break");
                System.out.println("现在i = " + i);
                break;
            }
        }
    }

那让我们运行一下看看结果,是否i = 5的时候成功跳出循环了

编辑

4.2 continue语句

continue语句：跳过本次循环.

continue语句用于跳过当前循环的剩余部分，直接开始下一次循环：

那么我们使用continue打印1 ~ 20的奇数:

    public static void main(String[] args) {
        //使用continue来跳过偶数
        for (int i = 0; i <= 20; i++) {
            if(i % 2 == 0){
                continue;
            }
            System.out.println(i);
        }
    }

那么我们运行一下

4.3 return语句

return语句：用于退出当前方法，如果方法有返回值，则返回相应的值：

public class Main {
    public static void main(String[] args) {
        // 调用 add 方法，并把结果打印出来
        int result = add(3, 5);
        System.out.println("3 + 5 = " + result);
    }

    // 定义一个方法：接收两个整数，返回它们的和
    public static int add(int a, int b) {
        int sum = a + b;
        return sum;  // 把计算结果“返回”出去
    }
}

由于这里的代码对于目前的小伙伴有些没学过,所以我来个非常简单的解释

return sum; 的意思是：“这个方法干完活了，把 sum 这个值交回去！”

谁调用这个方法（比如 add(3, 5)），就能拿到 return 后面的值（这里是 8）。

return 就像你去超市买东西，收银员算完总价后 “返回”给你账单金额。

return 就是“把结果交出去”，让调用者能拿到方法计算好的值。

那么退出当前方法又是怎么一回事呢

public class Main {
    public static void main(String[] args) {
        checkAge(16);  // 试试输入一个未成年年龄
        System.out.println("程序继续执行...");
    }

    public static void checkAge(int age) {
        if (age < 18) {
            System.out.println("你还未成年，不能进入！");
            return;  //立刻退出这个方法，后面的代码不再执行
        }

        // 下面这行只有年满18岁才会执行
        System.out.println("欢迎进入！");
    }
}

这个方法是 void 类型（不返回值），所以 return; 的作用不是“交结果”，而是 “马上离开这个方法”。
就像你进电影院，检票员一看你没成年，直接说：“不行！”——然后你就走了，后面的事（看电影）就不再发生了。

那么针针对这两个代码的return,我们来做个总结:

场景	`return` 写法	作用
要返回一个结果（比如计算和）	`return 8;`	把值交出去
只想提前结束方法（比如条件不满足）	`return;`	立刻退出，啥也不交

五、案例练习

5.1 简单计算器

功能需求：

显示菜单（加、减、乘、除、退出）

用户选择操作

输入两个数字

计算并显示结果

支持重复使用（循环）

能安全退出

处理除零错误

5.1.1 搭建主框架

主方法 + 循环结构 : 先写出程序骨架：用 while(true) 实现“一直运行，直到用户主动退出”。

public class SimpleCalculator {
    public static void main(String[] args) {
        while (true) {
            // 后续在这里加菜单和逻辑
        }
    }
}

5.1.2 添加菜单显示

直接使用打印来添加菜单栏显示

System.out.println("\n=== 简单计算器 ===");
System.out.println("1. 加法");
System.out.println("2. 减法");
System.out.println("3. 乘法");
System.out.println("4. 除法");
System.out.println("5. 退出");
System.out.print("请选择操作 (1-5): ");

5.1.3 读取用户输入（引入 Scanner）

要从键盘获取输入，必须使用 Scanner 类,这个在下一篇会详细说明

import java.util.Scanner; // 文件顶部导入,使用IDEA会直接导入

// 在 main 方法中
Scanner scanner = new Scanner(System.in);
int choice = scanner.nextInt(); // 读取整数选择

5.1.3 退出功能

如果用户选 5，就结束程序：

if (choice == 5) {
    System.out.println("感谢使用计算器，再见！");
    break; // 跳出 while 循环，程序结束
}

5.1.4 验证用户输入是否合法

因为在开发这些小项目的时候(虽然这只是联系,但是你以后就业后的项目就会出现这一问题),你不能保证用户会输入一些奇奇怪怪的东西,所以我们需要一个输入检测,也就是防止用户输入 0、6、100 等无效选项：

if (choice < 1 || choice > 5) {
    System.out.println("无效选择，请重新输入！");
    continue; // 跳过本次循环剩余代码，直接回到菜单
}

5.1.5 获取两个操作数（参与计算的数字）

既然选择了有效操作（1~4），就让用户输入两个数：

System.out.print("请输入第一个数字: ");
double num1 = scanner.nextDouble();

System.out.print("请输入第二个数字: ");
double num2 = scanner.nextDouble();

5.1.6 根据选择执行对应运算

这里是整个代码最重要的一个地方,我们用 switch 语句判断用户选了哪种运算：

double result = 0;
boolean validOperation = true; // 标记运算是否成功

switch (choice) {
    case 1 -> result = num1 + num2;
    case 2 -> result = num1 - num2;
    case 3 -> result = num1 * num2;
    case 4 -> {
        if (num2 != 0) {
            result = num1 / num2;
        } else {
            System.out.println("错误：除数不能为零！");
            validOperation = false; // 标记失败，不显示结果
        }
    }
}

5.1.7 格式化显示结果

if (validOperation) {
    String[] operations = {"加法", "减法", "乘法", "除法"};
    String operator = 
        choice == 1 ? "+" : 
        choice == 2 ? "-" : 
        choice == 3 ? "×" : "÷";

    System.out.printf("%s结果: %.2f %s %.2f = %.2f%n", 
        operations[choice - 1], num1, operator, num2, result);
}

%.2f：保留两位小数

%n：换行（比 \n 更跨平台）

三元运算符简洁地映射运算符符号

输出像这样：加法结果: 3.00 + 4.50 = 7.50

5.1.8 关闭资源

程序结束前释放 Scanner 占用的系统资源,这里下一篇会细讲

scanner.close(); // 放在 while 循环结束后

5.2 整体代码展示

import java.util.Scanner;

public class text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            // 显示菜单
            System.out.println("\n=== 简单计算器 ===");
            System.out.println("1. 加法");
            System.out.println("2. 减法");
            System.out.println("3. 乘法");
            System.out.println("4. 除法");
            System.out.println("5. 退出");
            System.out.print("请选择操作 (1-5): ");

            int choice = scanner.nextInt();

            // 处理退出
            if (choice == 5) {
                System.out.println("感谢使用计算器，再见！");
                break;
            }

            // 验证选择是否有效
            if (choice < 1 || choice > 5) {
                System.out.println("无效选择，请重新输入！");
                continue;
            }

            // 获取两个操作数
            System.out.print("请输入第一个数字: ");
            double num1 = scanner.nextDouble();

            System.out.print("请输入第二个数字: ");
            double num2 = scanner.nextDouble();

            // 执行计算
            double result = 0;
            boolean validOperation = true; // 标记运算是否成功

            switch (choice) {
                case 1 -> result = num1 + num2;
                case 2 -> result = num1 - num2;
                case 3 -> result = num1 * num2;
                case 4 -> {
                    if (num2 != 0) {
                        result = num1 / num2;
                    } else {
                        System.out.println("错误：除数不能为零！");
                        validOperation = false;
                    }
                }
            }

            // 显示结果（仅当运算有效时）
            if (validOperation) {
                String[] operations = {"加法", "减法", "乘法", "除法"};
                String operator =
                        choice == 1 ? "+" :
                                choice == 2 ? "-" :
                                        choice == 3 ? "×" : "÷";

                System.out.printf("%s结果: %.2f %s %.2f = %.2f%n",
                        operations[choice - 1], num1, operator, num2, result);
            }
        }

        scanner.close(); // 关闭资源
    }
}

完