【Java SE 基础学习打卡】19 运算符（中）

目录

• 前言
• [一、赋值运算符：给变量 "装数据"+"更数据"](#一、赋值运算符：给变量 “装数据”+“更数据”)
• • [1. 基础赋值运算符（`=`）：不是 "等于"，是 "赋值"](#1. 基础赋值运算符（=）：不是 “等于”，是 “赋值”)
  • [1.2 复合赋值运算符：偷懒专用，简化代码](#1.2 复合赋值运算符：偷懒专用，简化代码)
• [二、自增自减运算符：变量 "自己加 1 / 减 1"](#二、自增自减运算符：变量 “自己加 1 / 减 1”)
• • [2.1 基本用法：单独使用，前缀后缀都一样](#2.1 基本用法：单独使用，前缀后缀都一样)
  • [2.2 关键难点：参与运算时，前缀和后缀不一样](#2.2 关键难点：参与运算时，前缀和后缀不一样)
  • [2.3 避坑提醒（3 个关键点）：](#2.3 避坑提醒（3 个关键点）：)
• 总结

前言

上一节咱们吃透了算术运算符，能做基本的数学运算了。但写代码时，还经常需要给变量存值、让变量自己加 1 减 1（比如统计次数、倒计时）------ 这些操作就得靠 "赋值运算符" 和 "自增自减运算符"。它们是 Java 里的 "高频工具"，用法简单但有小细节要注意。这一节咱们就把这两类运算符讲透：先学赋值运算符（包括偷懒专用的复合赋值），再攻克自增自减的 "前缀后缀" 难点，全程用例子说话，保证你看完就能上手！

一、赋值运算符：给变量 "装数据"+"更数据"

赋值运算符的核心是 "把数据放进变量"，就像给抽屉放东西 ------ 基础赋值是 "直接放"，复合赋值是 "拿出来改一改再放回去"，特别实用。

1. 基础赋值运算符（=）：不是 "等于"，是 "赋值"

首先要明确：Java 里的=不是数学里的 "等于"，而是 "赋值符号"------ 作用是把右边的值 / 表达式结果 ，装进左边的变量里。

核心用法：

// 把具体值（18）装进变量age里
int age = 18;

// 把变量a的值，复制到变量b里（a的值不变）
int a = 10;
int b = a; // 现在b的值也是10

// 把表达式结果（3+5）装进变量sum里
int sum = 3 + 5; // 先算3+5=8，再把8赋给sum

避坑提醒：

• 左边必须是 "变量"（能装数据的容器），不能是具体值或表达式。比如10 = age;、a + b = 20;都是错误的 ------ 你不能把东西放进 "数字 10" 或 "a+b" 里。

• 右边可以是值、变量、表达式，只要能算出一个唯一结果就行。

1.2 复合赋值运算符：偷懒专用，简化代码

如果想 "先对变量做运算，再把结果存回变量"（比如 "年龄加 2""分数乘 3"），用基础赋值要写age = age + 2;，有点麻烦。Java 提供了 "复合赋值运算符"，把 "运算 + 赋值" 合并成一步，少写重复代码。

常用复合赋值运算符（5 个）：

运算符	核心作用	等价写法（帮你理解）
+=	加后赋值：变量 = 变量 + 右边值	a += 3 → a = a + 3
-=	减后赋值：变量 = 变量 - 右边值	a -= 3 → a = a - 3
*=	乘后赋值：变量 = 变量 × 右边值	a *= 3 → a = a * 3
/=	除后赋值：变量 = 变量 ÷ 右边值	a /= 3 → a = a / 3
%=	取余后赋值：变量 = 变量 % 右边值	a %= 3 → a = a % 3

例子演示：

public static void main(String[] args) {
    int score = 80;
    score += 5; // 等价于score = score + 5 → 80+5=85
    System.out.println(score); // 输出85

    int num = 10;
    num -= 4; // 10-4=6
    num *= 2; // 6×2=12
    num /= 3; // 12÷3=4（整数除法，无小数）
    num %= 2; // 4%2=0
    System.out.println(num); // 输出0
}

实用场景：

比如统计用户登录次数（每次登录加 1）、计算商品折扣价（原价 ×0.8），用复合赋值会更简洁：

int loginCount = 0;
loginCount += 1; // 登录次数+1，等价于loginCount = loginCount + 1

double originalPrice = 100.0;
originalPrice *= 0.8; // 打8折，等价于originalPrice = originalPrice * 0.8

二、自增自减运算符：变量 "自己加 1 / 减 1"

编程时经常需要 "让变量加 1"（比如计数）或 "让变量减 1"（比如倒计时），Java 专门提供了++（自增）和--（自减）运算符，直接让变量 "自己变"，不用写a = a + 1。

2.1 基本用法：单独使用，前缀后缀都一样

如果只是单纯让变量加 1 或减 1，++/--放在变量前面（前缀）或后面（后缀），结果完全相同。

例子：

public static void main(String[] args) {
    // 自增：加1
    int count = 3;
    count++; // 后缀自增：count = count + 1 → 4
    System.out.println(count); // 输出4

    int num = 3;
    ++num; // 前缀自增：num = num + 1 → 4
    System.out.println(num); // 输出4（和count++结果一样）

    // 自减：减1
    int time = 5;
    time--; // 后缀自减：time = time - 1 → 4
    System.out.println(time); // 输出4

    int value = 5;
    --value; // 前缀自减：value = value - 1 → 4
    System.out.println(value); // 输出4（和time--结果一样）
}

核心结论： 单独使用a++和++a（a--和--a），效果完全相同 ------ 都是让变量加 1（减 1）。

2.2 关键难点：参与运算时，前缀和后缀不一样

如果把++/--放进表达式里（比如和其他运算符一起用），前缀和后缀的区别就出来了，这是新手最容易踩坑的地方：

核心规则（记牢！）：

• 后缀形式（a++/a--）：先拿变量 "原来的值" 参与运算，运算结束后，变量再自增 / 自减；

• 前缀形式（++a/--a）：先让变量自增 / 自减，再拿 "新的值" 参与运算。

例子 1：自增参与加法运算

public static void main(String[] args) {
    // 后缀形式：a++ → 先用原值，再自增
    int a = 3;
    int result1 = a++ + 6; // 步骤：①用a的原值3算3+6=9；②a自增为4
    System.out.println(result1); // 输出9
    System.out.println(a); // 输出4

    // 前缀形式：++b → 先自增，再用新值
    int b = 3;
    int result2 = ++b + 6; // 步骤：①b自增为4；②用新值4算4+6=10
    System.out.println(result2); // 输出10
    System.out.println(b); // 输出4
}

例子 2：自减参与赋值运算

public static void main(String[] args) {
    int x = 5;
    int y = x--; // 后缀：先用x的原值5赋给y，再x减1→4
    System.out.println(y); // 输出5
    System.out.println(x); // 输出4

    int m = 5;
    int n = --m; // 前缀：先m减1→4，再用新值4赋给n
    System.out.println(n); // 输出4
    System.out.println(m); // 输出4
}

通俗记忆：

• 后缀（a++）："先用后变"------ 先办事，再涨经验；

• 前缀（++a）："先变后用"------ 先涨经验，再办事。

2.3 避坑提醒（3 个关键点）：

1. 只能作用于 "变量"，不能作用于常量或表达式。比如5++（常量不能变）、(a + b)++（表达式不是变量），都会编译报错；

2. 不能在一个表达式里对同一个变量多次自增 / 自减。比如int z = a++ + ++a;，结果混乱且可读性差，实际开发中绝对禁止；

3. 浮点类型变量也能使用++/--（比如double f = 2.5; f++;，结果是 3.5），但实际用得少，重点掌握整数类型即可。

总结

学完这一节，你只要记住 3 个核心点：

1. 赋值运算符=是 "装数据"，不是 "等于"；复合赋值（+=/-=等）是 "运算 + 赋值"，简化代码；

2. 自增自减++/--：单独使用时，前缀后缀无区别；参与运算时，后缀 "先用后变"，前缀 "先变后用"；

3. 避坑关键：赋值运算符左边必须是变量，自增自减只能作用于变量，不重复操作同一个变量。

这些运算符是写代码的 "基本功"，现在就动手练一练吧 ------ 比如用复合赋值算折扣价、用自增统计循环次数，很快就能熟练掌握！