企业官网建设流程全解析

运算符

这里我们学习运算符，顺便跟上篇结合一下，提出一个问题，什么叫一个表达式？
表达式通俗来讲就是：变量 + 运算符 = 表达式

1. 什么是运算符

计算机的最基本的用途之一就是执行数学运算，比如：

int a=10;int b=20;a+b;a<b;

上述 + 和 - 等就是运算符，即：对操作数进行操作时的符号，不同运算符操作的含义不同。
作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量，Java中的运算符可以主分为以下几个：

1. 算术运算符： + - * / % 2. 关系运算符：> < = 3. 逻辑运算符 4. 位运算符 5. 移位运算符 6. 条件运算符

2. 算数运算符

2.1 基本四则运算符：加减乘除模（+ - * / %）

int a=20;int b=10;System.out.println(a+b);//30System.out.println(a-b);//10System.out.println(a*b);//200System.out.println(a/b);//2System.out.println(a%b);//0

补充：模运算相当于数学中除法的余数

注意：

1. 都是二元运算符，使用时必须要有左右两个操作数
2. int / int 结果还是 int类型 ，而且会向下取整

int a=3;int b=2;//在数学中应该是1.5但是在Java中输出结果为一，会向下取整，即小数点之后全部舍弃掉了System.out.println(a/b);//如果要得到数学中的结果，可以使用如下方式double d=a*1.0/b;System.out.println(d);

3. 做除法和取模时，右操作数不能为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) */

注意：为 0 会报错噢！！
4. 在C语言中，我们的 %操作符 只能操作整数，但是在Java中 % 不仅可以对整数取模，也可以对double类型的值进行取模，但是没有意义，所以我们一般情况下都是对整数取模的

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

采用 % 运算符的表达式，其结果的正负性会受到第一个操作数的正负影响，即：

System.out.println(-10%3);//结果是 -1

在C语言中，我们的 %操作符只能操作整数，但是在Java中

5. 两侧的操作数类型不一致时，向类型大的提升，所以说！我们的Java是自由哒！！！咳咳，继续看

System.out.println(1+0.2);// + 的左侧是int 右侧是 double 在加之前 int 会被提升为double//所以会输出 1.2

2.2 增量运算符： += . -= . *= . /= . %=

该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。

int a=1;a+=2;//相当于 a = a + 2;System.out.println(a);//输出3a-=1;//相当于 a = a - 1System.out,println(a);//输出2a*=3;//相当于 a = a * 3System.out.println(a);//输出6a/=3;//相当于 a = a / 3System.out.println(a);//输出2a%=3;// 相当于 a = a % 3System.out.println(a);//输出2

注意：只有变量才能使用该运算符，常量不能使用。
还有，别写成这种情况

3+=2

补充：

int c=10;long d=20;c=c+d;//会报错，在运算时，c会提升为long类型，可是赋值给的c，又是没有被类型提升的System.out.println(c);

但是呢，有一个小知识点，写成这样就可以了：

int c=10;long d=20;c+=d;//这里会直接给你提升为long，然后成功运算System.out.println(c);

2.3 自增/自减运算符 ++ , –

++是给变量的值 +1，–是给变量的值减一。

int a=1;a++;//后置++，表示给a的值加1，此时a的值为2System.out.println(a++);//注意：后置++是先使用变量原来的值，表达式结束后再给原来的值赋值+1，因此输出2System.out.println(a);//输出3++a;// 前置++ 表示给a的值加1System.out.println(a++);// 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5System.out,println(a);// 输出5// --操作符给操作-1，与++含义类似

尤其是在进行混合使用的情况下，一定要搞清楚前置++ 与 后置++ 的区别。
注意：

1. 如果单独使用，【前置++】和【后置++】没有任何区别
2. 如果混合使用，【前置++】先+1，然后使用变量+1后的值，【后置++】先使用变量原来的值，表达式结束时才给变量+1
3. 只有变量才能使用自增/自减运算符，常量不能使用，因为常量是不允许被修改的

3. 关系运算符

关系运算符主要有六个：== ， ！=， <， >， <= ， >=,其计算结果是 true 或者 false

int a=10;int b=20;//注意：在Java中， = 表示赋值，要与数学中的含义区分//在Java中 == 表示相等System.out.println(a==b);//falseSystem.out.println(a!=b);//trueSystem.out.println(a<b);//trueSystem.out.println(a>b);//falseSystem.out.println(a<=b);//trueSystem.out.println(a>=b);//false

注意：当需要多次判断时，不能连着写，否则都无法进行编译，比如：

int a=10;System.out.println(3<a<5);

在这里说明一下缘由，在介绍关系运算符的开头就说明了，我们的关系运算符其计算结果是true或false，所以说，怎么可能拿一个表示真假的关键字来表示数字的大或小。

4. 逻辑运算符（重点）

逻辑运算符主要有三个：&& || !，运算结果都是boolean类型。

1. 逻辑 与 &&
   语法规则：表达式1 && 表达示2，左右表达式必须是boolean类型的结果。
   相当于现实生活中的且，比如：如果是学生，并且带有学生证，才能享受半票。
   即：两个表达式都为真，结果才是真，只要有一个是假，结果就是假
   

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==100);//左为假，且右为真，则结果为假System.out.println(a>100&&b>100);//左为假，且右为假，则结果为假);

2. 逻辑 ||
   语法规则：表达式1 || 表达式2，左右表达式必须是 boolean类型的结果。
   相当于现实生活中的或，比如：买房子交钱时，全款 或者 按揭都可以，如果全款或者按揭，房子都是你的，否则站一边去。
   

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. 逻辑非 ！
   语法规则： ! 表达式
   真变假，假变真
   

int a=1;System.out.println(!(a==1));// a == 1 为true，取个非就是falseSystem.out.println(!(a!=1));// a != 1 为false，取个非就是true

补充：短路求值
讲一下短路与和短路或

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

System.out.println(10>20&&10/0==0);//为trueSystem.out.println(10<20||10/0==0);//为true

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

1. 对于 && 如果左侧表达式返回的值为false，则表达式的结果一定是false，无需计算右侧表达式，即：当两个表达式同时为真，结果就是真，但是，只要第一个表达式为假，那么其结果就为假，此时并不会执行第2个表达式。
   验证：

publicclassTest{publicstaticvoidmain(String[]args){int a=1;int b=2;System.out.println(a>b&&10/0==0);}}

上述代码执行的结果是false，并没有报错，所以说明了后面的代码确实没有被执行。
2. 对于 || ，如果左侧表达式返回的值为true，则表达式结果一定是true，无需计算右侧表达式，其他的小点跟**&&**很像，在这里就不过多阐述了。
3. & 和 | 如果表达式结果为 boolean 时，也表示逻辑运算，但与 && || 相比，它们不支持短路求值

System.out.println(10>20&10/0);//程序抛出异常System.out.println(10<20|10/0);//程序抛出异常

我们后面要讲到的 按位与（&）和 按位或（|） 没有所谓的 短路现象。

5. 位运算符

Java中数据存储的最小单位是字节，而数据操作的最小单位是比特位
字节是最小的存储单位，每个字节是由8个二进制的比特位组成的，多个字节组合在一起可以表示各种不同的数据。

位运算符主要有四个： & | ~ ^，除了 ~ 是一元运算符外，其余都是二元运算符。

位操作符表示按二级制位运算，计算机中都是使用二级制来表示苏数据的（01构成的序列），按位计算就是在按照二进制位的每一位依次进行计算。

1. 按位与 &:有0则0，全1为1

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

进行按位计算，需要把 10 和 20 转成二进制，分别为 1010 和 10100
即：
00001010
00010100
————————
00000000

2. 按位或 |：有1为1，全0为0

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

运算方式和按位与（&）类似
即：
00001010
00010100
————————
000111110
注意：当 & 和 | 的操作数为整数(int , short , long , byte)的时候，表示按位运算，当 boolean 的时候，表示逻辑运算。

3. 按位异或 ^：如果两个数字的二进制相同，则结果为 0 ，相异则结果为 1.
   即：相同为1，相异为0

int a=0x1;int b=0x2;System.out.printf("%x\n",a^b);

注意：如果两个数相同，则异或的结果为0.

4. 按位取反 ~：如果该位为 0 则转为 1 ，如果该位为 1 则 0

int a=0xf;System.out.print("%x\n",~a);

注意：
（1）.0x 前缀的数字为十六进制数字(十六进制可以看成是二进制的简化表示方式，一个十六进制数字对应4个二进制位.)
（2）.0xf表示10进制的15，也就是二进制的 1111.
（3）.printf能够格式化输出内容，%x表示按照十六进制输出
（4）.\n表示换行符
这里补充一下：我们的 & 和 | 事实上是可以代替 &&以及 ||其使用的，只不过不存在短路的问题

publicclassTest{publicstaticvoidmain(String[]arge){int a=1;int b=2;System.out.println(10<20&10>0);//真System.out.println(10>20&10>0);//第一个为假System.out.println(10<20&10<0);//第二个为假System.out.printtn(10>20&10<0);//都为假System.out.println(10>20&10/0==0);报错，因为不存在短路问题，后续代码会被执行，导致/0报错}}

6. 移位运算（主要了解即可）

移位运算符有三个：** << , >> , >>>**，都是二元运算符，且按照二进制比特位来运算。

1. 左移 <<：最左侧不要了，最右侧补0.

int a=0x10;System.out.println(a<<1);//运行结果（注意，是按照十六进制来进行打印的）//20

通俗来讲，就是可以这样，：
0000 1011 ——移一位——> 11
进行操作后
0001 0110 ————> 22
注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数。
2.右移 >>：最右侧位不要了，最左侧符号位（正数补0，负数补1），简单来说就是符号位什么是就补什么

int a=0x10System.out.println(a>>1);//运行结果（注意，是按照十六进制打印）//8int b=0xffff0000;System.out.prinyln(b>>1);//运行结果（注意，是按照十六进制打印的）//ffff8000

可以这样：
0000 1011 ——移一位——> 0000 0101 ————> 5
0000 1011 ——移两位——>0000 0010 ————> 2
3.无符号右移 >>>：最右侧不要了，最左侧补0

int a=0xffffffff;System.out.println(a>>>1);//运行结果（是按照十六进制来进行打印）//7fffffff

注意：
（1）. 左移一位，相当于原数字 * 2，左移 N 位，相当于原数字 * 2的N次方。
（2）.右移一位，相当于原数字 / 2 ，右移N位，相当于原数字 / 2 的N次方。
（3）. 由于计算机计算移位的效率要远高于计算乘除，当某个代码正好乘除 2 的N次方的时候，就可以用移位运算代替。
（4）. 移动负数位或者移位数过大时，没有意义。

7. 条件运算符（或称为三目运算符）

条件运算符只有一个：
表达式1 ？ 表达式 2 ： 表达式3

1. 当表达式1的值为true时，整个表达式的值为表达式2的值.
2. 当表达式1的值为false时，整个表达式的值为表达式3的值。
   也是Java中唯一的一个三目运算符，是条件判断语句的简化写法。
   补充：有一个好的记忆方法，即：
   表达式1是正确的吗？如果表达式是正确的，那么就返回表达式2的值，如果表达式1是错误的，那么就返回表达式3的值

//求两个整数的最大值int a=10;int b=20;int max=a>b?a:b;

这里再来一道小题，大家感兴趣可以看看：

boolean flg=true==true?true==false?false:true:false;System.out.println(flg);

给上 () 就好了解了，这里给图解释一下：

即：

boolean flg=(true==true)?(true==false?false:true):false;System.out.println(flg);

所以我们其实没有必要去强行记忆 (就是死记硬背) 每一个运算符的优先级，要常用 ** () **

注意：

1. 表达式2和表达式3的结果要是同类型的，除非能发生类型隐式转换

int a=10;int b=20;int c=a>b?1:2.0;

2. 表达式不能单独存在，其产生的结果是必定会被使用的。

int a=10;int b=20;a>b?a:b;//会报错，因为其产生的结果是没有被使用的。

8. 运算符的优先级

在一条表达式中，各个运算符可以混合起来运算，但是运算符的优先级不同，比如： * 和 / 的优先级要高于 + 和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。

//求 a 和 b 的平均值int a=10;int b=20;int c=a+(b-a)>>1;System.out.println(c);

上述表达式中，由于 + 的优先级要高于 >> ，因此 a 先和 b - a 的结果做加法，整体为20，最后在进行右移，因此结果为10.
注意:运算符之间是有优先级的，具体的规则我们不必记忆，在可能存在歧义的代码中加上括号即可。

//求a和b的平均值int a=10;int b=20;int c=a+((b-a)>>1);System.out.println(c);

欧克了.
要知道！！这个优先级不要去死记硬背，要习惯化用().