前言：学会Java变量与数据类型后，下一步就是掌握「运算符」—— 它相当于Java的“计算工具”，用来对变量和数据进行运算、判断。很多新手刚接触时，会混淆运算符的用法（比如分不清=和==），甚至写出逻辑错误的代码。这篇文章全程避开复杂术语，用「生活化类比+可直接运行的代码案例」，把Java基础运算符讲透，每个知识点都搭配详细注释，新手跟着敲一遍就能掌握，复制粘贴就能在CSDN发布，助力你稳步推进Java入门之路！

温馨提示：所有代码均适配JDK8及以上版本，可直接复制到IDEA、Eclipse等Java编辑器运行，报错可评论区留言，逐一解答；建议结合上一篇「变量与数据类型」一起学习，衔接更顺畅~

一、先搞懂：什么是Java运算符？

1. 通俗理解

运算符就像我们现实中用的「计算器按钮」—— 比如用“+”按钮做加法、用“-”按钮做减法，用“>”按钮判断大小。在Java中，运算符就是用来连接变量/数据，执行特定操作（计算、判断、赋值）的符号，是编写Java代码的核心工具。

比如：用运算符计算10+5、判断10是否大于5、给变量赋值，这些操作都离不开运算符，它和变量、数据类型一起，构成Java基础的“铁三角”。

2. 运算符的分类

Java中的运算符有很多，但新手无需全部掌握，重点吃透以下4类基础运算符，就能应对大部分入门场景：

  • 赋值运算符：给变量赋值（最基础，比如=、+=）；

  • 算术运算符：做数学计算（比如+、-、*、/）；

  • 比较运算符：做判断，返回true/false（比如==、>、<）；

  • 逻辑运算符：组合多个判断条件（比如&&、||、!）。

下面逐一讲解，每个类别都配实操案例，确保新手能看懂、会使用。

二、赋值运算符（最基础，必掌握）

赋值运算符的核心作用：给变量赋值，把右边的值（或计算结果）赋给左边的变量。最常用的是「=」，还有简化版的复合赋值运算符（+=、-=等），能减少代码量。

1. 核心赋值运算符（=）

语法：变量名 = 值/表达式;（注意：是“赋值”，不是“等于”，和数学中的“=”含义不同）

public class AssignDemo1 {
    public static void main(String[] args) {
        // 案例：用=给变量赋值
        int a = 10; // 把10赋给变量a
        double b = 3.14; // 把3.14赋给变量b
        String c = "Java"; // 把字符串"Java"赋给变量c
        
        // 把表达式的结果赋给变量
        int d = a + 5; // 先计算a+5=15，再把15赋给d
        System.out.println(a); // 输出：10
        System.out.println(d); // 输出：15
    }
}

新手避坑：不要把“赋值”和“等于”混淆，比如「a = 5」是“把5赋给a”，不是“a等于5”；判断“a是否等于5”要用后面讲的「==」。

2. 复合赋值运算符（简化写法，常用）

当我们需要“先运算，再赋值”时，比如「a = a + 5」，可以用复合赋值运算符简化，新手重点掌握前4个即可。

运算符 含义（等价写法） 实操案例
+= a += b → a = a + b a += 5 → a = a + 5
-= a -= b → a = a - b a -= 5 → a = a - 5
*= a *= b → a = a * b a *= 5 → a = a * 5
/= a /= b → a = a / b a /= 5 → a = a / 5
%= a %= b → a = a % b a %= 5 → a = a % 5 
// 复合赋值运算符案例
public class AssignDemo2 {
    public static void main(String[] args) {
        int a = 10;
        a += 5; // 等价于 a = a + 5 → a=15
        System.out.println(a); // 输出：15
        
        a -= 3; // 等价于 a = a - 3 → a=12
        System.out.println(a); // 输出：12
        
        a *= 2; // 等价于 a = a * 2 → a=24
        System.out.println(a); // 输出：24
        
        a /= 4; // 等价于 a = a / 4 → a=6
        System.out.println(a); // 输出：6
    }
}

三、算术运算符（做数学计算，高频使用）

算术运算符用于对数字类型（int、double等）的变量/数据进行数学运算，和我们现实中的数学运算逻辑基本一致，新手重点掌握6个核心运算符。

1. 核心算术运算符

运算符 作用 案例（a=10，b=3） 结果
+ 加法 a + b 13
- 减法 a - b 7
* 乘法 a * b 30
/ 除法（注意：整数除法取整数部分） a / b（int类型） 3（不是3.333）
% 取余（除法后的余数） a % b 1（10÷3余1）
++ 自增（变量值+1） a++ 或 ++a 11（两种写法区别下面讲）
– 自减（变量值-1） a-- 或 --a 9

2. 实操案例（可直接复制运行）

public class ArithmeticDemo {
    public static void main(String[] args) {
        // 基础算术运算
        int a = 10;
        int b = 3;
        System.out.println("加法：" + (a + b)); // 输出：加法：13
        System.out.println("减法：" + (a - b)); // 输出：减法：7
        System.out.println("乘法：" + (a * b)); // 输出：乘法：30
        System.out.println("整数除法：" + (a / b)); // 输出：整数除法：3（取整数）
        System.out.println("取余：" + (a % b)); // 输出：取余：1
        
        // 自增、自减运算
        int c = 5;
        c++; // 等价于 c = c + 1
        System.out.println("c自增后：" + c); // 输出：6
        
        int d = 5;
        --d; // 等价于 d = d - 1
        System.out.println("d自减后：" + d); // 输出：4
    }
}

3. 新手避坑重点（高频错误）

  • 避坑1：整数除法（/）只取整数部分，不会四舍五入。比如10/3=3（不是3.333），如果想得到小数结果，需要把其中一个数改成double类型（比如10.0/3）；

  • 避坑2：自增（++）、自减（–）的前后区别：

    • a++：先使用a的值，再让a+1（比如int x = a++; 先把a的值赋给x，再a+1）；

    • ++a：先让a+1，再使用a的值（比如int x = ++a; 先a+1，再把新值赋给x）；

  • 避坑3：不能用算术运算符操作字符串（比如"Java" + 10，虽然不会报错，但会拼接成字符串"Java10"，不是数学加法）。

// 避坑案例
public class ArithmeticPitfall {
    public static void main(String[] args) {
        // 避坑1：整数除法取整
        System.out.println(10 / 3); // 输出：3
        System.out.println(10.0 / 3); // 输出：3.3333333333333335
        
        // 避坑2：自增前后区别
        int a = 10;
        int x = a++; // 先赋值x=10，再a=11
        int y = ++a; // 先a=12，再赋值y=12
        System.out.println(x); // 输出：10
        System.out.println(y); // 输出：12
        
        // 避坑3：字符串拼接
        System.out.println("Java" + 10); // 输出：Java10（拼接，不是加法）
    }
}

四、比较运算符（做判断，后续流程控制必备）

比较运算符用于比较两个变量/数据的大小、是否相等，运算结果只有两个：true（真，满足条件）、false（假，不满足条件），后续学习if判断、循环时会频繁用到。

1. 核心比较运算符（必记）

运算符 作用 案例（a=10，b=3） 结果
== 判断两个值是否相等（重点：两个=） a == b false
!= 判断两个值是否不相等 a != b true
> 判断左边是否大于右边 a > b true
< 判断左边是否小于右边 a < b false
>= 判断左边是否大于等于右边 a >= 10 true
<= 判断左边是否小于等于右边 b <= 2 false

2. 实操案例

public class CompareDemo {
    public static void main(String[] args) {
        int age = 18;
        double score = 85.5;
        
        // 比较运算，结果是true/false
        System.out.println(age == 18); // 输出：true（年龄等于18）
        System.out.println(score > 90); // 输出：false（分数不大于90）
        System.out.println(age != 20); // 输出：true（年龄不等于20）
        System.out.println(score <= 100); // 输出：true（分数小于等于100）
        
        // 比较运算符的实际用途（结合布尔变量）
        boolean isAdult = age >= 18; // 判断是否成年，结果true
        System.out.println("是否成年：" + isAdult); // 输出：是否成年：true
    }
}

3. 新手避坑

最容易犯的错误：把「==」和「=」混淆！

  • 「==」是比较运算符，用来判断两个值是否相等（比如a == 18）；
  • 「=」是赋值运算符，用来给变量赋值（比如a = 18）；
    如果写成「if(a = 18)」，会报错（把18赋给a，不是判断a是否等于18）。

五、逻辑运算符（组合判断，进阶基础）

逻辑运算符用于组合多个比较条件（比较运算符的结果），最终返回true或false，核心用于“多条件判断”（比如“年龄大于18且分数大于80”）。新手重点掌握3个核心逻辑运算符。

1. 核心逻辑运算符

运算符 作用（通俗理解） 规则 案例（a=true，b=false）
& 逻辑与（且） 两个条件都为true，结果才为true；只要有一个false，结果就是false a && b → false
逻辑或（或）
! 逻辑非（取反） true变false，false变true !a → false

2. 实操案例（贴近实际场景）

public class LogicDemo {
    public static void main(String[] args) {
        // 场景：判断学生是否能获奖（分数>80 且 年龄>16）
        int score = 85;
        int age = 17;
        
        boolean canWin = score > 80 && age > 16;
        System.out.println("是否能获奖：" + canWin); // 输出：true（两个条件都满足）
        
        // 场景：判断学生是否符合条件（分数>90 或 年龄<18）
        boolean isQualified = score > 90 || age < 18;
        System.out.println("是否符合条件：" + isQualified); // 输出：true（年龄<18满足）
        
        // 逻辑非（取反）
        boolean isStudent = true;
        System.out.println("不是学生：" + !isStudent); // 输出：false
    }
}

3. 新手避坑

逻辑与（&&）有「短路特性」：如果第一个条件是false，第二个条件不会执行（因为无论第二个条件是什么，结果都是false）；
逻辑或（||）也有「短路特性」：如果第一个条件是true，第二个条件不会执行（因为无论第二个条件是什么，结果都是true）。

// 短路特性案例
public class LogicShortCircuit {
    public static void main(String[] args) {
        int a = 10;
        // 逻辑与：第一个条件false，第二个条件不执行（a++不会执行）
        boolean b = (a > 20) && (a++ > 5);
        System.out.println(a); // 输出：10（a++未执行）
        
        // 逻辑或：第一个条件true，第二个条件不执行（a--不会执行）
        boolean c = (a < 20) || (a-- < 5);
        System.out.println(a); // 输出：10（a--未执行）
    }
}

六、新手常见报错汇总（避坑天花板）

整理了新手使用运算符时，最常遇到的4种报错，附上原因和解决方案，看完少踩90%的坑！

  • 报错1：incompatible types: int cannot be converted to boolean（类型不兼容，int不能转boolean）
    原因：把赋值运算符（=）当比较运算符（）使用，比如if(a = 18)（赋值结果是int，if需要boolean）
    解决方案：把=改成，比如if(a == 18)。

  • 报错2：operator ‘/’ cannot be applied to ‘java.lang.String’, ‘int’（运算符/不能用于String和int）
    原因：用算术运算符操作字符串和数字，比如"10" / 2
    解决方案：先把字符串转成数字（后续会讲），再进行运算。

  • 报错3：unexpected type（意外类型）
    原因：比较运算符使用错误，比如a => 10（正确写法是a >= 10）
    解决方案：修正比较运算符的写法，注意>=、<=的顺序。

  • 报错4：division by zero（除以零）
    原因：用0作为除法或取余的除数，比如10 / 0
    解决方案：确保除数不为0，可先判断除数是否为0。

七、总结（新手必看）

Java基础运算符的核心，新手只需掌握以下3点，就能轻松应对入门场景：

  • 赋值运算符：核心是=，复合赋值运算符（+=、-=）能简化代码，记住“赋值≠等于”；
  • 算术运算符：重点掌握+、-、*、/、%，注意整数除法取整、自增自减的前后区别；
  • 比较+逻辑运算符：比较运算符返回true/false，逻辑运算符组合多条件，记住&&（且）、||（或）、!（非）的规则。

练习建议：结合上一篇的变量知识，自己写代码练习“定义变量→用运算符运算→打印结果”，比如计算两个数的和、差、积、商，判断两个数的大小，慢慢就能熟练掌握。

运算符是Java流程控制（if、循环）的基础，现在打扎实，后续学习会更轻松。如果有报错、有疑问，欢迎在评论区留言，逐一解答！觉得有用的话，点赞收藏不迷路，关注我，后续持续更新Java新手基础教程，陪你从零学会Java~

# 开发语言 # java
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

当 AI 修图师装上“万能插头“：MCP 如何改变修图工作流

avatar AI编程社区
cover

2026年8月开发者实战指南：ChatGPT Plus / Pro + Codex 如何协同完成需求分析、编码、测试、调试与代码审查

avatar AI编程社区
cover

Claude API + Python实战：结构化输出后，如何拦住“看起来正确”的JSON

avatar AI编程社区