java运算符

算数运算符

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

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).

关键字

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

用于定义访问权限修饰符的关键字
private protected public

用于定义类，函数，变量修饰符的关键字
abstract final static synchronized

用于定义类与类之间关系的关键字
extends implements

用于定义建立实例及引用实例，判断实例的关键字
new this super instanceof

用于异常处理的关键字
try catch finally tfrow throws

用于包的关键字
package import

其他修饰符关键字
native strictfp transient volatile assert