闯荡 Java 世界（三）：学会“计算”和“决策”-CSDN博客

本文链接：https://blog.csdn.net/dongxiaod1/article/details/147938983

闯荡 Java 世界（三）：学会“计算”和“决策” ⚔️📊

欢迎回来，勇敢的 Java 探险家！在前两次的旅程中，我们搭建了营地（Java 环境），认识了装备（变量和数据类型）。今天，我们将学习如何运用这些装备来进行“计算”和“决策”，让我们的程序变得更加智能和灵活！

运算符：你的编程“工具箱” 🛠️

想象一下，你在探险中需要处理各种情况：计算距离、比较宝藏大小、判断方向…… 这时候，你就需要用到各种“工具”。在 Java 编程中，这些工具就是运算符。它们用来对数据进行操作。

算术运算符 (Arithmetic Operators) ➕➖✖️➗ %:
- +, -, *, /: 这些是最基本的加减乘除，和数学里的用法一样。
- %: 取模或取余数。当你需要知道一个数被另一个数整除后的余数时，就用它。如果余数为 0，说明是整除。
- ++, --: 自增 1 和 自减 1。这两种运算符非常常用，可以让变量的值加 1 或减 1。它们可以放在变量前面（前置）或后面（后置）。
  - 单独使用时：无论放在变量前还是后，效果都一样，就是让变量的值加 1 或减 1。
  - 被使用时（参与表达式运算）：在前在后就有区别了！
    - a++ (后置自增): 先使用变量 a 当前的值，然后 a 的值再加 1。
    - ++a (前置自增): 先让 a 的值加 1，然后使用 a 加 1 后的新值。
    - a-- (后置自减): 类似 a++，先使用 a 的值，再减 1。
    - --a (前置自减): 类似 ++a，先让 a 的值减 1，再使用新值。
      理解前置和后置的区别，是掌握 ++ 和 -- 的关键！多写几行代码试验一下，你会很快明白。
关系运算符 (Relational Operators) comparer :
- >, <, >=, <=: 大于、小于、大于等于、小于等于，用来比较两个数的大小。
- ==: 等于。注意，是两个等号，用来判断两个值是否相等。一个等号 = 是赋值运算符！
- !=: 不等于。
  关系运算的结果都是布尔值 (boolean)，也就是 true 或 false。 它们是进行“决策”的基础。
逻辑运算符 (Logical Operators) 🤔💡:
逻辑运算符建立在关系运算符的基础之上，用来连接多个布尔表达式，并产生一个新的布尔结果。
- &&: 短路与 (AND)。表示“并且”。只有当两边的条件都为 true 时，结果才为 true。如果第一个条件为 false，后面的条件就不会再判断了（发生短路）。 这是为了提高效率。
- ||: 短路或 (OR)。表示“或者”。只要两边的条件中有一个为 true，结果就为 true。如果第一个条件为 true，后面的条件就不会再判断了（发生短路）。 也是为了提高效率。
- !: 逻辑非 (NOT)。表示“取反”。如果条件为 true，结果就是 false；如果条件为 false，结果就是 true。
```
int age = 20;
double score = 85.5;
boolean isStudent = true;

// 逻辑与示例：判断是否是学生并且年龄小于 25
if (isStudent && age < 25) {
    System.out.println("是一名年轻的学生");
}

// 逻辑或示例：判断分数是否大于 90 或者年龄大于 30
if (score > 90 || age > 30) {
    System.out.println("分数很高或者年龄较大");
}

// 逻辑非示例：判断是否不是学生
if (!isStudent) {
    System.out.println("不是学生");
}
```
赋值运算符 (Assignment Operators) ➡️:
- =: 简单赋值运算符。用来将右边的值赋给左边的变量。
- +=, -=, *=, /=, %=: 扩展赋值运算符。它们是简化形式，例如 a += 5; 等同于 a = a + 5;。
  特别注意：扩展赋值运算符自带强制类型转换功能。 这意味着即使右边的表达式计算结果类型比左边的变量类型大，使用扩展赋值运算符也不会报错，系统会自动进行强制转换。
```
byte b = 10;
int i = 20;
// b = b + i; // 错误！b+i 的结果是 int，不能直接赋给 byte
b += i; // 正确！ += 自带强转，将 b+i 的结果强制转换为 byte 再赋值给 b
System.out.println(b); // 输出 30 (如果 int 值超出 byte 范围，会发生溢出)
```
字符串连接运算符 (String Concatenation Operator) 🔗:
- +: 当 + 运算符的两边任意一边出现了字符串时，它就不再是加法运算符了，而是用来将两边的内容连接起来，形成一个新的字符串。
  任何类型的数据与字符串连接，结果都会变成字符串类型。
```
int num = 10;
String text = "数字是: ";
System.out.println(text + num); // 输出 "数字是: 10"
System.out.println("计算结果: " + (5 + 3)); // 输出 "计算结果: 8"
System.out.println(5 + 3 + "计算结果"); // 输出 "8计算结果" (先计算 5+3，再和字符串连接)
```
条件运算符 (Conditional Operator) ❓:
- 语法：boolean ? 值1 : 值2
- 这是一种简洁的表达式，根据布尔条件的结果来选择返回两个值中的一个。
- 执行过程：
  1. 首先计算 boolean 表达式的值。
  2. 如果 boolean 为 true，整个表达式的值就是 值1。
  3. 如果 boolean 为 false，整个表达式的值就是 值2。
- 值1 和 值2 的类型需要兼容，并且整个条件运算会有一个确定的返回值。
```
int age = 18;
String status = age >= 18 ? "成年" : "未成年";
System.out.println("此人状态: " + status); // 输出 "此人状态: 成年"
```

分支结构：让程序学会“做选择” 🤔 branching:

在现实生活中，我们经常需要根据不同的情况做出不同的选择。比如，天气好就去公园，下雨就在家看书。在编程中，我们也需要让程序根据不同的条件执行不同的代码，这就是分支结构的作用。

if 结构：一条路 ➡️
最简单的分支结构，如果条件为 true，就执行一段代码；否则，什么也不做。

double price = 300.0;
if (price >= 500) { // 如果价格大于等于 500
    price *= 0.8; // 打八折
}
System.out.println("最终结算金额为: " + price); // 如果 price 小于 500，这里输出 300.0

在这里插入图片描述

if...else 结构：两条路 🛣️🛣️
当你有两种可能的选择时使用。如果 if 后面的条件为 true，执行 if 块里的代码；否则（条件为 false），执行 else 块里的代码。这两条路，程序只会走其中一条。

double price = 300.0;
if (price >= 500) { // 满 500
    price *= 0.8; // 打八折
} else { // 不满 500
    price *= 0.9; // 打九折
}
System.out.println("最终结算金额为: " + price); // 输出 270.0

在这里插入图片描述

另一个例子，判断成绩是否合法：
```java
double score = 95; // 带入不同的值测试：95, -5, 555
if (score >= 0 && score <= 100) { // 判断成绩是否在 0 到 100 之间
    System.out.println(score + " 是合法成绩");
} else {
    System.out.println(score + " 是不合法成绩");
}
```

if...else if...else 结构：多条路 🛣️🛣️🛣️…
当你有多个可能的选择时使用。程序会从上往下依次判断条件，只要找到第一个为 true 的条件，就执行对应的代码块，然后整个分支结构就结束了。如果所有 if 和 else if 的条件都为 false，就会执行最后的 else 块里的代码（如果存在 else 块的话）。
这多条路，程序只会走其中“一条”！

语法结构：
```
if (条件1) {
    代码块1
} else if (条件2) {
    代码块2
} else if (条件3) {
    代码块3
} else { // 可选的 else 块，当前面所有条件都为 false 时执行
    代码块4
}
```
执行过程：
1. 判断 条件1，如果为 true，执行 代码块1，然后结束。
2. 如果 条件1 为 false，判断 条件2，如果为 true，执行 代码块2，然后结束。
3. 如果 条件2 为 false，判断 条件3，如果为 true，执行 代码块3，然后结束。
4. 如果前面所有条件都为 false，执行 else 后面的 代码块4（如果存在的话），然后结束。
一个实际的例子： 根据购物金额计算折扣。
```
double price = 6000.0; // 带入不同的值测试：6000.0, 1000.0, 600.0, 300.0
if (price >= 2000) { // 满 2000 打 5 折
    price *= 0.5;
} else if (price >= 1000) { // 满 1000 不满 2000 打 7 折
    price *= 0.7;
} else if (price >= 500) { // 满 500 不满 1000 打 8 折
    price *= 0.8;
} else { // 不满 500 打 9 折
    price *= 0.9;
}
System.out.println("最终结算金额为: " + price);
```
仔细观察这个例子，因为条件是从大到小判断的，所以即使 price 很大，比如 6000，它会先满足 price >= 2000 的条件，执行打 5 折的代码，然后就跳出整个分支结构了。这正是我们期望的多选一的效果。