Java 编程：变量、运算符、表达式与决策循环

1. Java 变量、运算符与表达式基础

在 Java 编程中，变量、运算符和表达式是基础且关键的部分。

1.1 运算符

• 自增运算符 ： myVariable ++; 与之前较为冗长的代码效果相同，它是一种快速将变量值加 1 的方式。
• 自减运算符 ： -- 为自减运算符，用于快速将变量值减 1。例如， myVariable = myVariable - 1; 等同于 myVariable --; 。

虽然这些运算符有正式的名称，但这里给出的名称更便于学习 Java。Java 中还有更多的运算符，后续会在决策相关内容中进一步接触。若想了解完整的运算符列表，可访问 Java 官网 。

1.2 表达式

当我们将声明、赋值和运算符等元素组合成有意义的语法时，就形成了表达式。下面通过一个示例应用来实践这些内容。

创建示例应用步骤 ：
1. 创建一个名为 “Expressing Yourself” 的新项目，使用基本活动模板，其他设置保持默认。
2. 切换到编辑器中的 MainActivity 选项卡，在 onCreate 方法的结束花括号 } 之前添加以下代码：

int numMessages;

当开始输入 nu... 时，Android Studio 会弹出提示，第一个选项即为 numMessages 。我们可以左键点击它自动完成变量名输入，也可以直接按回车键选择。接着使用自动完成功能添加代码：

numMessages = 10;

然后在上述代码之后、 onCreate 方法结束花括号之前添加以下代码：

// Output the value of numMessages
Log.i("numMessages = ", "" + numMessages);
numMessages++;
numMessages = numMessages + 1;
Log.i("numMessages = ", "" + numMessages);
// Now a boolean (just true or false)
boolean isFriend = true;
Log.i("isFriend = ", "" + isFriend);
// A contact and an important message
String contact = "James Gosling";
String message = "Dear reader, I invented Java.";
// Now let's play with those String variables
Toast.makeText(this, "Message from " + contact, Toast.LENGTH_SHORT).show();
Toast.makeText(this, "Message is:" + message, Toast.LENGTH_SHORT).show();

运行该应用后，在日志窗口会看到如下输出：

numMessages =﹕ 10
numMessages =﹕ 12
isFriend =﹕ true

屏幕上会弹出两条 Toast 消息，第一条显示 “Message from James Gosling”，第二条显示 “Message is: Dear Reader, I invented Java.”。

下面逐步分析代码：
- 首先声明并初始化了一个 int 类型的变量 numMessages ：

int numMessages;
numMessages = 10;

• 然后使用 Log 输出 numMessages 的值，通过 + 运算符将变量添加到输出中：

// Output the value of numMessages
Log.i("numMessages = ", "" + numMessages);

• 接着使用 ++ 运算符将 numMessages 的值加 1，再通过 +1 操作再次增加其值，并输出新值：

numMessages ++;
numMessages = numMessages + 1;
Log.i("numMessages = ", "" + numMessages);

• 之后创建了一个 boolean 类型的变量 isFriend 并输出其值：

// Now a boolean (just true or false)
boolean isFriend = true;
Log.i("isFriend = ", "" + isFriend);

• 最后声明并初始化了两个 String 类型的变量 contact 和 message ，并使用 Toast 输出它们的值。当将两个字符串相加形成一个更长的字符串时，这一操作称为字符串拼接：

// A contact and an important message
String contact = "James Gosling";
String message = "Dear reader, I invented Java.";
// Now let's play with those String variables
Toast.makeText(this, "Message from " + contact, Toast.LENGTH_SHORT).show();
Toast.makeText(this, "Message is:" + message, Toast.LENGTH_SHORT).show();

通过这个示例，我们学会了声明变量、初始化变量值、修改变量值以及使用 Toast 或 Log 输出变量值。

2. Java 决策与循环

在 Java 编程中，我们常常需要根据变量的值来采取不同的行动，这就涉及到决策和循环的内容。

2.1 代码缩进

随着代码复杂度的增加，为了使代码更易读，代码缩进是一个很好的习惯。虽然代码缩进不是 Java 语法的一部分，即使不进行缩进代码也能编译，但它有助于保持代码的结构和含义清晰。例如， MainActivity 类内部的第一行代码通常缩进一个制表符，每个方法内部的第一行代码也会进行缩进。当缩进块结束时，结束花括号 } 的缩进程度与开始该块的代码行相同。

2.2 更多运算符

除了前面介绍的运算符，Java 中还有一些用于比较和逻辑判断的运算符，这些运算符用于创建布尔表达式（结果为 true 或 false ）。以下是这些运算符及其示例：
| 运算符 | 描述 | 示例 |
| ---- | ---- | ---- |
| == | 比较运算符，用于测试相等性 | (10 == 9) 为 false ， (2 + 2 == 4) 为 true |
| ! | 逻辑非运算符，用于测试表达式的否定 | !(2 + 2 == 5) 为 true ， !(2 + 2 == 4) 为 false |
| != | 不等于运算符，用于测试不相等性 | (10 != 9) 为 true ， (10 != 10) 为 false |
| > | 大于运算符，用于测试一个值是否大于另一个值 | (10 > 9) 为 true ， (9 > 10) 为 false |
| < | 小于运算符，用于测试一个值是否小于另一个值 | (10 < 9) 为 false ， (9 < 10) 为 true |
| >= | 大于等于运算符，用于测试一个值是否大于或等于另一个值 | (10 >= 9) 为 true ， (10 >= 10) 为 true ， (10 >= 11) 为 false |
| <= | 小于等于运算符，用于测试一个值是否小于或等于另一个值 | (10 <= 9) 为 false ， (10 <= 10) 为 true ， (10 <= 11) 为 true |
| && | 逻辑与运算符，用于测试表达式的所有部分是否都为 true | ((10 > 9) && (10 < 11)) 为 true ， ((10 > 9) && (10 < 9)) 为 false |
| || | 逻辑或运算符，用于测试表达式的至少一个部分是否为 true | ((10 > 9) || (10 < 9)) 为 true |

这些运算符在实际应用中会更加清晰，下面通过一个假设的军事场景来展示如何使用这些运算符进行决策。

2.3 使用 if 关键字进行决策

假设一位船长在临终前为部队编写了一个 Java 程序来传达最后的命令。部队需要在等待增援时守住桥的一侧，并且有一些规则来决定他们的行动。

首先，船长的第一个命令是：如果敌人过桥，就射击他们。在 Java 中，我们可以使用布尔变量 isComingOverBridge 来模拟这种情况：

if(isComingOverBridge){
    // Shoot them
}

如果 isComingOverBridge 为 true ，则花括号内的代码将执行；如果为 false ，程序将跳过该块继续执行。

船长还想告诉部队如果敌人不过桥该怎么做，此时可以使用 else 关键字：

if(isComingOverBridge){
    // Shoot them
}else{
    // Hold position
}

后来，船长意识到情况更复杂。如果敌人过桥但兵力过多，部队可能会被击败。于是他编写了以下代码：

boolean isComingOverBridge;
int enemyTroops;
int friendlyTroops;
// Code that initializes the above variables one way or another
// Now the if
if(isComingOverBridge && friendlyTroops > enemyTroops){
    // shoot them
}else if(isComingOverBridge && friendlyTroops < enemyTroops) {
    // blow the bridge
}else{
    // Hold position
}

这段代码有三种可能的执行路径：
1. 如果敌人过桥且友军兵力更多，执行 if 块内的代码。
2. 如果敌人过桥但友军兵力更少，执行 else if 块内的代码。
3. 如果以上条件都不满足，执行 else 块内的代码。

不过，这段代码存在一个问题，即没有明确处理敌军和友军兵力相等的情况。可以将第一个 if 语句修改为 if(isComingOverBridge && friendlyTroops >= enemyTroops) 来解决这个问题。

最后，船长担心如果敌人举着白旗过桥却被屠杀，部队会成为战犯。他使用 wavingWhiteFlag 布尔变量进行判断，并采用嵌套的 if-else 语句：

if (!wavingWhiteFlag){
    // not surrendering so check everything else
    if(isComingOverTheBridge && friendlyTroops >= enemyTroops){
        // shoot them
    }else if(isComingOverTheBridge && friendlyTroops < enemyTroops) {
        // blow the bridge
    }
}else{
    // this is the else for our first if
    // Take prisoners
}
// Holding position

通过这些示例，我们看到可以通过嵌套 if 和 else 语句来创建复杂而详细的决策逻辑。

下面是一个简单的流程图，展示上述军事场景的决策过程：

graph TD;
    A[敌人是否过桥?] -->|是| B[是否举白旗?];
    A -->|否| C[部队坚守];
    B -->|是| D[俘虏敌人];
    B -->|否| E[友军兵力是否更多?];
    E -->|是| F[射击敌人];
    E -->|否| G[炸毁桥梁];

通过以上内容，我们对 Java 中的变量、运算符、表达式以及决策逻辑有了更深入的理解。在实际编程中，合理运用这些知识可以编写出更加灵活和智能的程序。

3. switch 语句决策

除了使用 if-else 语句进行决策，Java 还提供了 switch 语句，它可以根据一个变量的不同取值执行不同的代码块。 switch 语句通常用于处理多个固定值的情况。

下面是一个简单的 switch 语句示例，假设我们要根据一周的不同天数输出不同的信息：

int day = 3;
switch (day) {
    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("输入的天数无效。");
}

在这个示例中， switch 语句根据变量 day 的值进行匹配。如果 day 的值等于某个 case 后面的值，就会执行该 case 下的代码块。 break 语句用于跳出 switch 语句，防止继续执行下一个 case 的代码。如果 day 的值与所有 case 都不匹配，则会执行 default 下的代码。

以下是 switch 语句的执行流程表格：
| 步骤 | 描述 |
| ---- | ---- |
| 1 | 计算 switch 后面括号内表达式的值。 |
| 2 | 将该值与各个 case 后面的值进行比较。 |
| 3 | 如果匹配到某个 case ，执行该 case 下的代码块，直到遇到 break 语句跳出 switch 。 |
| 4 | 如果没有匹配到任何 case ，执行 default 下的代码块（如果有）。 |

4. Java 循环结构

在 Java 编程中，循环结构用于重复执行一段代码，直到满足特定条件为止。常见的循环结构有 while 循环、 do-while 循环和 for 循环。

4.1 while 循环

while 循环在每次执行循环体之前都会检查一个条件。如果条件为 true ，则执行循环体；如果条件为 false ，则跳过循环体。

下面是一个简单的 while 循环示例，用于计算 1 到 10 的整数之和：

int sum = 0;
int i = 1;
while (i <= 10) {
    sum += i;
    i++;
}
System.out.println("1 到 10 的整数之和为：" + sum);

在这个示例中， while 循环会不断检查 i <= 10 这个条件。只要条件为 true ，就会执行循环体中的代码，将 i 的值累加到 sum 中，并将 i 的值加 1。当 i 的值大于 10 时，条件为 false ，循环结束。

while 循环的执行流程可以用以下流程图表示：

graph TD;
    A[开始] --> B{条件是否为 true?};
    B -->|是| C[执行循环体];
    C --> D[更新条件变量];
    D --> B;
    B -->|否| E[结束循环];

4.2 do-while 循环

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

下面是一个使用 do-while 循环的示例，同样用于计算 1 到 10 的整数之和：

int sum = 0;
int i = 1;
do {
    sum += i;
    i++;
} while (i <= 10);
System.out.println("1 到 10 的整数之和为：" + sum);

在这个示例中， do-while 循环会先执行一次循环体，将 i 的值累加到 sum 中，并将 i 的值加 1。然后检查 i <= 10 这个条件，如果条件为 true ，则继续执行循环体；如果条件为 false ，则结束循环。

do-while 循环的执行流程表格如下：
| 步骤 | 描述 |
| ---- | ---- |
| 1 | 执行循环体。 |
| 2 | 检查条件。如果条件为 true ，返回步骤 1 继续执行循环体；如果条件为 false ，结束循环。 |

4.3 for 循环

for 循环通常用于已知循环次数的情况。它的语法结构更加紧凑，包含了初始化、条件判断和更新三个部分。

下面是一个使用 for 循环计算 1 到 10 的整数之和的示例：

int sum = 0;
for (int i = 1; i <= 10; i++) {
    sum += i;
}
System.out.println("1 到 10 的整数之和为：" + sum);

在这个示例中， for 循环的初始化部分 int i = 1 会在循环开始前执行一次，用于初始化循环变量 i 。条件判断部分 i <= 10 会在每次循环开始前检查，如果条件为 true ，则执行循环体；如果条件为 false ，则结束循环。更新部分 i++ 会在每次循环体执行完毕后执行，用于更新循环变量的值。

for 循环的执行流程可以用以下流程图表示：

graph TD;
    A[初始化循环变量] --> B{条件是否为 true?};
    B -->|是| C[执行循环体];
    C --> D[更新循环变量];
    D --> B;
    B -->|否| E[结束循环];

5. 循环控制语句

在循环中，有时我们需要提前结束循环或者跳过某次循环的执行。Java 提供了 break 和 continue 两个关键字来实现这些功能。

5.1 break 语句

break 语句用于立即终止当前所在的循环。当在循环体中遇到 break 语句时，循环会立即结束，程序会继续执行循环后面的代码。

下面是一个使用 break 语句的示例，当 i 的值等于 5 时，终止循环：

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

在这个示例中，当 i 的值等于 5 时， if 条件为 true ，执行 break 语句，循环立即结束。因此，程序只会输出 1 到 4 的值。

5.2 continue 语句

continue 语句用于跳过当前循环的剩余部分，直接进入下一次循环。当在循环体中遇到 continue 语句时，程序会跳过本次循环中 continue 语句后面的代码，直接进入下一次循环的条件判断。

下面是一个使用 continue 语句的示例，当 i 的值为偶数时，跳过本次循环：

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

在这个示例中，当 i 的值为偶数时， if 条件为 true ，执行 continue 语句，跳过本次循环中 continue 语句后面的 System.out.println(i); 代码，直接进入下一次循环。因此，程序只会输出 1、3、5、7、9 的值。

通过合理运用循环结构和循环控制语句，我们可以更高效地处理重复性的任务，实现复杂的程序逻辑。在实际编程中，需要根据具体的需求选择合适的循环结构和控制语句，以达到最佳的编程效果。