【Java SE 基础学习打卡】20 运算符（下）

目录

• 前言
• [一、关系运算符：给数据做 "比较"，返回 "是 / 否"](#一、关系运算符：给数据做 “比较”，返回 “是 / 否”)
• [二、逻辑运算符：组合多个条件，做 "复杂判断"](#二、逻辑运算符：组合多个条件，做 “复杂判断”)
• • [2.1 短路与（`&&`）：两个条件 "都满足" 才成立](#2.1 短路与（&&）：两个条件 “都满足” 才成立)
  • [2.2 短路或（`||`）：两个条件 "满足一个" 就成立](#2.2 短路或（||）：两个条件 “满足一个” 就成立)
  • [2.3 非（`!`）：把条件 "反过来"](#2.3 非（!）：把条件 “反过来”)
  • [2.4 异或（`^`）：两个条件 "不一样" 才成立](#2.4 异或（^）：两个条件 “不一样” 才成立)
  • [2.5 逻辑运算符避坑重点](#2.5 逻辑运算符避坑重点)
• [三、三元运算符：一句话搞定 "二选一" 赋值](#三、三元运算符：一句话搞定 “二选一” 赋值)
• • [3.1 语法格式（记牢！）](#3.1 语法格式（记牢！）)
  • [3.2 代码示例（3 个实用场景）](#3.2 代码示例（3 个实用场景）)
  • • [场景 1：求两个数的最大值](#场景 1：求两个数的最大值)
    • [场景 2：判断成绩是否及格](#场景 2：判断成绩是否及格)
    • [场景 3：判断是否为成年人](#场景 3：判断是否为成年人)
  • [3.3 避坑提醒（2 个关键）](#3.3 避坑提醒（2 个关键）)
• 总结

前言

上一节咱们学了赋值和自增自减运算符，能给变量存值、让变量自己变了。但写代码光做这些还不够，咱们还得让程序像人一样 "做判断"------ 比如 "成绩是否及格""年龄够不够 18 岁""满足两个条件才能执行下一步"。这些判断就得靠关系、逻辑和三元运算符来实现，它们是写条件判断、循环代码的核心。这一节咱们就把这三类运算符讲透，全程用生活例子 + 代码演示，保证你看完就能用！

一、关系运算符：给数据做 "比较"，返回 "是 / 否"

关系运算符的作用很直接：比较两个数据的关系（比如谁大、谁小、是否相等），最后返回一个布尔值 ------true（是）或false（否）。就像生活中 "比身高""比分数"，结果只有两种可能。

Java 里有 6 种关系运算符，咱们一个个学，结合例子更易理解：

运算符	作用	生活场景类比
>	大于	小明身高 > 小红身高？
>=	大于等于	成绩 >= 60 分？（及格）
<	小于	年龄 < 18 岁？（未成年）
<=	小于等于	体重 <= 60kg？
==	等于	我的钱 == 你的钱？
!=	不等于	性别！= 男？

代码示例（逐个演示）：

public static void main(String[] args) {
    int score = 85;
    int age = 20;
    float weight = 58.5f;

    // 1. >：大于
    boolean isScoreOver80 = score > 80; // 85>80 → true
    System.out.println(isScoreOver80); // 输出true

    // 2. >=：大于等于（包含等于）
    boolean isPass = score >= 60; // 85>=60 → true
    System.out.println(isPass); // 输出true

    // 3. <：小于
    boolean isTeenager = age < 18; // 20<18 → false
    System.out.println(isTeenager); // 输出false

    // 4. <=：小于等于（包含等于）
    boolean isWeightOk = weight <= 60; // 58.5<=60 → true
    System.out.println(isWeightOk); // 输出true

    // 5. ==：等于（两个等号！别和赋值=搞混）
    boolean isScoreEqual85 = score == 85; // 85==85 → true
    boolean isAgeEqual20 = age == 20; // 20==20 → true
    System.out.println(isScoreEqual85); // 输出true

    // 6. !=：不等于
    boolean isAgeNot18 = age != 18; // 20!=18 → true
    System.out.println(isAgeNot18); // 输出true
}

新手必避坑（3 个关键提醒）

1. 别把==和=搞混 ：==是 "比较是否相等"，=是 "赋值"。比如age == 18是判断年龄是不是 18，age = 18是把 18 赋给 age，完全两回事；

2. 数值类型比较时，类型不同也能比 ：比如int a = 5和float b = 5.0f，a == b的结果是true（值相等即可）；

3. 关系运算符的结果是布尔值 ：只能用boolean类型变量接收，比如boolean result = 3 > 5;，不能用int接收（比如int result = 3 > 5;会报错）。

二、逻辑运算符：组合多个条件，做 "复杂判断"

关系运算符只能做 "单个判断"，但现实中常需要 "多个条件同时满足" 或 "满足一个就行"------ 比如 "年龄 18+ 并且 有身份证" 才能办卡，"成绩 90+ 或者 竞赛获奖" 才能拿奖学金。这些 "组合判断" 就靠逻辑运算符。

逻辑运算符的操作数是 "布尔值（true/false）"，结果也是布尔值。Java 里有 6 种，重点掌握前 4 种（最常用）：

运算符	名称	核心规则	推荐度
&&	短路与	两个条件都为 true，结果才是 true；左边为 false，右边不计算	强烈推荐
&	与	两个条件都为 true，结果才是 true；不管左边是什么，右边都计算	不推荐
`		`	短路或
`	`	或	至少一个条件为 true，结果就是 true；不管左边是什么，右边都计算
!	非	条件取反（true 变 false，false 变 true）	常用
^	异或	两个条件不一样（一个 true 一个 false），结果才是 true	少用

2.1 短路与（&&）：两个条件 "都满足" 才成立

核心规则 ：左边条件为false，右边直接不看（短路），结果为false；只有左边为true，才会看右边，都为true才返回true。

生活例子："年满 18 岁 并且 有身份证" 才能办理银行卡。

public static void main(String[] args) {
    int age = 20;
    boolean hasIDCard = true;

    // 两个条件都满足 → true
    boolean canApplyCard = (age >= 18) && hasIDCard;
    System.out.println(canApplyCard); // 输出true

    // 左边条件不满足（age<18），右边不计算，直接返回false
    int age2 = 17;
    boolean canApplyCard2 = (age2 >= 18) && hasIDCard;
    System.out.println(canApplyCard2); // 输出false
}

为什么推荐&&？ 能避免无用计算或报错。比如右边是 "除以 0" 这种危险操作，左边为false时右边不执行，不会报错：

int num = 0;
// 左边5>10是false，右边10/num不执行，避免报错
boolean safe = (5 > 10) && (10 / num > 1);
System.out.println(safe); // 输出false（安全无报错）

2.2 短路或（||）：两个条件 "满足一个" 就成立

核心规则 ：左边条件为true，右边直接不看（短路），结果为true；只有左边为false，才会看右边，都为false才返回false。

生活例子："成绩 90+ 或者 竞赛获奖" 就能获得奖学金。

public static void main(String[] args) {
    int score = 85;
    boolean isCompetitionWinner = true;

    // 左边不满足（85<90），看右边；右边满足 → true
    boolean canGetScholarship = (score >= 90) || isCompetitionWinner;
    System.out.println(canGetScholarship); // 输出true

    // 左边满足（95>=90），右边不计算，直接返回true
    int score2 = 95;
    boolean canGetScholarship2 = (score2 >= 90) || isCompetitionWinner;
    System.out.println(canGetScholarship2); // 输出true
}

2.3 非（!）：把条件 "反过来"

核心规则 ：对一个布尔值取反，!true = false，!false = true。

生活例子："不下雨" 就去野餐（即 "下雨" 的反面）。

public static void main(String[] args) {
    boolean isRain = false;
    boolean canPicnic = !isRain; // !false = true
    System.out.println(canPicnic); // 输出true

    boolean isPass = true;
    boolean isFail = !isPass; // !true = false
    System.out.println(isFail); // 输出false
}

2.4 异或（^）：两个条件 "不一样" 才成立

核心规则 ：两个条件一个true、一个false，结果为true；两个都true或都false，结果为false（实际用得少，了解即可）。

public static void main(String[] args) {
    boolean a = true;
    boolean b = false;
    boolean result = a ^ b; // true和false不一样 → true
    System.out.println(result); // 输出true

    boolean c = true;
    boolean d = true;
    boolean result2 = c ^ d; // 两个都true → false
    System.out.println(result2); // 输出false
}

2.5 逻辑运算符避坑重点

1. 优先用短路版（&&/||） ：比非短路版（&/|）高效，还能避免潜在错误；

2. 逻辑运算符的操作数必须是布尔值 ：比如3 && 5是错误的（3 和 5 是 int，不是布尔值），必须写成(3 > 0) && (5 > 0)；

3. 组合多个条件时加括号 ：比如(age >=18 && hasIDCard) || isVIP，明确优先级，避免歧义。

三、三元运算符：一句话搞定 "二选一" 赋值

有时候我们需要 "根据条件给变量赋不同的值"------ 比如 "成绩 >=60 分，赋值'及格'，否则赋值'不及格'""a>b，赋值 a，否则赋值 b"。这种简单的 "二选一"，用三元运算符能一句话搞定，比 if-else 简洁多了。

3.1 语法格式（记牢！）

变量 = 条件 ? 值1 : 值2;

• 先判断 "条件" 是否成立（条件是关系 / 逻辑表达式，结果为 true/false）；

• 条件为true：变量赋值为 "值 1"；

• 条件为false：变量赋值为 "值 2"。

3.2 代码示例（3 个实用场景）

场景 1：求两个数的最大值

public static void main(String[] args) {
    int a = 15;
    int b = 25;
    // 条件a>b？成立赋a，否则赋b
    int max = (a > b) ? a : b;
    System.out.println(max); // 输出25
}

场景 2：判断成绩是否及格

public static void main(String[] args) {
    int score = 58;
    // 条件score>=60？成立赋"及格"，否则赋"不及格"
    String result = (score >= 60) ? "及格" : "不及格";
    System.out.println(result); // 输出"不及格"
}

场景 3：判断是否为成年人

public static void main(String[] args) {
    int age = 17;
    String status = (age >= 18) ? "成年人" : "未成年人";
    System.out.println(status); // 输出"未成年人"
}

3.3 避坑提醒（2 个关键）

1. 值 1 和值 2 的类型要兼容：比如不能一个是 int（10），一个是 String（"十"），否则编译报错；

2. 只用于简单的二选一 ：如果条件复杂（比如多个分支），别硬用三元运算符，用 if-else 更清晰。比如(a>b) ? a : (b>c) ? b : c（嵌套三元），可读性差，不推荐。

总结

学完这一节，你已经掌握了 Java 里核心的判断类运算符，记住 3 个核心点：

1. 关系运算符：比较两个数据，返回 true/false（重点区分==和=）；

2. 逻辑运算符：组合多个条件（优先用&&/||），做复杂判断；

3. 三元运算符：简单二选一赋值，语法是 "条件？值 1: 值 2"，简洁高效。

这些运算符是写条件判断（if）、循环（for/while）的基础，现在就动手练一练吧 ------ 比如用关系 + 逻辑运算符判断 "是否能报考驾照"（年龄 >=18 并且 不是色盲），用三元运算符求三个数的最小值，很快就能熟练掌握！