算数运算符

基本四则运算符 + - * / %

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(a / b);
}
​
//运行结果：
0

0不能做除数，不然会报错

java.lang.ArithmeticException: / by zero

增量赋值运算符 += -= *= /= %=

代码示例1：

public static void main(String[] args) {
    int a = 10;
    a = a + 1;
    a += 1;//a = a + 1
    System.out.println(a);
}

代码示例2：

public static void main(String[] args) {
    short s = 1;
    s =(short) (s + 1);//编译出现错误,需要进行强制类型转换(short)
    s += 1;//帮你进行类型转换
    System.out.println(s);
}

自增/自减运算符 ++ --

代码示例1：

public static void main(String[] args) {
    int a = 10;
    a++;//后置++
    ++a://前置++
    System.out.println(a);
  
}

代码示例2：

    public static void main(String[] args) {
        int a = 10;
        int b = a++;
        System.out.println(a);
        System.out.println(b);
    }
//运行结果：
11
10

b = a++的过程：b=a; a=a+1

b = ++a的过程：a=a+1;b=a

关系运算符

== != < > <= >=

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);
    
//运行结果
false
true
true
false
true
false

注意: 关系运算符的表达式返回值都是 boolean 类型.

逻辑运算符

&& || !

注意: 逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean

逻辑与 &&

&& ：并且【表达式1 && 表达式2】只有这两个表达式都为真的时候，整体才为真。（表达式12都为布尔表达式）

特点：短路。如果表达式1为假。就不会继续执行表达式2。

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);

逻辑或 ||

|| : 或者。 【表达式1 || 表达式2】只要有一个表达式为真，那么整体为真。

特点：短路。如果表达式1为假。就不会继续执行表达式2。

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b ||b < c);

逻辑非 !

！【布尔表达式】

int a = 10;
int b = 20;
System.out.println(!(a < b));

短路求值

&& 和 || 遵守短路求值的规则

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false 
System.out.println(10 > 20 || 10 / 0 == 0); // 报错
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

位运算符

Java 中对数据的操作的最小单位不是字节, 而是二进制位.

位运算符主要有四个:

& | ~ ^

位操作表示按二进制位运算。 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.

按位与 &

如果两个二进制位都是 1, 则结果为 1, 否则结果为 0

0000 1011

0010 0110 &

0000 0010

按位或 |

如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

0000 1011

0010 0110 |

0010 1111

按位取反 ~

如果该位为 0 则转为 1, 如果该位为 1 则转为 0

0100 1011 ~

1011 0100

按位异或 ^

如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1

0000 1011 0000 0000

0010 0110 | 0101 1011 |

0010 1101 0101 1011

结论：0^n=n

n^n=0 两个相同的数字异或结果一定为0

移位运算（了解）

<< >> >>>

都是按照二进制位来运算

左移 <<

最左侧位不要了, 最右侧补 0

11=0000 1011 <<1 位 ： 0001 0110=22 11*2^1

11=0000 1011 <<2位 ： 0010 1100=44 11*2^2

左移相当于乘法

右移 >>

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

11=0000 1011 >>1 位 ： 0000 0101=5 11/2^1

11=0000 1011 >>2位 ： 0000 0010=2 11/2^2

-1: 1111 1111 >>1位 1111 1111:-1

左移相当于除法(对于正数)

无符号右移 >>>

最右侧位不要了, 最左侧补 0

1111 1111 >>>1位 0111 1111

不管符号位是0还是1，统一补0

条件运算符

条件运算符只有一个:

表达式1 ? 表达式2 : 表达式3

如果表达式1（布尔表达式） 为真，那么执行表达式2，否则执行表达式3

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int max = a > b ? a : b;
    System.out.println(max);
}
​
//运行结果
20

运算符的优先级

System.out.println(1 + 2 * 3);
​
//运算结果
7
​
System.out.println(10 < 20 && 20 < 30);
//此时明显是先计算的 10 < 20 和 20 < 30, 再计算 &&. 否则 20 && 20 这样的操作是语法上有误的(&& 的操作数只能是boolean).

关键字

类比生活中来说，是可能比较敏感的，不能使用，或者规定的不能用的