@TOC
一、运算符（Operator）的分类
:star: 算术运算符
:star: 赋值运算符
:star: 关系运算符
:star: 逻辑运算符
:star: 位运算符
:star: 三元运算符
二、算术运算符
:star: 对数值类型的变量进行运算操作的符号
public class Test {
public static void main(String[] args) {
int num1 = 8;
int num2 = 2;
int num3 = 1;
// +、-、*、/、%、++、--
System.out.println("加：" + (num1 + num2)); // 加：10
System.out.println("减：" + (num1 - num2)); // 减：6
System.out.println("乘：" + (num1 * num2)); // 乘：16
System.out.println("除：" + (num1 / num2)); // 除：4
System.out.println("取余：" + (num1 % num2)); // 取余：0
System.out.println("后加加：" + num3++); // 后加加：1
System.out.println("后减减：" + num3--); // 后减减：2
System.out.println("前加加：" + ++num3); // 前加加：2
System.out.println("前减减：" + --num3); // 前减减：1
}
}++：自增运算符 --：自减运算符
int num = 1;
// 使用完 num 的值后, 把 num 的值增加1
// 所以, 下面的一行代码执行完毕后, num 的值为 2
System.out.println("后加加：" + num++); // 后加加：1
// 先使用 num 的值后, 把 num 的值减少1
// 由于上面的代码把 num 的值增加了1, 所以此时 num 的值为2
// 执行完下面的一行代码后, num 的值减少1
// 执行完下面的一行代码后, num 的值为1
System.out.println("后减减：" + num--); // 后减减：2
// 先把当前 num 的值增加1, 再打印 num 的值
// 由于上面一行代码把 num 的值修改为了 1
// 下面的一行代码会先把 num 的值加1, 然后打印
// 所以, 打印的值为 2
System.out.println("前加加：" + ++num); // 前加加：2
// 下面的一行代码会把当前的 num 值先减少1, 然后打印
System.out.println("前减减：" + --num); // 前减减：1我初学编程的时候，总是弄晕自增运算符和自减运算符。最好的解决方法是记住： 自增运算符放前面就先运算，放后面就后运算，然后自己动手尝试一下。
public class Test {
public static void main(String[] args) {
int iniNum = 6;
// 先把 iniNum 当前的值赋值给 num, 然后 iniNum 再自增1
int num = iniNum++;
// 进过上面的一行代码, iniNum 的值变成了7
// 先把当前 iniNum 的值赋值给 iniNum, 然后 iniNum 再自增1
iniNum = iniNum++;
System.out.println(num); // 6
System.out.println(iniNum); // 7
}
}public class Test {
public static void main(String[] args) {
int i = 0;
// 先把 i 当前的值赋值给 i, 然后 i 再自增1
i = i++;
System.out.println(i); // 0
}
}public class Test {
public static void main(String[] args) {
int i = 1;
// 先把当前 i 的值增加 1, 然后才赋值给 i
i = ++i;
System.out.println(i); // 2
}
}public class Test {
public static void main(String[] args) {
int i = 0;
// 先把当前 i 的值赋值给i, 然后把 i 的值增加 1
i = i++;
System.out.println(i); // 0
}
}public class Test {
public static void main(String[] args) {
int num1 = 1;
int num2 = 0;
// 先把 num1 的值赋值给 num 后, num1 的值增加 1
int num = num1++;
System.out.println(num); // 1
System.out.println(num2); // 0
System.out.println(num1); // 2
// 先把 num2 的值减少1, 然后赋值给 num
num = --num2;
System.out.println(num); // -1
System.out.println(num2); // -1
}
}%：取余运算符（计算一个数除以另一个数后的余数）
:question:：假如还有 59 天放假，则还有多少星期零多少天放假？
public class Test {
public static void main(String[] args) {
int totalDay = 59;
int seven = 7;
int week = totalDay / seven;
int days = totalDay % seven;
// 还有8个星期, 零3天放假。
System.out.println("还有" + week + "个星期, 零" + days + "天放假。");
}
}三、关系运算符（比较运算符）
:star: 关系运算符的结果都是 boolean 类型（要么是 true，要么是 false）
:star: 关系表达式经常用在 if 结构的条件中或循环结构的条件中
instanceof 也非常常用，后期再详细说
public class Test {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
System.out.println("num1 == num2 " + (num1 == num2));
System.out.println("num1 != num2 " + (num1 != num2));
System.out.println("num1 < num2 " + (num1 < num2));
System.out.println("num1 > num2 " + (num1 > num2));
System.out.println("num1 <= num2 " + (num1 <= num2));
System.out.println("num1 >= num2 " + (num1 >= num2));
/*
num1 == num2 false
num1 != num2 true
num1 < num2 true
num1 > num2 false
num1 <= num2 true
num1 >= num2 false
*/
}
}:star: 关系运算符的结果都是 boolean 型（要么是 true，要么是 false）
:star: 关系运算符组成的表达式被称为关系表达式
:star: 比较运算符【==】不能误写成【=】
四、逻辑运算符
:star: 用于连接多个条件（多个关系表达式）
:star: 最终的结果也是一个 boolean 值
&& 短路与：两个为 true，才是 true
|| 短路或：一个为 true，就是 true
! 取反
& 逻辑与
| 逻辑或
^ 逻辑异或：不同为 true，相同 false
a && b：a 和 b 同时为 true，结果才为 true，否则是 false
a & b：a 和 b 同时为 true，结果才为 true，否则是 false
区别：
:herb:【&&】若前一个表达式（a）为 false 的时候，直接返回 false；不会判断后面的表达式（b）
:herb:【&】即使前一个表达式（a）为 false，也会判断后面的表达式（b）
public class Test {
public static void main(String[] args) {
int age = 5;
if (age >= 3 && age <= 7) { // 年龄大于等于3岁, 并且小于等于7岁则是 true
System.out.println("可以报考银河幼儿园");
}
if (age >= 3 & age <= 7) { // 年龄大于等于3岁, 并且小于等于7岁则是 true
System.out.println("可以报考银河幼儿园");
}
}
}上面的两段代码中使用到了 if-else 语句（后期还会详细说明）
if-else 语句的结构如下所示：
if (expression) {
// 如果 expression(表达式)的 boolean 值为 true
} else {
// 否则, 如果 expression(表达式)的 boolean 值为 false
}&& 和 & 的区别：
public class Test {
public static void main(String[] args) {
int num = 5;
if (num > 6 && num++ > 7) { // if: false
System.out.println(num); // 不打印
} else {
System.out.println(num); // 5 (结果为 5, 说明 && 右边的表达式没有执行)
}
}
}public class Test {
public static void main(String[] args) {
int num = 5;
if (num > 6 & num++ > 7) { // if: false
System.out.println(num); // 不打印
} else {
System.out.println(num); // 6 (结果为 6, 说明 && 右边的表达式执行了)
}
}
}---
a || b：a 和 b中 有一个为 true，则结果是 true，否则是false
a | b：a 和 b中 有一个为 true，则结果是 true，否则是false
区别：
:herb:【 ||】若前一个表达式（a）为 true 的时候，直接返回 true；不会判断后面的表达式（b）
:herb:【 |】即使前一个表达式（a）为 true，也会判断后面的表达式（b）! a：取反运算符（a 为 ture，则结果为 false；a 为 false，则结果为 true）
a ^ b：当 a 和 b 的值不同时，结果为 true，否则为 false
短路或测试代码
public class Test {
public static void main(String[] args) {
int num = 5;
/*
num 真实值是 5, 所以【num > 3】为 true
短路或【||】的特色是：若【||】左边的表达式为 true,
【||】右边的表达式不会进行运算
*/
if (num > 3 || num-- > 7) { // if: true
System.out.println("if: " + num); // if: 5
} else {
System.out.println("else: " + num); // 不打印
}
}
}逻辑或测试代码
public class Test {
public static void main(String[] args) {
int num = 5;
/*
num 真实值是 5, 所以【num > 3】为 true
短路或【|】的特色是：即使【|】左边的表达式为 true,
【|】右边的表达式也会进行运算（把 num 的值减少1）
*/
if (num > 3 | num-- > 7) { // if: true
System.out.println("if: " + num); // if: 4
} else {
System.out.println("else: " + num); // 不打印
}
}
}取反运算符测试代码
public class Test {
public static void main(String[] args) {
boolean isBoy = true; // 是男孩
boolean isGirl = false; // 不是女孩 (是男孩)
// !isBoy = false // 不是男孩 (是女孩)
System.out.println("!isBoy = " + !isBoy);
// !isGirl = true // 是女孩
System.out.println("!isGirl = " + !isGirl);
}
}取反运算符：原来是 true 的，取反后便是 false；原来是 false 的，取反后便是 true原来是【女孩:girl:】的取反后就是【男孩:boy:】；原来是【男孩:boy:】的取反后就是【女孩:girl:】
异或运算符测试代码
:house_with_garden:异或符号左右两侧的表达式都是 true 或都是 false 的时候，值是 false
public class Test {
public static void main(String[] args) {
int n1 = 66;
int n2 = 55;
boolean b1 = n1 > 38; // true
boolean b2 = n2 > 1; // true
// b1 ^ b2 = false // 左右两侧都是 true
System.out.println("b1 ^ b2 = " + (b1 ^ b2));
}
}public class Test {
public static void main(String[] args) {
int n1 = 66;
int n2 = 55;
boolean b1 = !(n1 > 38); // 【!true】false
boolean b2 = !(n2 > 1); // 【!true】false
// b1 ^ b2 = false // 左右两侧都是 false
System.out.println("b1 ^ b2 = " + (b1 ^ b2));
}
}:house_with_garden:异或符号左右两侧的表达式的值不一致的时候，值是 true
public class Test {
public static void main(String[] args) {
int n1 = 66;
int n2 = 55;
boolean b1 = n1 > 38; // true
boolean b2 = n2 == 666; // false
// b1 ^ b2 = true
// 左边是 true, 右边是 false (左右两侧的表达式的值不一致)
System.out.println("b1 ^ b2 = " + (b1 ^ b2));
}
}public class Test {
public static void main(String[] args) {
int n1 = 66;
int n2 = 55;
boolean b1 = n1 > 666; // false
boolean b2 = n2 + 1 == 56; // true
// b1 ^ b2 = true
// 左边是 false, 右边是 true (左右两侧的表达式的值不一致)
System.out.println("b1 ^ b2 = " + (b1 ^ b2));
}
}思考下面的例子的输出结果是啥？
:one:
public class Test {
public static void main(String[] args) {
int n1 = 5;
int n2 = 5;
if (n1++ == 6 & ++n2 == 6) {
n1 = 11;
}
System.out.println("n1 = " + n1);
System.out.println("n2 = " + n2);
}
}上面的例子中涉及如下知识点：
① 【=】是赋值运算符
② 【==】是判断两个操作数的地址值是否一样（目前可暂时理解为判断两个操作数的值是否一样）
③ 【&】逻辑与：即使左边的表达式为 false，右边的表达式也会进行运算
④ 【自增运算符】若放操作数前面，先运算；若放操作数后面，后运算
public class Test {
public static void main(String[] args) {
int n1 = 5;
int n2 = 5;
/*
(1) n1++ == 6: 后置自增运算符 --- 后运算, 所以 n1++ 的值还是 5
所以 【n1++ == 6】的值是 false, 同时 n1 的值被修改为了 6
(2) & 的特色：即使左边的表达式的值是 false, 后面的表达式也会执行运算
++n2 是前置增长运算符 --- 先运算, 所以 ++n2 的值是 6
所以目前 n2 的值是6
*/
if (n1++ == 6 & ++n2 == 6) {
n1 = 11;
}
System.out.println("n1 = " + n1); // n1 = 6
System.out.println("n2 = " + n2); // n2 = 6
}
}思考：如果把运算符修改为 &&、| 、|| 结果是啥？
:two:
public class Test {
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
short s = 46;
if ((s++ == 46) && (b2 = true)) s++;
if ((b1 = false) || (++s == 46)) s++;
System.out.println("s = " + s);
}
}上面代码中涉及到的知识点有：
① 自增运算符
② 短路与和短路或
③ 赋值操作的返回值是 true
赋值操作的返回值？
public class Test {
public static void main(String[] args) {
boolean b;
// b1 = true
System.out.println("b = " + (b = true));
// b1 = false
System.out.println("b = " + (b = false));
}
}注释解析：
public class Test {
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
short s = 46;
/*
【s++】后置自增, 所以【s++】的值是 46 --- 【s++ == 46】为true
【s++ == 46】执行完毕后, s 的值变为了 47
【b2 = true】赋值成功后, 值是 true
*/
if ((s++ == 46) && (b2 = true)) s++; // s++ 后值变为：48
/*
【b1 = false】赋值成功后, 值是 false
【++s == 49】需要执行, 【++s == 49】执行完毕后, s 的值是 49
*/
if ((b1 = false) || (++s == 49)) s++; // s++ 后值变为 50
System.out.println("s = " + s); // s = 50
}
}五、赋值运算符
赋值运算符【=】：将某个运算后的值，赋给指定的变量
复合赋值运算符
public class Test {
public static void main(String[] args) {
int a = 9;
int b = 3;
// 【+=】
a += b; // a = a + b
System.out.println("a = " + a); // a = 12
// 【-=】
a -= b; // a = a - b
System.out.println("a = " + a); // a = 9
// 【*=】
a *= b; // a = a * b
System.out.println("a = " + a); // a = 27
// 【/=】
a /= b; // a = a / b
System.out.println("a = " + a); // a = 9
// 【%=】
a %= b; // a = a % b;
System.out.println("a = " + a); // a = 0
}
}六、三目运算符
三目运算符的格式： 【条件表达式 ? 表达式1 : 表达式2】
含义：判断条件表达式的值是多少？如果是 true，执行表达式1；如果是 false，执行表达式2
public class Test {
public static void main(String[] args) {
int num = 66;
String string1 = num > 88 ? "num 大于88" : "num 小于88";
String string2 = num > 3 ? "num 大于3" : "num 小于3";
System.out.println("string1 = " + string1); // string1 = num 小于88
System.out.println("string2 = " + string2); // string2 = num 大于3
}
}三目运算符（三元运算符）可以转换为 if-else 语句
See you!
