目录
[1. 基本四则运算符：加减乘除模(+ - * / %)](#1. 基本四则运算符：加减乘除模(+ - * / %))
[2.增量运算符 += -= *= %=](#2.增量运算符 += -= *= %=)
[3. ⾃增/⾃减运算符 ++ --](#3. ⾃增/⾃减运算符 ++ --)
[2.逻辑 ||](#2.逻辑 ||)
[3.逻辑⾮ !](#3.逻辑⾮ !)
[1. 按位与&：](#1. 按位与&：)
[2. 按位或 | :](#2. 按位或 | :)
[3. 按位取反~:](#3. 按位取反~:)
[4. 按位异或^:](#4. 按位异或^:)
[3.⽆符号右移 >>>](#3.⽆符号右移 >>>)
内容概况：
本文详细介绍了Java中的各类运算符及其使用方法。主要内容包括：
1）算术运算符（+、-、*、/、%等）的使用规则和注意事项；
2）关系运算符（==、!=、>、<等）的布尔值返回特性；
3）逻辑运算符（&&、||、!）的运算规则和短路求值特性；
4）位运算符（&、|、~、^）的二进制位操作；
5）移位运算符（<<、>>、>>>）的位移规则；
6）条件运算符（?:）的三目运算特性。
文章还强调了运算符优先级问题，建议在复杂表达式中使用括号明确运算顺序。这些运算符是Java编程的基础，掌握它们对编写正确高效的程序至关重要。
一：什么是运算符
计算机的最基本的⽤途之⼀就是执⾏数学运算，⽐如：
int a = 10; int b = 20;
a + b;
a < b;
上述 + 和 < 等就是运算符 ，即：对操作数进⾏操作时的符号，不同运算符操作的含义不同。 作为⼀⻔计算机语⾔，Java也提供了⼀套丰富的运算符来操纵变量。Java中运算符可分为以下：算术 运算符**(+ - * /)** 、关系运算符**(< > ==)**、逻辑运算符、位运算符、移位运算符以及条件运算符等。
二：算术运算符
1. 基本四则运算符：加减乘除模(+ - * / %)
代码如下：
java
public static void main(String[] args) {
int a = 20;
int b = 10;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a % b);
}输出：
注意：
1.模运算相当于数学中除法的余数
2.都是⼆元运算符，使⽤时必须要有左右两个操作数
3.int/int结果还是int类型，⽽且会向下取整（和C语言差不多）
看代码：
java
public static void main(String[] args) {
int a = 3;
int b = 2;
System.out.println(a / b);//1
}结果：
和C语言一样，整型变量的除法，会自动去除小数点，保留整数位
如果想要得出小数点后面的数字，我们需要浮点型 来进行计算**（和C语言也是一样的）**
java
public static void main(String[] args) {
int a = 3;
int b = 2;
double d = a*1.0 / b;
System.out.println(d);
}结果：
4.做除法和取模时，右操作数不能为0
看代码：
java
public static void main(String[] args) {
int a = 1;
int b = 0;
System.out.println(a / b)
}结果会报错：
5. %不仅可以对整型取模，也可以对double类型取模，但是没有意义，⼀般都是对整型取模的
看代码：
java
public static void main(String[] args) {
System.out.println(11.5 % 2.0);
}结果是1.5
6.两侧操作数类型不⼀致时，向类型⼤的提升
看代码：
整型变量1和浮点型变量0.2，注意这里会变量提升，小的int会提升为double类型的数
java
public static void main(String[] args) {
System.out.println(1+0.2);
}结果是1.2：
2.增量运算符 += -= *= %=
该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。（和C语言一样）
看代码：
java
public static void main(String[] args) {
int a = 1;
a += 2;
System.out.println(a);
a -= 1;
System.out.println(a);
a *= 3;
System.out.println(a);
a /= 3;
System.out.println(a);
a%=3;
System.out.println(a);
}结果：
注意：增量运算符在计算的时候，可以不进⾏强制类型转换
double a = 10.4;
int b = 10;
b += a; // 不会报错
b = b + a; // 此时会编译报错，等号右边被提升为了 double 类型，放入了int类型，所以会报错
3. ⾃增/⾃减运算符 ++ --
++是给变量的值+1，--是给变量的值-1**（和C语言一样）**
这里就举例加法，减法就不演示了
前置++(先加1再使用）
看代码：
java
public static void main(String[] args) {
int a=1;
System.out.println(a);//1
System.out.println(++a); //2
}结果：
后置++（先使用再+1）
看代码：
java
public static void main(String[] args) {
int a= 1;
System.out.println(a);
System.out.println(a++);
System.out.println(a);
}结果是1 1 2：
注意：
• 如果单独使⽤，【前置++】和【后置++】没有任何区别
• 如果混合使⽤，【前置++】先+1，然后使⽤变量+1之后的值，【后置++】先使⽤变量原来的值， 表达式结束时给变量+1
• 只有变量才能使⽤⾃增/⾃减运算符，常量不能使⽤，因为常量不允许被修改
三：关系运算符
关系运算符主要有六个：== != < > = ，其计算结果是true 或者false
看代码：
java
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a == b);
System.out.println(a != b);
System.out.println(a < b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a >= b);
}结果只能是true或者false ：
注意：
当需要多次判断时，不能连着写，比如3<a<5，这是错误的写法，只能拆开一个一个写
四：逻辑运算符(重点)
逻辑运算符主要有三个: && || ! 运算结果都是boolean类型。
1.逻辑与&&
一句话：同为真，才是真，否则为假
-
语法规则：表达式1&&表达式2，左右表达式必须是boolean类型的结果。
-
相当于现实⽣活中的且，⽐如：如果是学⽣，并且带有学⽣证才可以享受半票。
-
两个表达式都为真，结果才是真，只要有⼀个是假，结果就是假。
看图：
代码演示：
java
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2);
System.out.println(a == 1 && b > 100);
System.out.println(a > 100 && b == 2);
System.out.println(a > 100 && b > 100);
}结果：
2.逻辑 ||
一句话： 同为假，才是假，否则为真
语法规则：表达式1||表达式2，左右表达式必须是boolean类型的结果。
相当于现实⽣活中的或，⽐如：买房⼦交钱时，全款或者按揭都可以，如果全款或者按揭，房⼦都是 你的，否则站⼀边去。
看图：
代码演示：
java
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2);
System.out.println(a == 1 || b > 100);
System.out.println(a > 100 || b == 2);
System.out.println(a > 100 || b > 100);
}结果：
3.逻辑⾮ !
语法规则：! 表达式
真变假，假变真
看图（不演示代码了）：
4.短路求值
&&和||遵守短路求值的规则
说白了就是，当你前面的一个表达式已经可以判断最终的答案的时候，后面的也就不会再去判断了
看代码：
java
public static void main(String[] args) {
System.out.println(10 > 20 && 10 / 0 == 0);
System.out.println(10 < 20 || 10 / 0 == 0);
}结果：
我们都知道,计算10 / 0 会导致程序抛出异常，但是上⾯的代码却能正常运⾏,说明10 / 0并没有真正被求值.
注意:
1.对于&&,如果左侧表达式值为false,则表达式结果⼀定是false,⽆需计算右侧表达式.
2.对于||,如果左侧表达式值为true,则表达式结果⼀定是true,⽆需计算右侧表达式.
3.& 和 | 如果表达式结果为boolean时,也表⽰逻辑运算.但与&& || 相⽐,它们不⽀持短路求值.
看代码：
java
public static void main(String[] args) {
System.out.println(10 > 20 & 10 / 0 == 0);
System.out.println(10 < 20 | 10 / 0 == 0);
}结果会报错：
五：位运算符
Java 中数据存储的最⼩单位是字节，⽽数据操作的最⼩单位是⽐特位.字节是最⼩的存储单位，每个 字节是由8个⼆进制⽐特位组成的，多个字节组合在⼀起可以表⽰各种不同的数据。
位运算符主要有四个:& | ~ ^，除 ~ 是⼀元运算符外，其余都是⼆元运算符。
位操作表⽰按⼆进制位运算.计算机中都是使⽤⼆进制来表⽰数据的(01构成的序列),按位运算就是在 按照⼆进制位的每⼀位依次进⾏计算.
1. 按位与&：
如果两个⼆进制位都是1,则结果为1,否则结果为0
**一句话概括：**同为1则为1，否则为0
这里的内部计算过程我就不解释了，和C语言的一模一样，原码、反码、补码等
看代码：
java
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a & b);
}结果是0：
进⾏按位运算,需要先把10和20转成⼆进制,分别为1010和10100
看图：
2. 按位或 | :
如果两个⼆进制位都是0,则结果为0,否则结果为1.
一句话：同为0则为0，否则是1
看代码：
java
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a | b);
}结果是30：
运算⽅式和按位于类似，看图：
注意:
当&和|的操作数为整数(int,short,long,byte)的时候,表⽰按位运算,当操作数为boolean的 时候,表⽰逻辑运算.
3. 按位取反~:
如果该位为0则转为1,如果该位为1则转为0
这里就不演示了，和C语言一样
4. 按位异或^:
如果两个数字的⼆进制位相同,则结果为0,相异则结果为1
一句话：相同为0，否则为1
六：移位运算(了解)
移位运算符有三个: << >> >>>，都是⼆元运算符，且都是按照**⼆进制**⽐特位来运算的。
1.左移<<
最左侧位不要了,最右侧补0**(和C语言一样）**
注意：
向左移位时，丢弃的是符号位，因此正数左移可能会变成负数。
2.右移>>
最右侧位不要了,最左侧补符号位(正数补0,负数补1)
3.⽆符号右移 >>>
最右侧位不要了,最左侧补0
注意:
1. 左移1位,相当于原数字*2.左移N位,相当于原数字*2的N次⽅.【针对正数⽽⾔】
2. 右移1位,相当于原数字/2.右移N位,相当于原数字/2的N次⽅.【针对正数⽽⾔】
3. 由于计算机计算移位效率⾼于计算乘除,当某个代码正好乘除2的N次⽅的时候可以⽤移位运算代 替.【针对正数⽽⾔】
4. 移动负数位或者移位位数过⼤都没有意义.
思考：如果是负数进⾏左移和右移，怎么计算结果？
七：条件运算符
条件运算符只有⼀个:
表达式 1 ? 表达式 2 : 表达式 3
当表达式 1 的值为true时,整个表达式的值为 表达式 2 的值;
当表达式 1 的值为false时,整个表达式的值为 表达式 3 的值.
也是Java中唯⼀的⼀个三⽬运算符,是条件判断语句的简化写法.
看代码：
java
public static void main(String[] args) {
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max);
}结果是20：
注意：
1. 表达式2和表达式3的结果要是同类型的，除⾮能发⽣类型隐式类型转换
看代码：
java
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;
}结果会报错：
2. 表达式不能单独存在，其产⽣的结果必须要被使⽤。
看代码：
java
public static void main(String[] args) {
int a = 10;
int b = 20;
a > b? a : b;
}结果会报错，原因是，没有把最终的值放入一个变量里面去:
八：运算符的优先级
在⼀条表达式中，各个运算符可以混合起来进⾏运算，但是运算符的优先级不同，⽐如：*和/的优先 级要⾼于+和-，有些情况下稍不注意，可能就会造成很⼤的⿇烦
注意：
运算符之间是有优先级的.具体的规则我们不必记忆.在可能存在歧义的代码中加上括号即可
以上就是全部内容了！！！！！！！！！