- 是对字面量或者变量进行操作的符号
| 符号 | 作用 | 说明 |
|---|---|---|
| + | 加 | 与小学加法同理。 例如：1 + 1 = 2。 int a = 10; int b = 20; int rs = a + b; // rs = 30 |
| - | 减法 | 与小学减法同理。 例如：2 - 1 = 1。 int a = 20; int b = 15; int rs = a - b; // rs = 5 |
| * | 乘 | 与小学乘法同理。 例如：3 * 5 = 15。 int a = 3; int b = 5; int rs = a * b; // rs = 15; |
| / | 除 | 与“÷” 相同（但是注意：在Java中两个整数相除结果还是整数）。 例如：15 / 5 = 3; int a = 15; int b = 5; int rs = a / b; //rs = 3; |
| % | 取余 | 获取的是两个数据做除法的余数 例如：16 % 5 = 1（16 / 5 = 3 余数：1） int a = 16; int b = 5; int rs = a % b; // rs = 1 |
package com.app.operator;
public class OperatorDemo1 {
public static void main(String[] args) {
// 目标：掌握基本的算术运算符：+ - * / %
// 先定义两个变量a、b，用做基本的算术运算
int a = 10;
int b = 4;
// 1.+：两个变量、数据做加法运算
int addUp = a + b;
System.out.print("a + b = ");
System.out.println(addUp); // 14
// 2.-：两个变量、数据做减法运算
int subtract = a - b;
System.out.print("a - b = ");
System.out.println(subtract); // 6
// 3.*：两个变量、数据做乘法运算
int multiply = a * b;
System.out.print("a * b = ");
System.out.println(multiply); // 40
// 4./：两个变量、数据做除法运算
int divide = a / b;
// 如果你非要准确的结果，小技巧: 先乘以 1.0（注意：不要放后面乘，乘除属于同级运算，会从左往右乘）
double divide2 = a * 1.0 / b;
// 把 1.0 放后面乘
double divide3 = a / b * 1.0;
System.out.print("int类型： a / b = ");
System.out.println(divide); // 2
System.out.print("double类型：a * 1.0 / b = ");
System.out.println(divide2); // 2.5
System.out.print("double类型：a / b * 1.0 = ");
System.out.println(divide3); // 2.0
// 5.%：两个变量、数据做除法的余数
int remainder = a % b; // 10 / 4 = 8 余 2
System.out.print("a % b = ");
System.out.println(remainder); // 2
}
}
输出结果： a + b = 14 a - b = 6 a * b = 40 int类型： a / b = 2 double类型：a * 1.0 / b = 2.5 double类型：a / b * 1.0 = 2.0 a % b = 2二、案例：数值拆分
需求：一个三位数，将其拆分为个位、十位、百位后，打印在控制台
例： 请输入整数： 123 整数123的个位为：3 整数123的十位为：2 整数123的百位为：1
package com.app.operator;
public class OperatorTest2 {
public static void main(String[] args) {
// 1.定义一个int类型的变量number，初始值为：678
int number = 678;
// 2.将 678 拆分为个位、十位、百位（除、取余）
int ge = number % 10; // 678 / 10 = 67 余8
// 678 / 10 = 67 余8 再将 67 % 10 = 7（67 / 10 = 6 余 7）
int shi = number / 10 % 10;
// 678 / 100 = 6.78，由于表达式最高类型是整数类型，所以最终结果是整数
int bai = number / 100;
// 3.分别打印在控制台
System.out.print("整数678的个位为：");
System.out.println(ge);
System.out.print("整数678的十位为：");
System.out.println(shi);
System.out.print("整数678的百位为：");
System.out.println(bai);
}
}
输出结果： 整数678的个位为：8 整数678的十位为：7 整数678的百位为：6三、“+” 做连接符
- “+” 符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串。
-
独门秘籍
- 能算则算，不能算就在一起。
package com.app.operator;
public class OperatorDemo3 {
public static void main(String[] args) {
// 目标：掌握“+”符号与字符串的连接操作
// 1.定义一个int类型的变量，初始值随便给，用于识别 + 符号连接操作
int a = 5;
// 'A'的在ASCII码表对应的数字是：65
System.out.println("三国五虎上将有" + a + "个人"); // 三国五虎上将有5个人
System.out.println("张飞和关羽有" + 'a' + "个兄弟"); // 张飞和关羽有a个兄弟
System.out.println(a + 'A'); // 70
System.out.println("acd" + a + 'A'); // acd5A
System.out.println(10 + "go" + 5); // 10go5
System.out.println(a + "" + 'A'); // 5A
System.out.println(a + 'A' + "个张飞"); // 70个张飞
System.out.println("关羽有个" + a + 'A');// 关羽有个5A
System.out.println("关羽有" + ('A' - a) + "个兄弟"); // 关羽有60个兄弟
}
}
输出结果： 三国五虎上将有5个人 张飞和关羽有a个兄弟 70 acd5A 10go5 5A 70个张飞 关羽有个5A 关羽有60个兄弟四、自增自减运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 自增 | 变量自身的值加1 |
| – | 自减 | 变量自身的值减1 |
-
++ 和 – 既可以放在变量的后边，也可以放在变量的前边
-
++、-- 只能操作变量，不能操作字面量的
-
例如：
++1、--1、1++、1-- // 这些都是错误的 // 正确用法 int a = 1; int b = a++; int c = a--; int d = ++a; int e = --a;
-
-
自增、自减运用场景，举例：抖音短视频双击红心功能
例如：
package com.app.operator; public class OperatorDemo4 { public static void main(String[] args) { // 目标：掌握自增、自减运算符：++、-- // 定义一个int类型的变量love，用于存放用户点亮的红心，初始值为0 int love = 0; // 用户觉得这个视频不错。点亮红心了 +1 (注意：++ 放在变量的前边或者后边，结果都一样) // love++; // love = love + 1; ++love; System.out.println(love); // 用户觉得被这个视频骗到了。取消了点亮的红心 -1 (注意：-- 放在变量的前边或者后边，结果都一样) // love--; // love = love - 1; --love; System.out.println(love); } }输出结果： 1 0
-
++、-- 如果不是单独使用（如在表达式中、或者同时有其它操作），放在变量前后会存在明显区别
-
放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算
-
放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1
例如：
package com.app.operator; public class OperatorDemo4 { public static void main(String[] args) { // 目标：掌握自增、自减运算符：++、-- System.out.println("++、-- 单独使用时，放在变量前后不存在区别"); // 定义一个int类型的变量love，用于存放用户点亮的红心，初始值为0 int love = 0; // 用户觉得这个视频不错。点亮红心了 +1 (注意：++ 放在变量的前边或者后边，结果都一样) // love++; ++love; System.out.println(love); // 用户觉得被这个视频骗到了。取消了点亮的红心 -1 (注意：-- 放在变量的前边或者后边，结果都一样) // love--; --love; System.out.println(love); System.out.println("-----------------------------------"); System.out.println("++、-- 不是单独使用时，放在变量前后会存在明显区别"); // 1.++、-- 放在变量的前面，先+1、-1，再使用变量 int i = 10; System.out.println("i = " + i); System.out.println("++放在变量前面，先+1，再使用变量"); int j = ++i; System.out.println("i = " + i); System.out.println("j = " + j); System.out.println("-----------------------------------"); int m = 10; System.out.println("m = " + m); System.out.println("--放在变量前面，先-1，再使用变量"); int l = --m; System.out.println("m = " + m); System.out.println("l = " + l); System.out.println("-----------------------------------"); // 2.++、-- 放在变量的后面，先使用变量，再+1、-1 int number = 20; System.out.println("number = " + number); System.out.println("++放在变量后面，先使用变量，再+1"); int number2 = number++; System.out.println("number = " + number); System.out.println("number2 = " + number2); System.out.println("-----------------------------------"); int number3 = 20; System.out.println("number3 = " + number3); System.out.println("--放在变量后面，先使用变量，再-1"); int number4 = number3--; System.out.println("number3 = " + number3); System.out.println("number4 = " + number4); } }++、-- 单独使用时，放在变量前后不存在区别 1 0 ----------------------------------- ++、-- 不是单独使用时，放在变量前后会存在明显区别 i = 10 ++放在变量前面，先+1，再使用变量 i = 11 j = 11 ----------------------------------- m = 10 --放在变量前面，先-1，再使用变量 m = 9 l = 9 ----------------------------------- number = 20 ++放在变量后面，先使用变量，再+1 number = 21 number2 = 20 ----------------------------------- number3 = 20 --放在变量后面，先使用变量，再-1 number3 = 19 number4 = 20
-
package com.app.operator;
public class OperatorTest5 {
public static void main(String[] args) {
// 目标：练习自增、自减拓展案例（有些面试题会出现）
int c = 10;
int d = 5;
// c:10 11 12 11 c————> 最终变成了 11
// d:5 4 5 d————> 最终变成了 5
// rs: = 10 + 12 - 4 - 5 +1 + 12 rs————>结果 = 26
int rs = c++ + ++c - --d - ++d +1 + c--;
System.out.println("c = " + c); // 11
System.out.println("d = " + d); // 5
System.out.println("rs = " + rs); // 26
}
}
输出结果： c = 11 d = 5 rs = 26六、赋值运算符 基本赋值运算符
-
就是 “=”（常用）
int a = 10; // 先看 “=” 右边，把数据10 赋值给 左边的int类型变量a存储
| 符号 | 作用 | 说明 |
|---|---|---|
| +=（常用） | 加后赋值 | a += b 等价于 a = (a的数据类型)(a + b); 将a + b的值给a |
| -= | 减后赋值 | a -= b 等价于 a = (a的数据类型)(a - b); 将a - b的值给a |
| *= | 乘后赋值 | a *= b 等价于 a = (a的数据类型)(a * b); 将a * b的值给a |
| /= | 除后赋值 | a /= b 等价于 a = (a的数据类型)(a / b); 将a / b的值给a |
| %= | 取余后赋值 | a %= b 等价于 a = (a的数据类型)(a %= b); 将a % b的值给a |
注意：扩展的赋值运算符隐含了强制类型转换
package com.app.operator;
public class OperatorDemo6 {
public static void main(String[] args) {
// 目标：掌握赋值运算符：=、+=、-=、*=、/=、%=
int a = 10;
int b = 200;
// a = a + b; //以前的写法
a += b; // 等价于 a = (int)(a + b); 会自带强制类型转换
System.out.println("a+=b = " + a);
byte i = 10;
byte j = 20;
// i = (byte) (i + j);
i += j; // 等价于 i = (byte) (i + j);
System.out.println("i+=j = " + i);
int m = 30;
int n = 5;
m += n; // 等价于 m = (int)(m + n); // m = (int)(30 + 5)，m = 35;
System.out.println("m+=n = " + m);
m -= n; // 等价于 m = (int)(m - n); // m = (int)(35 - 5)，m = 30;
System.out.println("m-=n = " + m);
m *= n; // 等价于 m = (int)(m * n); // m = (int)(30 * 5)，m = 150;
System.out.println("m*=n = " + m);
m /= n; // 等价于 m = (int)(m / n); // m = (int)(30 / 5)，m = 30;
System.out.println("m/=n = " + m);
m %= n; // 等价于 m = (int)(m % n); // m = (int)(30 % 5)，m = 0;
System.out.println("m%=n = " + m);
}
}
输出结果： a+=b = 210 i+=j = 30 m+=n = 35 m-=n = 30 m*=n = 150 m/=n = 30 m%=n = 0七、关系运算符
- 是对数据进行条件判断的符号，最终会返回一个比较的布尔结果（true（真），false（假））
| 符号 | 说明 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b， 判断a和b的值是否不相等，成立为true，不成立为false |
| > | a>b， 判断a的值是否大于b的值，成立为true，不成立为false |
| >= | a>=b，判断a的值是否大于等于b的值，成立为true，不成立为false |
| < | a |
| <= | a<=b，判断a的值是否小于等于b的值，成立为true，不成立为false |
- 在做相等判断时，千万不要把 == 误写成 =
package com.app.operator;
public class OperatorDemo7 {
public static void main(String[] args) {
int a = 10; // 定义int类型变量a，初始值为10
int b = 10; // 定义int类型变量b，初始值为10
boolean rs = a == b; // true，因为10 == 10
boolean rs2 = a != b; // false，因为10 == 10，所以10 != 10，不成立
boolean rs3 = a > b; // false，因为10 == 10，所以10 > 10，不成立
boolean rs4 = a >= b; // true，因为10 == 10，所以10 >= 10，满足等号，成立
boolean rs5 = a < b; // false，因为10 == 10，所以10 < 10，不成立
boolean rs6 = a <= b; // true，因为10 == 10，所以10 <= 10，满足等号，成立
// 打印各比较结果
System.out.println("a==b = " + rs);
System.out.println("a!=b = " + rs2);
System.out.println("a>b = " + rs3);
System.out.println("a>=b = " + rs4);
System.out.println("a d2; // false
boolean b4 = d >= d2; // false
boolean b5 = d < d2; // true
boolean b6 = d <= d2; // true
// 打印各比较结果
System.out.println("d==d2 = " + b1);
System.out.println("d!=d2 = " + b2);
System.out.println("d>d2 = " + b3);
System.out.println("d>=d2 = " + b4);
System.out.println("d
输出结果：
a==b = true
a!=b = false
a>b = false
a>=b = true
ad2 = false
d>=d2 = false
d
八、逻辑运算符
-
可以把多个条件的布尔结果放在一起运算，最终返回一个布尔结果
符号 介绍 说明 & 逻辑与 必须都是true，结果才是true；只要有一个是false，结果一定是false | 逻辑或 只要有一个true，结果就是true ! 逻辑非 你真我假、你假我真、非真既假。!true = false、!false = true ^ 逻辑异或 如果两个条件都是false 或者 都是true 则结果是false。两个条件不同结果是true。
- 像京东、淘宝，你搜索一台笔记本或者一台手机，是不是要筛选品牌、屏幕尺寸、存储内存等等这些多个条件啊，这些都是要用到逻辑运算符的
package com.app.operator;
public class OperatorDemo8 {
public static void main(String[] args) {
// 1.定义两个double类型的变量，分别用于存储笔记本屏幕尺寸、存储内存容量
double size = 14.3;
double storage = 256;
System.out.println("------------- 逻 辑 与 -------------");
// 需求：尺寸要大于等于14.3，内存要大于等于128GB
// 注意：&——逻辑与运算符 必须前后的条件都是true，结果才为true
boolean logicalAnd = size >= 14.3 & storage >= 128; // 屏幕尺寸与内存结果都为true，所以最终结果也为true
boolean logicalAnd1 = size >= 14.3 & storage <= 128; // 屏幕尺寸为true，但是内存不为true，所以最终结果为false
System.out.println("logicalAnd = " + logicalAnd);
System.out.println("logicalAnd1 = " + logicalAnd1);
System.out.println("------------- 逻 辑 或 -------------");
// 需求：要么尺寸大于等于14.3，要么内存大于等于1TB=1024GB
// 注意：|——逻辑或运算符 只要有一个条件是true，结果就为true
boolean logicalOr = size >= 14.3 | storage >= 1024;
System.out.println("logicalOr = " + logicalOr); // 屏幕尺寸结果为true，内存结果为false，所以满足条件之一，最终结果为true
System.out.println("------------- 逻 辑 非 -------------");
// 注意：逻辑非是非真既假、你真我假、你假我真
boolean logicalNot = !true; // false
boolean logicalNot1 = !false; // true
System.out.println("logicalNot = " + logicalNot);
System.out.println("logicalNot1 = " + logicalNot1);
System.out.println("------------- 逻辑异或 -------------");
// 注意：逻辑异或：两个结果都为true 或 都为false，则最终结果为false；两个结果不同才为true
boolean logicalXOR = true ^ true; // false
boolean logicalXOR1 = false ^ false; // false
boolean logicalXOR2 = true ^ false; // true
boolean logicalXOR3 = false ^ true; // true
System.out.println("logicalXOR = " + logicalXOR);
System.out.println("logicalXOR1 = " + logicalXOR1);
System.out.println("logicalXOR2 = " + logicalXOR2);
System.out.println("logicalXOR3 = " + logicalXOR3);
}
}
输出结果：
------------- 逻 辑 与 -------------
logicalAnd = true
logicalAnd1 = false
------------- 逻 辑 或 -------------
logicalOr = true
------------- 逻 辑 非 -------------
logicalNot = false
logicalNot1 = true
------------- 逻辑异或 -------------
logicalXOR = false
logicalXOR1 = false
logicalXOR2 = true
logicalXOR3 = true
短逻辑运算符
符号 介绍 说明 && 短路与 判断结果与 “&（逻辑与）”一样。过程是左边为 false，右边则不执行 || 短路或 判断结果与“|（逻辑或）”一样。过程是左边为 true，右边则不执行
注意
- 逻辑与（&）、逻辑或（|）无论左边是 true 还是 false，右边都要执行！！
逻辑与（&）、逻辑或（|）、短路与（&&）、短路或（||）的区别
package com.app.operator;
public class OperatorDemo9 {
public static void main(String[] args) {
// 目标：理解逻辑与（&）、逻辑或（|）、短路与（&&）、短路或（||）的区别
int a = 10;
int b = 20;
System.out.println("------------------ 逻 辑 与（&） ------------------");
// 1.逻辑与：&——>无论左边判断结果是true还是false，右边依然会执行
boolean logicalAnd = a > 2 & ++b > 10; //左边判断结果为true，利用 ++b来改变b变量的值，方便观察 & 是否执行右边
System.out.println("logicalAnd = " + logicalAnd);
System.out.println("b = " + b); // 20变21，说明 & 左边判断结果为true时，依然执行右边判断
boolean logicalAnd1 = a < 2 & ++b > 10; //左边判断结果为false，利用 ++b来改变b变量的值，方便观察 & 是否执行右边
System.out.println("logicalAnd1 = " + logicalAnd1);
System.out.println("b = " + b); // 21变22，说明 & 左边判断结果为false，依然执行右边判断
System.out.println("------------------ 短 路 与（&&） ------------------");
// 2.短路与：&&——>左边判断结果为false，右边则不会执行，直接短路
boolean dly = a < 2 && ++b > 10; // 左边判断结果为false，利用 ++b来改变b变量的值，方便观察 && 是否执行右边
System.out.println("dly = " + dly);
System.out.println("b = " + b); // b的值依然是22，说明 && 左边判断结果为false，右边则不会执行
boolean dly2 = a > 2 && ++b > 10; // 左边判断结果为true，利用 ++b来改变b变量的值，方便观察 && 是否执行右边
System.out.println("dly2 = " + dly2);
System.out.println("b = " + b); // 22变23，说明 && 左边判断结果为true，右边会执行
System.out.println("------------------ 逻 辑 或（|） ------------------");
boolean logicalOr = a > 2 | ++b < 10; // 左边判断结果为true，利用 ++b来改变b变量的值，方便观察 | 是否执行右边
System.out.println("logicalOr = " + logicalOr);
System.out.println("b = " + b); // 23变24，说明 | 左边判断结果为true，右边会执行
boolean logicalOr2 = a < 2 | ++b > 10; // 左边判断结果为false，利用 ++b来改变b变量的值，方便观察 | 是否执行右边
System.out.println("logicalOr2 = " + logicalOr2);
System.out.println("b = " + b); // 24变25，说明 | 左边判断结果为false，右边会执行
System.out.println("------------------ 短 路 或（||） ------------------");
boolean dlh = a > 2 || ++b < 10; // 左边判断结果为true，利用 ++b来改变b变量的值，方便观察 || 是否执行右边
System.out.println("dlh = " + dlh);
System.out.println("b = " + b); // b的值25没有改变，说明 || 左边判断结果为true，右边则不会执行
boolean dlh2 = a < 2 || ++b > 10; // 左边判断结果为false，利用 ++b来改变b变量的值，方便观察 || 是否执行右边
System.out.println("dlh2 = " + dlh2);
System.out.println("b = " + b); // 25变26，说明 || 左边判断结果为false，右边会执行
}
}
输出结果：
------------------ 逻 辑 与（&） ------------------
logicalAnd = true
b = 21
logicalAnd1 = false
b = 22
------------------ 短 路 与（&&） ------------------
dly = false
b = 22
dly2 = true
b = 23
------------------ 逻 辑 或（|） ------------------
logicalOr = true
b = 24
logicalOr2 = true
b = 25
------------------ 短 路 或（||） ------------------
dlh = true
b = 25
dlh2 = true
b = 26
九、三元运算符
-
格式：
条件表达式 ? 值1 : 值2;
-
执行流程：首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2
package com.app.operator;
public class OperatorDemo10 {
public static void main(String[] args) {
// 目标：掌握三元运算符，理解其流程
// 1.定义学生名字为小明，成绩为98分，使用三元运算符判断这个成绩是否考试通过或挂科
String name = "小明";
double score = 98;
String result = score >= 60 ? "考试通过" : "挂科";
System.out.println(name + "同学考得成绩：" + score + "，所以" + result + "了！");
// 2.定义学生名字为晓东，成绩为59.5分，使用三元运算符判断这个成绩是否考试通过或挂科
String name2 = "晓东";
double score2 = 59.5;
String result1 = score2 >= 60 ? "考试通过" : "挂科";
System.out.println(name2 + "同学考得成绩：" + score2 + "，所以" + result1 + "了！！！");
}
}
输出结果：
小明同学考得成绩：98.0，所以考试通过了！
晓东同学考得成绩：59.5，所以挂科了！！！
小案例巩固
- 需求：从2个整数中找出较大值
package com.app.operator;
public class OperatorTest11 {
public static void main(String[] args) {
// 小案例：需求——>需要从2个整数中找出较大值
// 1.定义两个int类型的变量存放两个整数
int a = 100;
int b = 2000;
// 2.使用三元运算符将两个整数进行比较，假如：100 > 2000 如果为true，返回值100，否则返回值2000
int max = a > b ? a : b;
System.out.println("整数" + a + "与整数" + b + "中较大值为：" + max);
// 3.定义两个int类型的变量存放两个整数
int c = 10000;
int d = 5000;
// 4.使用三元运算符将两个整数进行比较，假如：10000 > 5000 如果为true，返回值10000，否则返回值5000
int max1 = c > d ? c : d;
System.out.println("整数" + c + "与整数" + d + "中较大值为：" + max1);
}
}
输出结果：
整数100与整数2000中较大值为：2000
整数10000与整数5000中较大值为：10000
十、案例：
-
求三个整数的最大值
-
分析：
-
（1）先用三元运算符获取前两个整数的最大值，并用临时变量存起来
-
（2）然后用三元运算符，让临时最大值与第三个整数进行比较，得出三个整数的最大值
-
（3）打印输出三个整数的最大值
package com.app.operator;
public class OperatorTest12 {
public static void main(String[] args) {
// 1.定义三个int类型的变量，用于分别存放三个整数，用于求三个整数最大值
int a = 1900;
int b = 5;
int c = 20000;
// 2.先用三元运算符将前两个整数进行比较，用临时变量存起来
int tempMax = a > b ? a : b;
// 3.然后用三元运算符将临时最大值与第三个整数进行比较，得出三个整数的最大值
int max = tempMax > c ? tempMax : c;
// 4.打印输出三个整数的最大值
System.out.println("整数" + a + "、整数" + b + "、整数" + c + "，这三个整数的最大值为：" + max);
}
}
输出结果：
整数1900、整数5、整数20000，这三个整数的最大值为：20000
三元运算符拓展知识
-
三元运算符的嵌套
-
求三个整数的最大值
-
分析：
-
用三元运算符嵌套比较——>
假如：第一个 大于 第二个 问 (如果为true：属于第一个整数胜出，接着假如：第一个 大于 第三个 问 如果为true：则值1：第一个 : 值2：第三个) : (假如：第一个 小于 第二个：属于第二个整数胜出，接着假如：第二个 大于 第三个 问 如果为true：则值1：第二个 : 值2：第三个 );
package com.app.operator;
public class OperatorTest12 {
public static void main(String[] args) {
// 1.定义三个int类型的变量，用于分别存放三个整数，用于求三个整数最大值
int a = 1900;
int b = 5;
int c = 20000;
// 2.先用三元运算符将前两个整数进行比较，用临时变量存起来
int tempMax = a > b ? a : b;
// 3.然后用三元运算符将临时最大值与第三个整数进行比较，得出三个整数的最大值
int max = tempMax > c ? tempMax : c;
// 4.打印输出三个整数的最大值
System.out.println("整数" + a + "、整数" + b + "、整数" + c + "，这三个整数的最大值为：" + max);
System.out.println("-------------------三元运算符拓展知识----------------");
// 1.定义三个int类型的变量，用于分别存放三个整数，用于求三个整数最大值
int i = 1900;
int j = 5;
int k = 20000;
// 2.使用三元运算符嵌套： 条件表达式 ? 值1 : 值2 ;
// 不拆分形式为： i > j ? (i > k ? i : k) : (j > k ? j : k);
int max1 = i > j ? i > k ? i : k : j > k ? j : k; // 拆分形式
// 4.打印输出三个整数的最大值
System.out.println("整数" + i + "、整数" + j + "、整数" + k + "，这三个整数的最大值为：" + max1);
}
}
输出结果：
整数1900、整数5、整数20000，这三个整数的最大值为：20000
-------------------三元运算符拓展知识----------------
整数1900、整数5、整数20000，这三个整数的最大值为：20000
十一、运算符优先级
-
在表达式中，哪个运算符先执行后执行是要看优先级的，例如 “*、/” 的优先级高于 “+、-”
优先级 运算符 1 () 2 !、-、++、– 3 *、/、% 4 +、- 5 <<、>>、>>> 6 <、<=、>、>=、instanceof 7 ==、!= 8 & 9 ^ 10 | 11 && 12 || 13 ? : 14 =、+=、-=、*=、/=、%=、&=
package com.app.operator;
public class OperatorDemo13 {
public static void main(String[] args) {
// 目标：看看Java是否存在优先级，大家以后需注意优先级问题
//因为 && 的优先级比 || 的高，所以先比较 && 的左和右，很明显&&的结果为false
//后比较 || 的左和右，左为true，所以不会执行右边，则||结果为true
System.out.println(10 > 3 || 10 > 3 && 10 < 3); // true
//因为 () 的优先级是最高的，所以先比较 () 里的 || 的左和右，则||的结果为true
//后比较 && 的左和右，左为true，则右为false，则&&结果为false
System.out.println((10 > 3 || 10 > 3) && 10 < 3); // false
}
}
输出结果：
true
false
十二、总结
基本的算术运算符
1、基本的算术运算符有哪些？
- +、-、*、/、%
2、“/” 需要注意什么，为什么？
- 如果两个整数做除法，其结果一定是整数，因为最高类型是整数类型
“+”符号做连接符
1、+ 符号除了做基本的算术运算，还有哪些功能？
- 与字符串做 + 运算时会被当成连接符，其结果还是字符串
- 能算则算，不能算就在一起
自增自减
1、自增、自减运算符是什么，有什么作用？
- ++、–。对当前变量值+1、-1
- 例如：抖音短视频的点亮红心功能——>双击了，就红心++；取消了，就红心–；或 ++红心、–红心
2、自增、自减运算符在变量前后有区别吗？
- 如果单独使用方前后是没有区别的
- 非单独使用：++、-- 在变量前，先进行变量自增/自减，再使用变量
- 非单独使用：++、-- 在变量后，先使用变量，再进行变量自增/自减
赋值运算符
1、赋值运算符有哪些？
- =、+=、-=、*=、/=、%=
2、作用是什么？
- 基本作用是赋值
- += 可以实现数据的累加，把别人的数据加给自己
关系运算符
1、什么是关系运算符？
- 对数据进行条件判断的符号，最终会返回一个比较的布尔结果（true—>真，false—>假）
2、在做相等判断时，需注意什么呢？
-
不要将 == 误写成 = ，因为 = 是进行赋值操作，将右边的值 赋值给 左边
例如：
int a = 10;
int b = 2;
System.out.println(a = b);
输出结果：
2
逻辑运算符
1、逻辑运算符有哪些，有什么特点？
- 逻辑与（&）：有一个false，结果是false，两个都为true结果才为true
- 短路与（&&）：有一个false，结果是false。左边为false，则不会执行右边，因为满足不了两个都为true，所以直接短路（性能更好）
- 逻辑或（|）：有一个true，结果是true
- 短路或（||）：有一个为true，结果是true。左边为true，则不会执行右边，因为已经满足一个true，所以直接短路（性能更好）
- 逻辑非（!）：!true=false; !false=true;（非真既假）
- 逻辑异或（^）：相同是false，不同是true
- 注意：实际开发中，常用的逻辑运算符是：&&、||、!
