我们在前面的小节中，已经学习了变量和运算符。有了这些前置知识，我们就可以学习表达式、语句和块了。
运算符可用于构建表达式，表达式可以进行值的计算，它是语句的核心组成部分；而语句是指令式编程语言中最小的独立元素；多条语句又可以组成语句块。本小节我们将学习表达式的概念和常用分类，也将了解到什么是语句和块。

1. 表达式

1.1 概念

表达式，是由数字、运算符、数字分组符号（括号）、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合。约束变量是在表达式中已被指定数值，而自由变量则可以在表达式之外另行指定数值。

在 Java 中，表达式是根据 Java 语法由变量、运算符和方法调用组成的结构，表达式的结算结果为单个值。
表达式实例：

  1. public class Expression {
  2.       public static void main(String[] args) {
  3.           int a = 10, b = 20;
  4.           // (a + b) * 2 就是一个算数表达式
  5.           int c = (a + b) * 2;
  6.           // c > b 就是一个布尔表达式
  7.           if (c > b) { // if语句将在下一小节讲到，此处只需知道 c > b 是一个表达式即可
  8.               System.out.println("c大于b");
  9.         }
  10.     }
  11. }

上面代码中，(a + b) * 2 就是一个算数表达式，而 c > b 就是一个布尔表达式，代码中的 if 语句将在下一小节讲到，此处只需知道 c > b 是一个表达式即可。
下面我们将围绕算数表达式和布尔表达式来学习表达式。

1.2 分类

1.2.1 算数表达式

算数表达式是最常用的表达式，又称为数学表达式。它是通过算术运算符来进行运算的数学公式。
为了使用 Java 进行算数运算，首先必须至少声明一个变量。如下：

  1. int num = 10;

变量创建后，可以使用算数运算符（+、-、*、/、 %、++、 — ）来操作变量的值。使用算数表达式的实例如下：

  1. public class ArithmeticExpression1 {
  2.       public static void main(String[] args) {
  3.           int num = 10;
  4.           int result = num / 3;
  5.           System.out.println( num + " / 3 = " + result);
  6.     }
  7. }

编译执行程序，屏幕上将会打印：

  1. 10 / 3 = 3

对于操作数为整型的除法表达式，其计算结果将始终取整数部分。所以上面的 10 / 3 的结果等于 3。如果我们想得到小数，可以使用浮点类型的变量来作为操作数（10.0 / 3），其返回的值也是一个浮点型。
除了除法表达式之外，在使用自增 / 自减表达式运算的时候，也要额外注意前后自增 / 自减运算符的差别。我们来看下面一个实例：

  1. public class ArithmeticExpression2 {
  2.       public static void main(String[] args) {
  3.          // 前自增
  4.           System.out.println("------ 前自增 ------");
  5.         int num = 10;
  6.           System.out.println("++num = " + (++num));
  7.           System.out.println("num = " + num);
  8.           // 前自减
  9.         System.out.println("------ 前自减 ------");
  10.         num = 10;
  11.           System.out.println("--num = " + (--num));
  12.           System.out.println("num = " + num);
  14.           // 后自增
  15.         System.out.println("------ 后自增 ------");
  16.         num = 10;
  17.           System.out.println("num++ = " + (num ++));
  18.         System.out.println("num = " + num);
  19.           // 前自减
  20.           System.out.println("------ 前自减 ------");
  21.           num = 10;
  22.           System.out.println("num-- = " + (num --));
  23.         System.out.println("num = " + num);
  24.     }
  25. }

注意观察前后自增自减的区别，运行结果：

  1. ------ 前自增 ------
  2. ++num = 11
  3. num = 11
  4. ------ 前自减 ------
  5. --num = 9
  6. num = 9
  7. ------ 后自增 ------
  8. num++ = 10
  9. num = 11
  10. ------ 前自减 ------
  11. num-- = 10
  12. num = 9

结论：

  1. 前自增 / 自减的运算规则是：先进行自增或者自减运算，再进行表达式运算；
  2. 后自增 / 自减的运算规则是：先进行表达式运算，再进行自增或者自减运算。

    1.2.2 布尔表达式

    布尔表达式（Boolean expression）的结果只有 true（真）和 false（假）两个值。在 Java 语言中，布尔表达式可以使用关系运算符或逻辑运算符来代替算数运算符。
    我们来看一个使用关系运算符的实例：
    1. public class BooleanExpression1 {
    2.      public static void main(String[] args) {
    3.        // 初始化两个整型变量a、b，值分别为2、3
    4.        int a = 2, b = 3;
    5.        // 分别打印比较运算符比较的结果
    6.        System.out.println(a == b);
    7.        System.out.println(a != b);
    8.        System.out.println(a > b);
    9.        System.out.println(a < b);
    10.        System.out.println(a >= b);
    11.        System.out.println(a <= b);
    12.  }
    13. }
    请阅读上面代码，并算出每一次打印的结果。这里不再展示代码打印结果。
    布尔表达式常作为条件分支语句中的条件。因此下面的示例需要你对条件语句有一定的了解，我们再来看一个稍微复杂一些的实例：
    1. public class BooleanExpression2 {
    2.    public static void main(String[] args) {
    3.      // 初始化4个整型变量
    4.        int i = 4, j = 5, k = 7, m = 8;
    5.      // i > j && m < k++ 即为条件表达式
    6.        if(i > j && m < k++) {
    7.            k++;
    8.      } else {
    9.            k--;
    10.      }
    11.        System.out.println("k = " + k);
    12.  }
    13. }
    编译执行代码，屏幕上将会打印： ```java k = 6
  1. 上述代码，是使用逻辑运算符和算数运算符结合的布尔表达式示例，如果布尔表达式 i > j && m < k++ 结果为真，则执行 if 分支，k 自增 1，否则执行 else 分支，k 自减 1，最后打印出 k 的值。由于 i 的值小于 j，并且 && 运算符有**短路**作用，所以 m < k++ 不做运算，直接走到 else 分支，最后得到结果 k = 6。<br />这里再次强调一下逻辑运算符的短路：<br />在表达式中 (a && b)，如果 a 为假，则 b 不会被求值，因为无论如何表达式都会为假。<br />同理，在表达式中 (a || b)，如果 a 为真，则 b 不会被求值，因为无论如何表达式都会为真。<br />这就是我们所说的短路。如果想要取消短路，可以使用 & 代替 &&、使用 | 代替 ||，但是不建议这样写，会降低代码的可读性。<br />试想，如果将表达式中 i > j && m < k++ 的 && 改为 &，变量 k 的值将会是多少？
  2. <a name="EHtER"></a>
  3. ## 2. 语句
  4. 在计算机科学的编程中，一个语句是指令式编程语言中**最小的独立元素**，语句用以表达程序要执行的一些动作。多数语句是以高级语言编写成一个或多个语句的序列，用于命令计算机执行指定的一系列操作。<br />语句和自然语言（例如英语、汉语）中的句子大致相同。一条语句构成了完整的执行单元。通过使用英文分号（;）终止表达式，可以将以下类型的表达式制成语句：
  6. - 赋值表达式
  7. - 自增 / 自减 ++ 或 --
  8. - 方法调用
  9. - 对象创建表达式（面向对象部分将会学到）
  11. 请结合如下示例理解语句的概念：<br />变量声明语句：
  12. ```java
  13. int age;

赋值语句：

  1. age = 20;

自增语句：

  1. age ++;

方法调用语句：

  1. System.out.println（"Hello World! "）;

3. 块

块通常用来将两条或多条语句组合在一起，使其在格式上看更像一条语句。
一堆语句可以放在大括号中，以作为单个块执行。可以为此类语句命名或为其提供执行条件（下一节的条件判断将会讲到）。
下面是将一系列的语句放在一个块中的示例代码：

  1. {
  2.     int a = 1;
  3.     int b = 2;
  4.     int c = 3;
  5.     int result = a + b + c;
  6. }

4. 小结

本节我们学习了表达式，它的计算结果为单独的值。还要特别注意前后自增 / 自减的区别，要理解逻辑运算符在表达式中的短路作用，这在任何语言的基础面试中都会经常考到。对于语句和块的概念，我们也有了一个初步的认识，想要完全理解这些内容，还需要继续向下学习更多知识。下一小节开始，我们将学习 Java 条件语句、循环语句等内容，这些都将加深你对本节概念的理解。