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

码云骑士2026-06-10 8:36

文章目录

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

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

运算符 含义 示例 结果
+ 加法 5 + 3 8
- 减法 5 - 3 2
* 乘法 5 * 3 15
/ 除法 5 / 2 2（不是2.5！）
% 取余（求模） 5 % 2 1（5除以2余1）
java 复制代码 
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 易错点：整除问题

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

java 复制代码 
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 取余运算

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

java 复制代码 
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 ++ 和 --

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

运算符 含义 示例 等价于
++ 自增，让变量加 1 a++ 或 ++a a = a + 1
-- 自减，让变量减 1 a-- 或 --a a = a - 1

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

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

写法 规则 一句话
++a（前置） 先加再用 先给 a 加 1，再用 a 的值
a++（后置） 先用再加 先用 a 的值，再给 a 加 1
java 复制代码 
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
    }
}

对比记忆：

java 复制代码 
int x = 3;
int y = ++x;   // 前置：x 变成 4，y = 4

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

2.3 自增自减经典陷阱

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

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

  1. 先把 i 当前的值（1）压入临时存储区
  2. i 自增为 2
  3. 赋值 i = 临时存储区的值（1）
  4. 最终 i 又变回了 1

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

3 ~> 赋值运算符

3.1 基本赋值 =

java 复制代码 
int age = 20;          // 把 20 赋给变量 age
String name = "张三";   // 把 "张三" 赋给 name

3.2 复合赋值运算符

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

写法 等价于 示例（设 a = 10）
a += 5 a = a + 5 a 变成 15
a -= 5 a = a - 5 a 变成 5
a *= 5 a = a * 5 a 变成 50
a /= 5 a = a / 5 a 变成 2
a %= 5 a = a % 5 a 变成 0
java 复制代码 
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 复合赋值自带强制转换

java 复制代码 
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）：

运算符 含义 示例（设 a=5, b=3） 结果
== 等于 a == b false
!= 不等于 a != b true
> 大于 a > b true
< 小于 a < b false
>= 大于等于 a >= 5 true
<= 小于等于 a <= 4 false
java 复制代码 
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吗"的混淆，初学者太常犯了。好在编译器一般能帮你检测出来：

java 复制代码 
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：

运算符 含义 规则
&& 与（AND） 两边都是 true，结果才为 true
` `
! 非（NOT） 取反，true 变 false，false 变 true
java 复制代码 
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）
java 复制代码 
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++ 根本没执行！）
    }
}

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

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

5.3 逻辑运算符的真值表

| a | b | a && b | a || b | !a |
|-------|-------|----------|----------|-------|
| true | true | true | true | false |
| true | false | false | true | false |
| false | true | false | true | true |
| false | false | false | false | true |

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

6.1 三元运算符的语法

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

java 复制代码 
条件 ? 值1 : 值2;

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

6.2 实战案例

java 复制代码 
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 三元运算符可以嵌套

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

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

7 ~> 位运算符（初识）

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

运算符 含义 示例（设 a=5(0101)）
& 按位与 5 & 3 = 1（0101 & 0011 = 0001）
` ` 按位或
^ 按位异或 5 ^ 3 = 6（0101 ^ 0011 = 0110）
~ 按位取反 ~5 = -6
<< 左移 5 << 1 = 10（相当于乘以 2）
>> 右移 5 >> 1 = 2（相当于除以 2）
java 复制代码 
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 实战中的优先级问题

java 复制代码 
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 会自动把小类型提升为大类型：

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 ~> 常见编译运行错误

编号 错误现象 错误原因 解决方案
1 bad operand types for binary operator '+' 运算符左右两边类型不兼容 检查操作数类型，确保运算符适用
2 integer division in floating-point context 整数除法结果赋给了浮点变量 改为 5.0 / 2 或 (double)5 / 2
3 unexpected type 赋值运算符写在了不合法位置 检查表达式语法
4 cannot find symbol 变量名拼写错误 检查变量名的大小写和拼写
5 incompatible types: int cannot be converted to boolean 把 = 写成了 == 条件判断中用 == 而不是 =
6 operator && cannot be applied to int,int 逻辑运算符用在了非 boolean 类型上 确保 && / `

思考 && 总结

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

  1. 算术运算符： + - * / %。整型除法结果也是整型（小数截断）。取余常用于判断奇偶数。(double)5/2 能得到 2.5。
  2. 自增自减： ++a（先加再用）和 a++（先用再加）是初学者翻车最多的点。简单起见，初学阶段把它们单独写一行，不要和赋值混在一起。经典陷阱 i = i++ 结果 i 还是原来的值。
  3. 比较运算符： 结果是 boolean 类型。注意 = 是赋值，== 才是判断相等。String 比较内容用 .equals()，不要用 ==。
  4. 逻辑运算符： &&（全真才真）、||（有真就真）、!（取反）。利用短路特性能写出优雅的判空逻辑：user != null && user.getName().equals("admin")。
  5. 三元运算符： 条件 ? 值1 : 值2，简洁表达二选一。嵌套一层以内是优雅，多了就是炫技。
  6. 优先级： 不确定时加括号，永远是对的。

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

结尾

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

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

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

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

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

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

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

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

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

往期回顾：

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

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

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

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

相关推荐
雪落漂泊2 小时前
C++ 继承与多态（下）
开发语言·c++
川冰ICE2 小时前
JavaScript工程化②｜Webpack5基础配置，打包你的第一个项目
开发语言·javascript·ecmascript
YHHLAI2 小时前
JavaScript 同步异步精讲：单线程、事件循环、Promise 执行机制
开发语言·javascript·ecmascript
yijianace2 小时前
Python爬虫实战：ThreadPoolExecutor多线程采集书籍信息与图片下载
开发语言·爬虫·python
资深流水灯工程师2 小时前
PySide6 + Qt Designer + PyCharm 完整开发流程
开发语言·qt·pycharm
Web打印2 小时前
HttpPrinter web打印控件 官方文档（https://wiki.httpprinter.com/）快速检索目录
java·javascript·chrome
我登哥MVP2 小时前
Spring Boot 从“会用”到“精通”：内容协商原理
java·spring boot·后端·spring·java-ee·maven·lua
阿旭超级学得完2 小时前
Linux基础指令 四(apt,vim,git,cgdb)
linux·服务器·开发语言·数据结构·c++·git·vim
Invictus_cl2 小时前
条纹圆形进度条(彩虹色)
开发语言·前端·javascript
热门推荐
01【AI】2026 年具身智能模型和世界模型总结02GitHub 镜像站点032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04Codex 下载安装指南：Windows 和 macOS 官方版下载052026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？06AI科技热点日报 | 2026年6月1日07【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法08《置身钉内》原文-可播放阅读09CC-Switch 下载、安装与使用配置指南【2026.5.29】10Agnes AI 全模态 API 免费实测报告：文生图 + 文生视频完整测试