【Java编程动手学】Java中的表达式与语句

文章目录

• 一、引言
• 二、表达式与语句基础
• • • [1. 表达式（Expression）](#1. 表达式（Expression）)
    • • 常见表达式类型：
      • 示例代码：
    • [2. 语句（Statement）](#2. 语句（Statement）)
    • • 常见语句类型：
      • 示例代码：
    • [3. 语句块（Block）](#3. 语句块（Block）)
    • • 示例代码：
• 三、程序执行顺序
• • • [1. 顺序结构](#1. 顺序结构)
    • [2. 流程控制对比表](#2. 流程控制对比表)
• 四、条件分支语句
• • • [1. if条件分支](#1. if条件分支)
    • • 基本语法：
      • 示例代码：
    • [2. switch条件分支](#2. switch条件分支)
    • • 基本语法：
      • 示例代码：
      • `break`的作用：
• 五、循环结构
• • • [1. for循环](#1. for循环)
    • • 基本语法：
      • 示例代码：
      • `break`与`continue`：
    • [2. while循环](#2. while循环)
    • • 基本语法：
      • 示例代码：
      • `break`与`continue`用法同`for`循环。
    • [3. do-while循环](#3. do-while循环)
    • • 基本语法：
      • 示例代码：
      • 循环结构对比表
• 六、return语句
• • • • 基本语法：
      • 示例代码：
• 七、完整代码示例
• • • 代码说明：
    • 预期输出：
• 总结

---

一、引言

Java作为一门面向对象的编程语言，其核心逻辑由表达式 和语句 构成。表达式用于计算值，语句用于执行操作，而语句块（由大括号{}包裹的语句集合）则定义了代码的作用域。掌握这些基础概念是编写高效Java程序的关键。本文将系统讲解表达式、语句、语句块，以及程序执行顺序、条件分支、循环结构和return语句的用法，并通过代码示例和表格对比加深理解。

---

二、表达式与语句基础

1. 表达式（Expression）

表达式是由变量、运算符、方法调用等组成的组合，能够计算并返回一个值。表达式可以单独存在，也可以作为语句的一部分。

常见表达式类型：

• 算术表达式 ：3 + 5 * 2（结果为13）
• 逻辑表达式 ：a > 0 && b < 10（返回布尔值）
• 赋值表达式 ：int x = 10;（将10赋值给x，表达式值为10）
• 方法调用表达式 ：Math.sqrt(16)（返回4.0）

示例代码：

public class ExpressionDemo {
    public static void main(String[] args) {
        int a = 5, b = 3;
        // 算术表达式
        int sum = a + b; // 表达式值为8
        System.out.println("Sum: " + sum);

        // 逻辑表达式
        boolean isGreater = (a > b); // 表达式值为true
        System.out.println("a > b? " + isGreater);

        // 方法调用表达式
        double sqrt = Math.sqrt(25); // 表达式值为5.0
        System.out.println("Square root: " + sqrt);
    }
}

2. 语句（Statement）

语句是Java中执行操作的最小单位，通常以分号;结尾。语句可以包含表达式，但表达式本身不一定是语句（如3 + 4是表达式，但缺少分号时不是语句）。

常见语句类型：

• 声明语句 ：int num;
• 赋值语句 ：num = 10;
• 控制语句 ：if (x > 0) {...}
• 循环语句 ：for (int i = 0; i < 5; i++) {...}

示例代码：

public class StatementDemo {
    public static void main(String[] args) {
        // 声明语句
        int age;
        // 赋值语句
        age = 25;
        // 控制语句（if）
        if (age >= 18) {
            System.out.println("Adult");
        }
    }
}

3. 语句块（Block）

语句块是由大括号{}包裹的一组语句，用于定义代码的作用域（如方法体、循环体、条件分支等）。

示例代码：

public class BlockDemo {
    public static void main(String[] args) {
        int x = 10;
        // 语句块
        {
            int y = 20; // y的作用域仅在此块内
            System.out.println("x + y = " + (x + y));
        }
        // System.out.println(y); // 编译错误：y未定义
    }
}

---

三、程序执行顺序

Java程序的执行顺序遵循从上到下、逐行执行的原则，但可以通过控制语句（如条件分支、循环）改变流程。

1. 顺序结构

默认的线性执行方式。

public class SequenceDemo {
    public static void main(String[] args) {
        System.out.println("Step 1"); // 先执行
        System.out.println("Step 2"); // 后执行
    }
}

2. 流程控制对比表

控制结构	作用	示例
顺序结构	逐行执行	System.out.println("A");
条件分支	根据条件选择执行路径	if (x > 0) {...}
循环结构	重复执行代码块	for (int i = 0; i < 5; i++)

---

四、条件分支语句

1. if条件分支

根据布尔表达式的值决定是否执行代码块。

基本语法：

if (condition) {
    // 条件为true时执行
} else if (condition2) {
    // 其他条件
} else {
    // 默认情况
}

示例代码：

public class IfDemo {
    public static void main(String[] args) {
        int score = 85;
        if (score >= 90) {
            System.out.println("A");
        } else if (score >= 80) {
            System.out.println("B"); // 输出B
        } else {
            System.out.println("C");
        }
    }
}

2. switch条件分支

根据表达式的值匹配多个case，适合多分支场景。

基本语法：

switch (expression) {
    case value1:
        // 代码块
        break; // 跳出switch
    case value2:
        // 代码块
        break;
    default:
        // 默认情况
}

示例代码：

public class SwitchDemo {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday"); // 输出Wednesday
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

break的作用：

• 终止当前case的执行，防止穿透（fall-through）。
• 若省略break，会继续执行下一个case的代码。

---

五、循环结构

1. for循环

适合已知循环次数的场景。

基本语法：

for (初始化; 条件; 迭代) {
    // 循环体
}

示例代码：

public class ForLoopDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("i = " + i);
        }
        // 输出：i=1, i=2, ..., i=5
    }
}

break与continue：

• break：立即终止整个循环。
• continue：跳过当前迭代，进入下一次循环。

public class ForBreakContinue {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 6) break; // 循环在i=6时终止
            if (i % 2 == 0) continue; // 跳过偶数
            System.out.println(i); // 输出1, 3, 5
        }
    }
}

2. while循环

适合不确定循环次数的场景，先判断条件再执行。

基本语法：

while (condition) {
    // 循环体
}

示例代码：

public class WhileDemo {
    public static void main(String[] args) {
        int count = 0;
        while (count < 3) {
            System.out.println("Count: " + count); // 输出0,1,2
            count++;
        }
    }
}

break与continue用法同for循环。

3. do-while循环

先执行一次循环体，再判断条件。

基本语法：

do {
    // 循环体
} while (condition);

示例代码：

public class DoWhileDemo {
    public static void main(String[] args) {
        int num = 5;
        do {
            System.out.println("Num: " + num); // 至少执行一次
            num--;
        } while (num > 0); // 输出5,4,3,2,1
    }
}

循环结构对比表

循环类型	特点	适用场景
for	初始化、条件、迭代集中	已知循环次数
while	先判断条件	不确定循环次数
do-while	至少执行一次	需要先执行再判断的场景

---

六、return语句

return用于从方法中返回结果（非void方法）或直接终止方法执行。

基本语法：

return value; // 返回指定值（非void方法）
return;       // 仅终止方法（void方法）

示例代码：

public class ReturnDemo {
    // 非void方法
    public static int add(int a, int b) {
        return a + b; // 返回计算结果
    }

    // void方法
    public static void greet() {
        System.out.println("Hello!");
        return; // 可省略
    }

    public static void main(String[] args) {
        System.out.println(add(3, 5)); // 输出8
        greet(); // 输出Hello!
    }
}

---

七、完整代码示例

以下是将所有知识点整合到一个完整的可执行Java代码中，包含表达式、语句、条件分支、循环和return语句的示例：

public class JavaBasicsDemo {

    // 示例方法：演示return语句
    public static int calculateSum(int a, int b) {
        return a + b; // 返回两数之和
    }

    // 示例方法：演示void方法中的return
    public static void printMessage(String msg) {
        if (msg == null) {
            System.out.println("Message is null!");
            return; // 提前终止方法
        }
        System.out.println("Message: " + msg);
    }

    public static void main(String[] args) {
        // 1. 表达式示例
        int x = 10;
        int y = 20;
        int arithmeticResult = x + y * 2; // 算术表达式
        boolean logicalResult = (x > 5) && (y < 30); // 逻辑表达式
        System.out.println("算术表达式结果: " + arithmeticResult);
        System.out.println("逻辑表达式结果: " + logicalResult);

        // 2. 语句块示例
        {
            int z = 30; // 局部变量，作用域仅在此块
            System.out.println("语句块内的z: " + z);
        }
        // System.out.println(z); // 编译错误：z未定义

        // 3. if条件分支
        int score = 85;
        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好"); // 输出"良好"
        } else {
            System.out.println("及格");
        }

        // 4. switch条件分支（带break）
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三"); // 输出"星期三"
                break;
            default:
                System.out.println("无效日期");
        }

        // 5. for循环（带break和continue）
        System.out.println("for循环示例:");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue; // 跳过本次循环
            }
            if (i == 5) {
                break; // 终止循环
            }
            System.out.println("i = " + i); // 输出1, 2, 4
        }

        // 6. while循环（带break）
        System.out.println("while循环示例:");
        int count = 0;
        while (count < 10) {
            if (count == 4) {
                break; // 当count=4时终止循环
            }
            System.out.println("count = " + count); // 输出0,1,2,3
            count++;
        }

        // 7. do-while循环
        System.out.println("do-while循环示例:");
        int num = 5;
        do {
            System.out.println("num = " + num); // 至少执行一次
            num--;
        } while (num > 0); // 输出5,4,3,2,1

        // 8. 调用演示return的方法
        int sum = calculateSum(15, 25);
        System.out.println("两数之和: " + sum);

        // 9. 调用void方法
        printMessage("Hello, Java!");
        printMessage(null); // 触发return提前终止

        // 10. 程序执行顺序演示
        System.out.println("程序开始");
        {
            System.out.println("语句块1");
            {
                System.out.println("嵌套语句块");
            }
        }
        System.out.println("程序结束");
    }
}

代码说明：

1. 表达式：演示了算术表达式和逻辑表达式的计算
2. 语句块：展示了局部变量的作用域限制
3. 条件分支 ：
   • if-else根据分数输出不同评价
   • switch根据日期输出星期几（演示break用法）
4. 循环结构 ：
   • for循环演示continue和break
   • while和do-while展示基本用法
5. return语句 ：
   • 在非void方法中返回计算结果
   • 在void方法中提前终止执行
6. 执行顺序：通过嵌套语句块展示从上到下的执行流程

预期输出：

算术表达式结果: 50
逻辑表达式结果: true
语句块内的z: 30
良好
星期三
for循环示例:
i = 1
i = 2
i = 4
while循环示例:
count = 0
count = 1
count = 2
count = 3
do-while循环示例:
num = 5
num = 4
num = 3
num = 2
num = 1
两数之和: 40
Message: Hello, Java!
Message is null!
程序开始
语句块1
嵌套语句块
程序结束

这个完整示例可以直接复制到Java开发环境中运行，涵盖了文章中提到的所有语法点，并通过实际输出验证代码逻辑。

总结

本文系统讲解了Java中表达式、语句、语句块的核心概念，并通过代码示例和表格对比了条件分支（if/switch）、循环结构（for/while/do-while）以及return语句的用法。掌握这些基础语法是编写高效Java程序的关键，建议通过实际编码练习加深理解。

关键点回顾：

1. 表达式计算值，语句执行操作，语句块定义作用域。
2. 条件分支通过if和switch实现多路径选择。
3. 循环结构中break终止循环，continue跳过当前迭代。
4. return用于返回结果或终止方法。

通过不断实践，你将能更灵活地运用这些语法构建复杂的逻辑。