Appearance
运算符
运算符是用于执行特定运算操作的符号。Java 提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符等。
运算符分类
text
┌─────────────────────────────────────────────────────────────────┐
│ Java 运算符分类 │
├─────────────────────────────────────────────────────────────────┤
│ 算术运算符：+ - * / % ++ -- │
│ 关系运算符：== != > < >= <= │
│ 逻辑运算符：&& || ! │
│ 位运算符： & | ^ ~ << >> >>> │
│ 赋值运算符：= += -= *= /= %= 等 │
│ 条件运算符：? : │
│ 其他运算符：instanceof new [] . () │
└─────────────────────────────────────────────────────────────────┘算术运算符
算术运算符用于执行数学运算。
基本算术运算符
java
public class ArithmeticOperator {
public static void main(String[] args) {
int a = 10;
int b = 3;
// 加法运算
int sum = a + b;
System.out.println(a + " + " + b + " = " + sum); // 13
// 减法运算
int diff = a - b;
System.out.println(a + " - " + b + " = " + diff); // 7
// 乘法运算
int product = a * b;
System.out.println(a + " * " + b + " = " + product); // 30
// 除法运算（整数除法，结果取整）
int quotient = a / b;
System.out.println(a + " / " + b + " = " + quotient); // 3
// 取模运算（求余数）
int remainder = a % b;
System.out.println(a + " % " + b + " = " + remainder); // 1
// 浮点数除法
double divResult = 10.0 / 3;
System.out.println("10.0 / 3 = " + divResult); // 3.333...
// 字符串连接（+ 运算符重载）
String str = "Hello" + " " + "Java";
System.out.println(str); // Hello Java
// 数字与字符串连接
String mixed = "结果是：" + (a + b);
System.out.println(mixed); // 结果是：13
}
}自增自减运算符
java
public class IncrementOperator {
public static void main(String[] args) {
int a = 5;
// 前缀自增：先加1，再使用
int b = ++a;
System.out.println("前缀自增: a = " + a + ", b = " + b); // a=6, b=6
int c = 5;
// 后缀自增：先使用，再加1
int d = c++;
System.out.println("后缀自增: c = " + c + ", d = " + d); // c=6, d=5
int e = 10;
// 前缀自减：先减1，再使用
int f = --e;
System.out.println("前缀自减: e = " + e + ", f = " + f); // e=9, f=9
int g = 10;
// 后缀自减：先使用，再减1
int h = g--;
System.out.println("后缀自减: g = " + g + ", h = " + h); // g=9, h=10
// 复杂表达式中的自增
int x = 5;
int result = x++ + ++x;
// x++ = 5, x 变为 6
// ++x = 7, x 变为 7
// result = 5 + 7 = 12
System.out.println("x = " + x + ", result = " + result); // x=7, result=12
}
}关系运算符
关系运算符用于比较两个值，返回布尔值。
java
public class RelationalOperator {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 等于
boolean equal = a == b;
System.out.println(a + " == " + b + " : " + equal); // false
// 不等于
boolean notEqual = a != b;
System.out.println(a + " != " + b + " : " + notEqual); // true
// 大于
boolean greater = a > b;
System.out.println(a + " > " + b + " : " + greater); // false
// 小于
boolean less = a < b;
System.out.println(a + " < " + b + " : " + less); // true
// 大于等于
boolean greaterEqual = a >= 10;
System.out.println(a + " >= 10 : " + greaterEqual); // true
// 小于等于
boolean lessEqual = b <= 20;
System.out.println(b + " <= 20 : " + lessEqual); // true
// 字符比较（比较 Unicode 编码）
char c1 = 'A';
char c2 = 'B';
System.out.println("'A' < 'B' : " + (c1 < c2)); // true
// 字符串比较（使用 equals，不要用 ==）
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
System.out.println("s1 == s2 : " + (s1 == s2)); // true（常量池）
System.out.println("s1 == s3 : " + (s1 == s3)); // false
System.out.println("s1.equals(s3) : " + s1.equals(s3)); // true
}
}逻辑运算符
逻辑运算符用于连接布尔表达式。
java
public class LogicalOperator {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
// 逻辑与（&&）：两边都为 true 才为 true
boolean and = a && b;
System.out.println("true && false = " + and); // false
// 逻辑或（||）：一边为 true 就为 true
boolean or = a || b;
System.out.println("true || false = " + or); // true
// 逻辑非（!）：取反
boolean not = !a;
System.out.println("!true = " + not); // false
// 短路特性演示
int x = 10;
int y = 0;
// 短路与：如果左边为 false，右边不执行
if (y != 0 && x / y > 1) {
System.out.println("不会执行这里");
} else {
System.out.println("短路与生效，避免了除零错误");
}
// 短路或：如果左边为 true，右边不执行
if (x > 0 || x / y > 1) {
System.out.println("短路或生效，右边未执行");
}
// 非短路运算符（& 和 |）
// 这两个运算符没有短路特性，两边都会执行
// if (y != 0 & x / y > 1) { // 会抛出 ArithmeticException
// System.out.println("不会执行");
// }
// 异或（^）：两边不同为 true，相同为 false
boolean xor1 = true ^ false; // true
boolean xor2 = true ^ true; // false
boolean xor3 = false ^ false; // false
System.out.println("true ^ false = " + xor1);
System.out.println("true ^ true = " + xor2);
System.out.println("false ^ false = " + xor3);
}
}位运算符
位运算符直接对整数的二进制位进行操作。
java
public class BitwiseOperator {
public static void main(String[] args) {
int a = 60; // 二进制：0011 1100
int b = 13; // 二进制：0000 1101
// 按位与（&）：两位都为1才为1
int and = a & b; // 0000 1100 = 12
System.out.println("60 & 13 = " + and); // 12
// 按位或（|）：有一位为1就为1
int or = a | b; // 0011 1101 = 61
System.out.println("60 | 13 = " + or); // 61
// 按位异或（^）：两位不同为1
int xor = a ^ b; // 0011 0001 = 49
System.out.println("60 ^ 13 = " + xor); // 49
// 按位取反（~）：0变1，1变0
int not = ~a; // 1100 0011 = -61
System.out.println("~60 = " + not); // -61
// 左移（<<）：所有位向左移动，低位补0
int leftShift = a << 2; // 1111 0000 = 240
System.out.println("60 << 2 = " + leftShift); // 240
// 右移（>>）：所有位向右移动，高位补符号位
int rightShift = a >> 2; // 0000 1111 = 15
System.out.println("60 >> 2 = " + rightShift); // 15
// 无符号右移（>>>）：所有位向右移动，高位补0
int unsignedRight = -1 >>> 2;
System.out.println("-1 >>> 2 = " + unsignedRight); // 1073741823
// 位运算技巧
// 判断奇偶：n & 1 == 1 为奇数
int num = 7;
System.out.println(num + " 是奇数：" + ((num & 1) == 1)); // true
// 交换两个数（不使用临时变量）
int x = 5, y = 10;
x = x ^ y;
y = x ^ y;
x = x ^ y;
System.out.println("交换后：x = " + x + ", y = " + y); // x=10, y=5
// 快速乘除2的幂
int n = 8;
System.out.println(n + " * 2 = " + (n << 1)); // 16
System.out.println(n + " / 2 = " + (n >> 1)); // 4
}
}赋值运算符
赋值运算符用于给变量赋值。
java
public class AssignmentOperator {
public static void main(String[] args) {
// 基本赋值
int a = 10;
System.out.println("a = " + a); // 10
// 复合赋值运算符
int b = 20;
// 加法赋值
b += 5; // 等价于 b = b + 5
System.out.println("b += 5: " + b); // 25
// 减法赋值
b -= 10; // 等价于 b = b - 10
System.out.println("b -= 10: " + b); // 15
// 乘法赋值
b *= 2; // 等价于 b = b * 2
System.out.println("b *= 2: " + b); // 30
// 除法赋值
b /= 3; // 等价于 b = b / 3
System.out.println("b /= 3: " + b); // 10
// 取模赋值
b %= 3; // 等价于 b = b % 3
System.out.println("b %= 3: " + b); // 1
// 位运算赋值
int c = 60;
c &= 13; // 等价于 c = c & 13
System.out.println("c &= 13: " + c); // 12
c |= 1; // 等价于 c = c | 1
System.out.println("c |= 1: " + c); // 13
c ^= 5; // 等价于 c = c ^ 5
System.out.println("c ^= 5: " + c); // 8
c <<= 2; // 等价于 c = c << 2
System.out.println("c <<= 2: " + c); // 32
c >>= 1; // 等价于 c = c >> 1
System.out.println("c >>= 1: " + c); // 16
// 连续赋值
int d, e, f;
d = e = f = 100;
System.out.println("d = " + d + ", e = " + e + ", f = " + f);
}
}条件运算符（三元运算符）
条件运算符是 Java 中唯一的三元运算符。
java
public class ConditionalOperator {
public static void main(String[] args) {
// 语法：条件 ? 表达式1 : 表达式2
// 条件为 true 返回表达式1，否则返回表达式2
int a = 10;
int b = 20;
// 求较大值
int max = a > b ? a : b;
System.out.println("较大值: " + max); // 20
// 求较小值
int min = a < b ? a : b;
System.out.println("较小值: " + min); // 10
// 判断奇偶
int num = 7;
String evenOrOdd = num % 2 == 0 ? "偶数" : "奇数";
System.out.println(num + " 是 " + evenOrOdd); // 7 是 奇数
// 判断正负零
int value = -5;
String sign = value > 0 ? "正数" : (value < 0 ? "负数" : "零");
System.out.println(value + " 是 " + sign); // -5 是 负数
// 嵌套使用（不推荐过多嵌套，影响可读性）
int score = 85;
String grade = score >= 90 ? "优秀" :
score >= 80 ? "良好" :
score >= 60 ? "及格" : "不及格";
System.out.println("成绩 " + score + " 等级: " + grade); // 良好
// 实际应用：空值处理
String name = null;
String displayName = name != null ? name : "匿名用户";
System.out.println("显示名称: " + displayName); // 匿名用户
}
}运算符优先级
当表达式中包含多种运算符时，按照优先级顺序执行。
text
优先级从高到低：
┌─────────────────────────────────────────────────────────────────┐
│ 优先级 │ 运算符 │ 说明 │
├─────────────────────────────────────────────────────────────────┤
│ 1 │ () [] . │ 括号、数组访问、成员访问 │
│ 2 │ ! ~ ++ -- + - │ 一元运算符 │
│ 3 │ * / % │ 乘法、除法、取模 │
│ 4 │ + - │ 加法、减法 │
│ 5 │ << >> >>> │ 移位运算 │
│ 6 │ < <= > >= │ 比较运算 │
│ 7 │ == != │ 相等比较 │
│ 8 │ & │ 按位与 │
│ 9 │ ^ │ 按位异或 │
│ 10 │ | │ 按位或 │
│ 11 │ && │ 逻辑与 │
│ 12 │ || │ 逻辑或 │
│ 13 │ ? : │ 条件运算符 │
│ 14 │ = += -= *= /= %= 等 │ 赋值运算符 │
└─────────────────────────────────────────────────────────────────┘java
public class OperatorPrecedence {
public static void main(String[] args) {
// 使用括号明确优先级，提高可读性
// 算术运算优先级
int result1 = 2 + 3 * 4; // 14（先乘后加）
int result2 = (2 + 3) * 4; // 20（括号改变优先级）
System.out.println("2 + 3 * 4 = " + result1);
System.out.println("(2 + 3) * 4 = " + result2);
// 逻辑运算优先级
boolean b1 = true || false && false; // true（&& 优先级高于 ||）
boolean b2 = (true || false) && false; // false
System.out.println("true || false && false = " + b1);
System.out.println("(true || false) && false = " + b2);
// 混合运算
int a = 5, b = 3, c = 2;
boolean result = a > b && b > c || a < c;
// 等价于：(a > b && b > c) || a < c
// 即：(true && true) || false = true
System.out.println("a > b && b > c || a < c = " + result);
// 赋值与比较
int x = 10;
boolean isEqual = (x = 20) == 20; // 先赋值，再比较
System.out.println("x = " + x + ", isEqual = " + isEqual);
// 复杂表达式建议使用括号
int complex = ((a + b) * c - 10) / 2;
System.out.println("((a + b) * c - 10) / 2 = " + complex);
}
}其他运算符
instanceof 运算符
java
public class InstanceofOperator {
public static void main(String[] args) {
// instanceof：判断对象是否为某个类的实例
String str = "Hello";
// 判断 str 是否是 String 的实例
boolean isString = str instanceof String;
System.out.println("str 是 String 的实例: " + isString); // true
// 判断 str 是否是 Object 的实例（String 继承自 Object）
boolean isObject = str instanceof Object;
System.out.println("str 是 Object 的实例: " + isObject); // true
// 判断 null
String nullStr = null;
boolean isNullInstance = nullStr instanceof String;
System.out.println("null 是 String 的实例: " + isNullInstance); // false
// 用于类型检查
Object obj = "Hello Java";
if (obj instanceof String) {
String s = (String) obj; // 安全转型
System.out.println("字符串长度: " + s.length());
}
// Java 16+ 模式匹配
// if (obj instanceof String s) {
// System.out.println("字符串长度: " + s.length());
// }
}
}new 运算符
java
public class NewOperator {
public static void main(String[] args) {
// new：创建对象
String str = new String("Hello");
int[] arr = new int[5];
// 创建自定义类对象
Person person = new Person();
person.name = "张三";
person.age = 25;
person.introduce();
}
}
class Person {
String name;
int age;
void introduce() {
System.out.println("我是 " + name + "，今年 " + age + " 岁");
}
}小结
本章我们学习了：
- 算术运算符：+、-、*、/、%、++、--
- 关系运算符：==、!=、>、<、>=、<=
- 逻辑运算符：&&、||、!
- 位运算符：&、|、^、~、<<、>>、>>>
- 赋值运算符：=、+=、-=、*=、/= 等
- 条件运算符：? :
- 运算符优先级：使用括号明确优先级
下一章，我们将学习 流程控制，了解 Java 中的条件语句和循环语句。