（六）Java 运算符
目录
一. 前言
二. 算术运算符
三. 关系运算符
四. 位运算符
五. 逻辑运算符
六. 赋值运算符
七. 其他运算符
7.1. 条件运算符（三元运算符）
7.2. instanceof 运算符
八. Java 运算符优先级
九. 课后习题
一. 前言
计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java 也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符。
二. 算术运算符
算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。
表格中的实例假设整数变量 A 的值为10，变量 B 的值为20：
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法：相加运算符两侧的值 | A + B等于30 |
| - | 减法：左操作数减去右操作数 | A – B等于-10 |
| * | 乘法：相乘操作符两侧的值 | A * B等于200 |
| / | 除法：左操作数除以右操作数 | B / A等于2 |
| ％ | 取模：左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增：操作数的值增加1 | B++ 或 ++B 等于 21 |
| -- | 自减：操作数的值减少1 | B-- 或 --B 等于 19 |
虽然都是自增（他们的运算结果都是等于 B+1），但 B++ 和 ++B 还是有所区别，++B 是左值，直接原地操作（可以理解为直接在变量 B 上+1），B++ 是右值，在编译器中运算的时候会先构建一个临时变量，用临时变量运算+1后再赋值给 B。
所以，在下面实例代码中，打印 d++ 的时候发现结果并没有+1（这个时候打印的是 d 这个变量，运算的是 d 的临时变量），但是后一条打印的语句显示的结果又是+1后的结果（临时变量的值赋给变量 d 了）。而打印 ++d 的结果是直接+1的。
代码实例：
下面的简单示例程序演示了算术运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a * b));
System.out.println("b / a = " + (b / a));
System.out.println("b % a = " + (b % a));
System.out.println("c % a = " + (c % a));
System.out.println("a++ = " + (a++));
System.out.println("a-- = " + (a--));
// 查看 d++ 与 ++d 的不同
System.out.println("d++ = " + (d++));
System.out.println("d = " + d);
System.out.println("++d = " + (++d));
}
} // 运行结果：
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
a-- = 11
d++ = 25
d =26
++d = 27三. 关系运算符
下表为 Java 支持的关系运算符。
表格中的实例整数变量 A 的值为10，变量 B 的值为20：
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 为假（非真）。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | (A> B) 非真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | (A |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | (A> = B) 为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | (A <= B) 为真。 |
代码实例：
下面的简单示例程序演示了关系运算符。复制并粘贴下面的 Java 程序并保存为 Test.java文件，然后编译并运行这个程序：
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b));
System.out.println("a != b = " + (a != b));
System.out.println("a > b = " + (a > b));
System.out.println("a < b = " + (a < b));
System.out.println("b >= a = " + (b >= a));
System.out.println("b <= a = " + (b <= a));
}
} // 运行结果：
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false 四. 位运算符
Java 定义了位运算符，应用于整数类型（int），长整型（long），短整型（short），字符型（char），和字节型（byte）等类型。关于位运算可以参见《一文带你深入理解位运算》。
位运算符作用在所有的位上，并且按位运算。假设 a = 60 和 b = 13；它们的二进制格式表示将如下：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011下表列出了位运算符的基本运算，假设整数变量 A 的值为60和变量 B 的值为13：
| 操作符 | 描述 | 例子 |
|---|---|---|
| ＆ | 按位与操作符，当且仅当两个操作数的某一位都非0时候结果的该位才为1。 | (A＆B)，得到12，即0000 1100 |
| | | 按位或操作符，只要两个操作数的某一位有一个非0时候结果的该位就为1。 | (A | B) 得到61，即 0011 1101 |
| ^ | 按位异或操作符，两个操作数的某一位不相同时候结果的该位就为1。 | (A ^ B) 得到49，即 0011 0001 |
| 〜 | 按位补运算符翻转操作数的每一位。 | (〜A) 得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2 得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2 得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2 得到15即0000 1111 |
代码实例：
下面的简单示例程序演示了位运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：
public class Test {
public static void main(String[] args) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c );
c = a >> 2; /* 215 = 1111 */
System.out.println("a >> 2 = " + c );
c = a >>> 2; /* 215 = 0000 1111 */
System.out.println("a >>> 2 = " + c );
}
} // 运行结果：
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15五. 逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量 A 为真，变量 B 为假：
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | (A && B) 为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | (A | | B) 为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | !(A && B) 为真。 |
代码实例：
下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：
public class Test {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b));
System.out.println("!(a && b) = " + !(a && b));
}
} // 运行结果：
a && b = false
a || b = true
!(a && b) = true六. 赋值运算符
下面是 Java 语言支持的赋值运算符：
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B 将把 A + B 得到的值赋给 C |
| += | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C += A 等价于 C = C + A |
| -= | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C -= A 等价于 C = C - A |
| *= | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C *= A 等价于 C = C * A |
| /= | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C /= A 等价于 C = C / A |
| ％= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C ％= A 等价于 C = C ％ A |
| <<= | 左移位赋值运算符 | C <<= 2 等价于 C = C << 2 |
| >>= | 右移位赋值运算符 | C >>= 2 等价于 C = C >> 2 |
| ＆= | 按位与赋值运算符 | C ＆= 2 等价于 C = C＆2 |
| ^= | 按位异或赋值操作符 | C ^= 2等价于 C = C ^ 2 |
| |= | 按位或赋值操作符 | C |= 2 等价于 C = C | 2 |
代码实例：
下面的简单示例程序演示了赋值运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 0;
c = a + b;
System.out.println("c = a + b = " + c);
c += a ;
System.out.println("c += a = " + c);
c -= a ;
System.out.println("c -= a = " + c);
c *= a ;
System.out.println("c *= a = " + c);
a = 10;
c = 15;
c /= a ;
System.out.println("c /= a = " + c);
a = 10;
c = 15;
c %= a ;
System.out.println("c %= a = " + c);
c <<= 2 ;
System.out.println("c <<= 2 = " + c);
c >>= 2 ;
System.out.println("c >>= 2 = " + c);
c >>= 2 ;
System.out.println("c >>= a = " + c);
c &= a ;
System.out.println("c &= a = " + c);
c ^= a ;
System.out.println("c ^= a = " + c);
c |= a ;
System.out.println("c |= a = " + c);
}
} // 运行结果：
c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10七. 其他运算符
7.1. 条件运算符（三元运算符）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false代码实例：
public class Test {
public static void main(String[] args) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println("Value of b is : " + b);
b = (a == 10) ? 20: 30;
System.out.println("Value of b is : " + b);
}
}// 运行结果：
Value of b is : 30
Value of b is : 207.2. instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
instanceof 运算符使用格式如下：
(Object reference variable) instanceof (class/interface type)如果运算符左侧变量所指的对象，是操作符右侧类或接口（class/interface）的一个对象，那么结果为真。
下面是一个例子：
String name = 'James';
boolean result = name instanceof String; // 由于name是String类型，所以返回真如果被比较的对象兼容于右侧类型，该运算符仍然返回 true。
看下面的例子：
class Vehicle {}
public class Car extends Vehicle {
public static void main(String[] args) {
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println(result);
}
}
// 运行结果：
true八. Java 运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。
例如，(1+3) + (3+2) * 2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。
再如，x = 7 + 3 * 2；这里 x 得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算 3 * 2 得到 6，然后再加7。
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
| 类别 | 操作符 | 关联性 |
|---|---|---|
| 后缀 | () [] .（点操作符） | 左到右 |
| 一元 | + - ! ~ | 从右到左 |
| 乘除取模 | * / % | 左到右 |
| 加减 | + - | 左到右 |
| 移位 | >>、>>>、<< | 左到右 |
| 关系 | >、>=、<、<= | 左到右 |
| 相等 | ==、!= | 左到右 |
| 按位与 | & | 左到右 |
| 按位异或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 逻辑与 | && | 左到右 |
| 逻辑或 | || | 左到右 |
| 条件 | ? : | 从右到左 |
| 赋值 | =、+=、-=、*=、/=、%=、>>=、<<=、＆=、^=、|= | 从右到左 |
| 逗号 | , | 左到右 |
九. 课后习题
1. 定义三个整型变量 a、b、c，他们的初始值分别为4、15、20。对表达式进行运算。
2. 接收命令行参数年、月、日，判断这一天是当年的第几天。（判断一年是否是闰年的标准：可以被4整除，但不可被100整除；可以被400整除）
3. 利用三元运算符求任意三个数中最大者。
4. 将任意一个三位数的个位、十位、百位分别输出。
5. 若任意两数和是3的倍数或其中一个为3，则输出 true，否者输出 false。