java运算符

算术运算符

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

规则比较简单, 值得注意的是除法:

a) int / int 结果还是 int, 需要使用 double 来计算.

int a = 1;

int b = 2;

System.out.println(a / b); //结果为0

b) 0 不能作为除数 

int a = 1;

int b = 0;

System.out.println(a / b)

// 运行结果

Exception in thread "main" java.lang.ArithmeticException: / by zero

at Test.main(Test.java:5) ，即会抛出算术异常（ArithmeticException）

System.out.println("dd");  //当前面出现了异常后，此段及以后的代码便不会在执行了

c) % 表示取余, 不仅仅可以对 int 求模, 也能对 double 来求模 (java中不同于c语言的是此处可以进行小数的取余)

System.out.println(11.5 % 2.0); // 运行结果为1.5

d) int / double,此时int会自动类型提升为double后进行除法运算，所以最终等价于double/double 

int a=10;
double b=8.0;
System.out.println(a/b);

//运行结果

1.25

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

代码1：

int a = 10;

a += 1; // 等价于 a = a + 1

System.out.println(a);

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

代码1：

int a = 10;

int b = ++a;

System.out.println(b);//结果为11,先给a+1后再赋给b

int d = 10;

int c = d++;

System.out.println(c);//结果为10,先把d赋给b

代码2：需要特别注意

int a = 10;
a = a++;
System.out.println(a);//在c语言中此时a输出的值为11，但是在java中输出的值为10，原因是java的反汇编原理

结论:

1. 如果不取自增运算的表达式的返回值, 则前置自增和后置自增没有区别.

2. 如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值.

---

关系运算符

关系运算符主要有六个:

==       !=       <     >      <=      >=

int a = 10;

int b = 20;

以下括号中的全部为布尔表达式

System.out.println(a == b);//false

System.out.println(a != b);//true

System.out.println(a < b);//true

System.out.println(a > b);//false

System.out.println(a <= b);//true

System.out.println(a >= b);//false

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

---

逻辑运算符(重点)

逻辑运算符主要有三个: &&    ||     !

注意: 逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean ,即逻辑运算符不同于c语言的是，其都要与布尔表达式进行搭配

逻辑与 && (短路与)

规则: 两个操作数都为 true, 结果为 true, 否则结果为 false.

格式：布尔表达式1&&布尔表达式2&&布尔表达式3...,当所有布尔表达式都为真才是真，只要有一个为假整体就为假

int a = 10;

int b = 20;

int c = 30;

System.out.println(a < b && b < c); //输出结果为true

int a=10;

int b=20;

int c=30;

if(a++&&b++&&c++){

System.out.println("1");

}else{

System.out.println("2");

}

//直接会在if处报错，因为类似逻辑与这样的逻辑运算符，其只能与布尔表达式进行组合，a++,b++,c++这种不属于布尔表达式，所以会报错。

逻辑或 || (短路或)

规则: 两个操作数都为 false, 结果为 false, 否则结果为 true

格式：布尔表达式1||布尔表达式2||布尔表达式3...只要其中一个布尔表达式为真整体为真，所有布尔表达式为假便为假

int a = 10;

int b = 20;

int c = 30;

System.out.println(a < b || b < c);//输出结果为true

逻辑非 !

规则: 操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数).

int a = 10;

int b = 20;

System.out.println(!(a > b)); //true,逻辑非在c语言中!后面可以加上整数，而在java中其后面只能加上布尔表达式，输出结果为true

短路求值

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

System.out.println(10 > 20 && 10 / 0 == 0); // 打印为false

System.out.println(10 < 20 && 10 / 0 == 0);//会报算数异常错误，因为第二个式子的分母为0

System.out.println(10 < 20 || 10 / 0 == 0); // 打印为true 

System.out.println(10 > 20 || 10 / 0 == 0);//会报算数异常错误，因为第二个式子的分母为0

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.

结论:

1. 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式.

2. 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式.

& 和 | (不推荐使用)

& 和 | 如果操作数为 boolean 的时候, 也表示逻辑运算. 但是和 && 以及 || 相比, 它们不支持短路求值.

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常，因为并不支持短路求值，所以10 / 0 会导致程序抛出异常

System.out.println(10 < 20 | 10 / 0 == 0);// 程序抛出异常，因为并不支持短路求值，所以10 / 0 会导致程序抛出异常

---

位运算符

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

位运算符主要有四个: &   |    ~    ^

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

1.&按位与  

           0000 0101  

        &0000 0011

          0000 0001            规律：两个数按位与时，有0便为0，全是1才是1

2 ^按位异或

          0000 0101  

        ^0000 0011

          0000 0110           规律：两个数按位异或时，两个数字相同为0，不同为1

注意：0^n都是n,即任意的数与0做异或运算后，都为这个数本身：

         0000  0000

      ^ 0101  1111

         0101  1111

3. |按位或

          0000 0101  

        ^0000 0011

          0000 0111           规律：两个数按位或时，两个数字有一个为1变为1，全部是0才为0

4.按位取反（~ ）

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

          0000  0101

          1111   1010       规律：每一位上是1的话取反为0，是0的话取反为1

---

移位运算(了解)

移位运算符有三个: <<       >>       >>> ,且都是按照二进制位来运算.

1.<< ：最左侧位不要了, 最右侧补 0.

举例：

3 << 2

    计算过程：首先把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011，然后把该数字高位（左侧）的两个零移出，其他的数字都朝左平移2位，最后在低位（右侧）的两个空位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 1100，则转换为十进制是12.

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

11 >> 2
　　计算过程：11的二进制形式为：0000 0000 0000 0000 0000 0000 0000 1011，然后把低位的最后两个数字移出，因为该数字是正数，所以在高位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 0010.转换为十进制是3.

3.>>>：最右侧位不要了, 最左侧补 0(不管正负).

注意:

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.

4. 移动负数位或者移位位数过大都没有意义.

面试题：如何让一个数字快速的扩大8倍？

答：让这个数字左移三位，因为只有左移才可以体现出快速二字。

---

条件运算符

条件运算符只有一个: 表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式 3 的值.

条件运算符也是 Java 中唯一的一个三目运算符, 是条件判断语句的简化写法.

代码1：

// 求两个整数的最大值

int a = 10;

int b = 20;

int max = a > b ? a : b;//输出就结果为20

代码2：

boolean flg = true ? true == true ? false : true : false;//最终结果为false
System.out.println(flg);

---

运算符的优先级

先看一段代码

System.out.println(1 + 2 * 3);

结果为 7, 说明先计算了 2*3 , 再计算 1+2*3

另外一个例子

System.out.println(10 < 20 && 20 < 30);

此时明显是先计算的 10 < 20 和 20 < 30, 再计算 &&. 否则 20 && 20 这样的操作是语法上有误的(&& 的操作数只能是boolean,即操作数必须为布尔表达式).

总结：运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可，即根据自己想要的运算逻辑加上括号就好.

---

注释

注释是为了让代码更容易被读懂而附加的描述信息. 不参与编译运行, 但是却非常重要.

基本规则

Java中的注释主要分为以下三种 ：

单行注释：// 注释内容（用的最多）

多行注释：/* 注释内容*/（不推荐）

文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可用来自动生成文档

注释规范

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.

2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.

3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.

4. 积极向上: 注释中不要包含负能量

---

关键字 

 关键字是 Java 中的一些具有特定含义的单词。另外, 定义的变量名不能和关键字冲突.