【3.Java基础】Java运算符详解：从算数运算到逻辑判断，一篇文章全部掌握

文章目录

• 【3.Java基础】Java运算符详解：从算数运算到逻辑判断，一篇文章全部掌握
• • 导入语
  • 1 ~> 算术运算符
  • • 1.1 基本算术运算
    • 1.2 易错点：整除问题
    • 1.3 取余运算
  • 2 ~> 自增和自减运算符
  • • 2.1 `++` 和 `–`
    • 2.2 前置 vs 后置（初学者第一道坎）
    • 2.3 自增自减经典陷阱
  • 3 ~> 赋值运算符
  • • 3.1 基本赋值 `=`
    • 3.2 复合赋值运算符
    • 3.3 复合赋值自带强制转换
  • 4 ~> 比较运算符
  • • 4.1 六个比较运算符
    • 4.2 易错点：不要把 `==` 写成 `=`
  • 5 ~> 逻辑运算符
  • • 5.1 三个逻辑运算符
    • 5.2 短路特性
    • 5.3 逻辑运算符的真值表
  • 6 ~> 条件运算符（三元运算符）
  • • 6.1 三元运算符的语法
    • 6.2 实战案例
    • 6.3 三元运算符可以嵌套
  • 7 ~> 位运算符（初识）
  • 8 ~> 运算符优先级
  • • 8.1 Java 运算符优先级总表
    • 8.2 实战中的优先级问题
  • 9 ~> 表达式中的类型自动提升
  • 10 ~> 常见编译运行错误
  • 思考 && 总结
  • 结尾

【3.Java基础】Java运算符详解：从算数运算到逻辑判断，一篇文章全部掌握

📖 文章简介： 本文系统讲解Java中的六大类运算符：算术运算符（含自增自减的前置后置区别）、赋值运算符、比较运算符、逻辑运算符（含短路特性）、位运算符、以及三元运算符。每种运算符均附完整代码示例和运行结果，同时覆盖运算符优先级规则、表达式类型自动提升机制，以及自增陷阱、整除取整、浮点数相等判断、短路特性等初学高频踩坑点。文末附常见编译运行错误对照表，适合刚学完变量和类型的初学者快速建立起对Java运算符的完整认识。

🎬 个人主页： 源码骑士

❄ 专栏传送门： 《java编程练习题》《全栈开发》

⭐️热衷从源码视角拆解技术底层原理，将复杂架构讲得通俗易懂

🎬 源码骑士的简介： 5年Android Framework系统开发经验，曾主导多项系统级性能优化专项 技术栈覆盖Android系统全链路（Binder/Handler/AMS/WMS/启动流程）及Java后端全家桶（Spring + MyBatis + Redis + Oracle） 累计产出原创技术文章100+篇，文章以流程图为特色，被读者评价为"看一篇胜过啃一周源码"

导入语

变量你已经会声明了、类型你也搞懂了。下一步是什么？让这些变量动起来。

变量存了数据，接下来你要对数据做各种操作——加减乘除、比较大小、判断真假。这些操作靠的就是运算符。运算符是连接变量和逻辑的桥梁，没有了它，你写出来的代码就是一串安静的数字和文字，什么也干不了。

这篇文章的目标：把 Java 中所有常用的运算符掰开揉碎讲清楚。每一种运算符都跟着代码示例，每一个容易踩坑的地方都标出来。看完之后，运算符这一关就不会再卡住你。

1 ~> 算术运算符

1.1 基本算术运算

算术运算符就是对数值做加减乘除运算，跟数学课上学的一样：

public class ArithmeticDemo {
public static void main(String[] args) {
int a = 10;
int b = 3;

System.out.println("a + b = " + (a + b)); // 输出：13
System.out.println("a – b = " + (a – b)); // 输出：7
System.out.println("a * b = " + (a * b)); // 输出：30
System.out.println("a / b = " + (a / b)); // 输出：3
System.out.println("a % b = " + (a % b)); // 输出：1
}
}

1.2 易错点：整除问题

整数除以整数，结果还是整数（小数部分直接丢掉，不是四舍五入）。

System.out.println(5 / 2); // 输出：2（不是2.5！）
System.out.println(5.0 / 2); // 输出：2.5（浮点数参与 → 小数除法）
System.out.println((double)5/2); // 输出：2.5（强制转换其中一个操作数）

规则： 除号两边的操作数只要有一个是浮点数，就按小数除法算。全是整数就按整数除法算，结果直接截断小数部分。

1.3 取余运算

取余（%）就是求除法运算后剩下的"零头"：

System.out.println(10 % 3); // 输出：1（10 ÷ 3 = 3 余 1）
System.out.println(10 % 5); // 输出：0（整除，余数为0）
System.out.println(10 % –3); // 输出：1（Java中结果的正负号跟被除数一致）
System.out.println(–10 % 3); // 输出：-1

取余的一个常见用途：判断奇偶数 —— num % 2 == 0 就是偶数，num % 2 == 1 就是奇数。

2 ~> 自增和自减运算符

2.1 ++ 和 —

这两个运算符是编程语言独有的，数学课上学不到：

2.2 前置 vs 后置（初学者第一道坎）

自增自减运算符可以写在变量前面（前置），也可以写在后面（后置），但结果不同：

public class IncrementDemo {
public static void main(String[] args) {
int a = 5;

// 前置：先加再用
int b = ++a; // a 先自增为 6，然后赋给 b
System.out.println("a = " + a); // 输出：6
System.out.println("b = " + b); // 输出：6

// 后置：先用再加
int c = 5;
int d = c++; // 先把 c 的值 5 赋给 d，c 再自增为 6
System.out.println("c = " + c); // 输出：6
System.out.println("d = " + d); // 输出：5
}
}

对比记忆：

int x = 3;
int y = ++x; // 前置：x 变成 4，y = 4

int m = 3;
int n = m++; // 后置：n = 3，m 变成 4

2.3 自增自减经典陷阱

int i = 1;
i = i++; // ❌ 你以为 i = 2？实际结果 i = 1！
System.out.println(i); // 输出：1

原因分析： i = i++ 的执行过程是：

建议： 初学阶段不要把自增自减和赋值写在同一行里，分两行写清晰又不会踩坑。

3 ~> 赋值运算符

3.1 基本赋值 =

int age = 20; // 把 20 赋给变量 age
String name = "张三"; // 把 "张三" 赋给 name

3.2 复合赋值运算符

复合赋值就是把运算和赋值合二为一：

public class AssignmentDemo {
public static void main(String[] args) {
int num = 10;

num += 3; // num = 10 + 3 = 13
System.out.println("num += 3 → " + num);

num -= 5; // num = 13 – 5 = 8
System.out.println("num -= 5 → " + num);

num *= 2; // num = 8 * 2 = 16
System.out.println("num *= 2 → " + num);
}
}

3.3 复合赋值自带强制转换

short s = 10;
s = s + 1; // ❌ 编译报错：s + 1 结果是 int，不能直接赋给 short

short s2 = 10;
s2 += 1; // ✅ 编译通过：复合赋值自带强制转换

复合赋值运算符（+=、-= 等）内部会自动帮你做类型转换，所以 s2 += 1 不会报错而 s = s + 1 会。但建议不要依赖这个特性，类型匹配着写最安全。

4 ~> 比较运算符

4.1 六个比较运算符

比较运算符用来比较两个值的大小关系，运算结果是 boolean 类型（true 或 false）：

public class ComparisonDemo {
public static void main(String[] args) {
int score = 85;

boolean isPass = score >= 60; // true
boolean isExcellent = score >= 90; // false
boolean isFullMark = score == 100; // false

System.out.println("及格？" + isPass);
System.out.println("优秀？" + isExcellent);
System.out.println("满分？" + isFullMark);
}
}

4.2 易错点：不要把 == 写成 =

= 是赋值，== 是比较。这个错翻译过来就是"把B赋给A"和"A等于B吗"的混淆，初学者太常犯了。好在编译器一般能帮你检测出来：

int x = 10;
if (x == 5) { // ✅ 判断 x 是否等于 5
System.out.println("x = 5");
}

// if (x = 5) { } // ❌ 编译报错：= 的结果是 int，if 需要 boolean

另外，== 比较引用类型（如 String）时比较的是内存地址，不是内容。字符串内容比较用 .equals()，后面学到再细讲。

5 ~> 逻辑运算符

5.1 三个逻辑运算符

逻辑运算符用来连接多个 boolean 条件，运算结果也是 boolean：

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

// &&：两边都为真才为真
boolean canEnter = age >= 18 && hasTicket;
System.out.println("能进场？" + canEnter); // true

// ||：只要一边为真就为真
boolean isFreeOrVIP = age < 12 || age > 60;
System.out.println("免票或老年？" + isFreeOrVIP); // false

// !：取反
boolean isChild = !(age >= 18);
System.out.println("是未成年？" + isChild); // false
}
}

5.2 短路特性

&& 和 || 有一个重要特性叫短路：

• &&：如果左边是 false，右边根本不会执行（因为不管右边是什么，整个表达式都一定是 false）
• ||：如果左边是 true，右边根本不会执行（因为不管右边是什么，整个表达式都一定是 true）

public class ShortCircuitDemo {
public static void main(String[] args) {
int a = 5;

// 短路示例：
boolean result = (a < 3) && (a++ > 10);
System.out.println("a = " + a); // 输出：5（a++ 根本没执行！）

int b = 5;
boolean result2 = (b > 3) || (b++ > 10);
System.out.println("b = " + b); // 输出：5（b++ 根本没执行！）
}
}

利用短路特性的实战场景：

// 常见写法：先判空，再访问属性
if (user != null && user.getName().equals("admin")) {
// 如果 user 为 null，短路特性保证后面的 getName() 不会被执行
// 从而避免了 NullPointerException（空指针异常）
}

5.3 逻辑运算符的真值表

6 ~> 条件运算符（三元运算符）

6.1 三元运算符的语法

三元运算符是 Java 中唯一需要三个操作数的运算符：

条件 ? 值1 : 值2;

// 如果条件为 true，整个表达式的值是"值1"
// 如果条件为 false，整个表达式的值是"值2"

6.2 实战案例

public class TernaryDemo {
public static void main(String[] args) {

// 案例一：求最大值
int a = 10, b = 20;
int max = (a > b) ? a : b;
System.out.println("最大值：" + max); // 输出：20

// 案例二：判断成绩等级
int score = 75;
String grade = (score >= 60) ? "及格" : "不及格";
System.out.println("等级：" + grade); // 输出：及格

// 案例三：判断奇偶数
int num = 7;
String type = (num % 2 == 0) ? "偶数" : "奇数";
System.out.println(type); // 输出：奇数
}
}

6.3 三元运算符可以嵌套

int score = 85;
String grade = (score >= 90) ? "优秀" : (score >= 60) ? "及格" : "不及格";
System.out.println(grade); // 输出：及格

建议： 嵌套一层还可以接受，嵌套两层以上就该换成 if-else 语句了。三元运算符的定位是简洁地表达二选一，不是取代 if-else。

7 ~> 位运算符（初识）

位运算符直接对整数的二进制位进行操作。初学阶段知道有这个东西即可，学 Android Framework 底层解析标志位时经常会用到。

System.out.println(5 & 3); // 输出：1
System.out.println(5 | 3); // 输出：7
System.out.println(5 << 1); // 输出：10（5 × 2¹ = 10）
System.out.println(5 << 2); // 输出：20（5 × 2² = 20）

8 ~> 运算符优先级

8.1 Java 运算符优先级总表

当一行代码里出现多个运算符时，谁先算谁后算？这就是优先级问题。

8.2 实战中的优先级问题

System.out.println(5 + 3 * 2); // 输出：11（先乘后加，等价于 5 + 6）
System.out.println((5 + 3) * 2); // 输出：16（括号改变优先级）
System.out.println(10 > 5 && 3 < 1); // 输出：false（先比较再逻辑运算）

// 不加括号可能翻车的写法：
boolean flag = true || false && false;
// 实际执行顺序：true || (false && false)
// 结果: true

记住一条原则：不确定优先级的时候，加括号。 多打两个括号不会让代码变慢，但会让你和看代码的人都省去猜优先级的功夫。

9 ~> 表达式中的类型自动提升

当表达式中混用了不同类型的数据，Java 会自动把小类型提升为大类型：

public class TypePromotionDemo {
public static void main(String[] args) {
// byte / short / char 参与运算时自动提升为 int
byte b1 = 10;
byte b2 = 20;
int sum = b1 + b2; // byte + byte → int

// int 和 double 混合运算，int 自动提升为 double
int count = 10;
double price = 9.9;
double total = count * price; // int * double → double
System.out.println(total); // 输出：99.0

// 字符串拼接优先级
System.out.println("结果：" + 10 + 20); // 输出：结果：1020
System.out.println("结果：" + (10 + 20)); // 输出：结果：30
System.out.println(10 + 20 + "是结果"); // 输出：30是结果
}
}

特别注意字符串拼接： + 遇到 String 时不再做加法运算，而是做字符串拼接。"结果：" + 10 + 20 是先把 10 拼成 "结果：10"，再把 20 拼成 "结果：1020"。要避免这种 bug，加括号就行。

10 ~> 常见编译运行错误

思考 && 总结

本文覆盖了 Java 中六大类运算符，核心要点总结如下：

运算符讲完了，接下来要学的是"流程控制"——条件判断（if-else）和循环（for/while）。有了变量、数据类型、运算符，再配上流程控制，你就能写出真正有逻辑的程序了。

结尾

各位小伙伴，本文的内容到这里就全部结束了，源码骑士在这里再次感谢您的阅读！

源码骑士 — Android Framework & 全栈开发

👀 关注：跟博主一起从源码视角深耕底层原理，见证每一次成长

❤️ 点赞：让优质内容被更多人看见，让知识传递更有力量

⭐ 收藏：把核心知识点存好，在需要时随时查、随时用

💬 评论：分享你的经验或疑问，评论区一起交流避坑

🔄 一键四连：不要忘记给博主"一键四连"哦！今日源码拆解达成！

🗡️ 寄语：技术之路难免有困惑，但同行的人会让前进更有方向

结语：希望对学习 Java 运算符的小伙伴有所帮助，接下来要进入流程控制啦！不要忘记给博主"一键四连"哦！

往期回顾：

【1.Java基础】Java初识：从零搭建开发环境到写出第一个HelloWorld

【1.1Java基础】JDK安装常见问题教辅-从踩坑到排雷

【1.2Java基础】Win10环境变量配置详解-从原理到排雷

【2.Java基础】Java常量与变量-从基本类型到类型转换全面掌握