Java 基础（7）——运算符

学完基础的变量常量等知识。再往后和变量常量紧密相关的当然是加减乘除等等运算方法了~（当然加减乘除也只是一部分）

首先按照运算过程参与的元素，把运算符号简单粗暴的分为一元运算符、二元运算符、三元运算符等等。

一元运算符就是只有一个元素参加的运算，如【 !a 】；

二元运算符就是只有二个元素参加的运算，如【 a + b 】；

三元运算符就是只有三个元素参加的运算，如【 a ? b : c 】；

……(*^▽^*)后面还有没有我没有去仔细了解，为了严谨，还是加上省略号哈哈。

算术运算符

咱们先学学小学三年级及之前的运算符‘+’、‘-’、‘*’、‘/’。

1+1=2，1-1=0等等算式放到Java中呢，我们也是一样的这么写~

来，我们先搞两个变量在这里：

double a = 1998.1109;

double b = 2019.0413;

然后后面就用这两个变量来算了~

加 +

double c = a + b; //这里也是用加法让c等于a+b

System.out.println("a+b="+c);

输出结果：

减 -

double c = a - b;    // 这里也是同样的减法

System.out.println("a-b="+c);

输出结果：

乘 *

double c = a * b;    // 与手写不一样的是，计算机中乘法用*

System.out.println("a*b="+c);

输出结果：

除 /

double c = a / b;    // 除法也与手写不一样，计算机中除法用/

System.out.println("a/b="+c);

输出结果：

---

除法的补充 - 2019.0414 （感谢提醒我的孙老师）

除法中，整数的除法还是会有一定的特殊性的，比如 3 / 2 = 1.5，留有小数点，那我们重新定义两个整型变量, 然后让他们做除法：

int h = 3, i = 2;
System.out.println("h/i="+(h/i)); // 数学：3÷2=1.5
System.out.println("i/h="+(i/h)); // 数学：2÷3=0.666…

来看看结果：

ei？这里的结果发现小数被舍弃了，1.5 变成了 1，0.6 也变成了 0~ 所以在做除法运算的时候，整数间的除法是不会保留小数的，这个与下面的 “取余” 类似，整数间的除法叫做“取整”。
[补充完毕]

---

说完上面的加减乘除法，我们还有几个相对比价 “高级” 的计算符号需要去 study：

取余 %

取余：应该就是 取得余数 的意思了吧~

　　余数呢，就是在整数的除法中，当不能整除时，就产生了余数。比如3除2，商是1，余数是1.

　　……额，我怎么开始解释小学数学了 -_-|| 上代码吧…

double c =  b % a;    // 整除

System.out.println("a%b="+c);

输出结果：

额，这我就不验证了…应该是对的了。

自增 ++ （自减 --）

自增：就是程序运行到某一行，变量自己就想通了，给自己加了个1……这就是自增（在原有的变量中加1）

比如：

a = a + 1;

System.out.println("a="+a);

输出结果：

上面是没有用到自增的运算符的计算，就是一个简单的加法计算。那么用自增呢，就更简单了：

a ++;    // 自增运算符

System.out.println("自增：a="+a);

输出结果：

此外，关于自增自减，必须要讲到的是自增自减符的位置问题！

先来一段代码：

a = 1998.1109;//重置a的值为1998.1109
System.out.println("先++：" + ++a);
a = 1998.1109;//重置a的值为1998.1109
System.out.println("后++：" + a++);
//不重置a的值了
System.out.println("最后a变成了：" + a);

然后看一下结果：

发现了什么呢？

• 先进行自增运算的输出的值为 a = 1999.1109，完成了自增运算
• 后进行自增运算的输出的值仍然为 a 原来的值（1998.1109）。
• 最后进行a值的检查的时候，a却还是变成了1999.1109.

So，真相大白了吧：

• ++a,会先把a做加1操作后，把a输出，就是算好了的结果。
• a++会先输出a，然后再算++。

就是这么回事儿，其实按照从左到右的顺序执行代码了(*^▽^*)

自减（每次减一）同理，就不过多论述了~

赋值运算符

赋值运算符，一般来说就是数学中的“=”，但是我们不能把它叫做等于哦~

之前的代码大家也都看到了。

double a = 1998.1109;

这样的代码，读作：a等于1998.1109是错的哦，应该是将1998.1109赋值给a。

这个逻辑是什么样的呢？

我的理解：等号左边的a是不确定的，右边的1998.1109是确定的，将确定的值赋给不确定的变量，使变量的确定就叫赋值。【等于的两边是等价的，而赋值确实右边的值成立后，左边的变量才成立。】

除了上面的“=”之外，还有许多其他的赋值运算符，他们由“=”前面加上其他的运算符组成，比如：

表 7 - 1 赋值运算符

运算符	用法	等效表达式
+=	a += b	a = a +b
-=	a -= b	a = a - b
*=	a *= b	a = a * b
/=	a /= b	a = a /b
%=	a %= b	a = a % b
&=	a &= b	a = a & b
|=	a |= b	a = a | b
^=	a ^= b	a = a ^ b
>>=	a >>= b	a = a >> b
<<=	a <<= b	a = a << b
>>>=	a >>>= b	a = a >>> b

For example:（以+=为例）

int a = 0;
a+=2;
System.out.println("a="+a);

输出结果：

关系运算符

专业一点的话：关系运算符用来比较两个值，返回布尔类型的值：true 或 false 。关系运算符都是二元运算符。

两个变量之间的关系，我们可以用仍然用ab来作为例子进行比较。

a与b之间，硬要搞点什么关系的话，无非就是谁大谁小或者相等不相等的关系了。类似于>、<这样的就叫关系运算符了。那运算的结果呢，无非就是a比b大是不是真的，是真的就是true，假的就是false。

然后常用的关系运算符还是列出来一下：

表 7 - 2 关系运算符

运算符	用法	返回true需要满足的条件
>	a > b	a 大于 b
<	a < b	a 小于 b
>=	a >= b	a 大于等于 b
<=	a <= b	a 小于等于 b
==	a == b	a 和 b 相等
!=	a != b	a 和 b 不相等

好，这里列出一段代码来帮助理解：

boolean a = 1>0;    //真的，1确实大于0
boolean b = 1<0;    //假的
boolean c = 1>=0;    //真的
boolean d = 1<=0;    //假的
boolean e = 1!=0;    //真的
boolean f = 1==0;    //假的
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
System.out.println("e="+e);
System.out.println("f="+f);

那么输出结果是不是注释所预料到的呢？来看一下

bingo~~

逻辑运算符

1. 如果今天出太阳并且篮球场还有位置，我就去打篮球。

　　【出太阳】和【篮球场有位置】都得成立，都得是真的，我才出去【打篮球】。有一个前提条件不满足，我就懒得去了。用逻辑运算符表达就是

【出太阳】&&【篮球场有位置】

“&&” 符号就是 与 逻辑符了。符号两边都成立，都为真才会返回一个 true 值，否则都是 false 。

用代码体验一下：

boolean a = (1 > 0) && (2 > 0);
// (1 > 0)为真， (2 > 0)为真，两个都成立，&&运算返回true
System.out.println("a = "+a);

boolean b = (1 < 0) && (2 > 0);
// (1 < 0)为假， (2 > 0)为真，两个有一个成立，&&运算返回false
System.out.println("b = "+b);

boolean c = (1 < 0) && (2 < 0);
// (1 < 0)为假， (2 < 0)为假，两个都不成立，&&运算返回false
System.out.println("c = "+c);

输出结果：

2. 如果今天出太阳或者下雨了，我就得带把伞出门。

　　【出太阳】和【下雨】只要有一个成立了，不管是【出太阳】还是【下雨】，我都得【带伞出门】。用逻辑运算符表达就是

【出太阳】||【下雨】

“||” 符号就是 或 逻辑符了。符号两边只有有一个成立，只要有一个为真就会返回一个 true 值，两个条件都是假的话，才会返回 false 值。

用代码体验一下：

boolean a = (1 > 0) || (2 > 0);
// (1 > 0)为真， (2 > 0)为真，两个都成立，||运算返回true
System.out.println("a = "+a);

boolean b = (1 < 0) || (2 > 0);
// (1 < 0)为假， (2 > 0)为真，两个有一个成立，||运算返回true
System.out.println("b = "+b);

boolean c = (1 < 0) || (2 < 0);
// (1 < 0)为假， (2 < 0)为假，两个都不成立，||运算返回false
System.out.println("c = "+c);

输出结果：

3. 如果今天不上班，我就呆在家里。

　　不是【上班】的日子，我才呆在家里。不是 { 不【上班】} 的时候，我当然得去上班了……用逻辑运算符表达就是

!【上班】

“!” 符号就是 取反 逻辑符了。表示否则的意思。

用代码体验一下：

boolean a = !(1 > 0);
// (1 > 0) 为真，经过取反运算之后为假
System.out.println("a = "+a);

boolean b = !(1 < 0);
//(1 < 0) 为假，经过取反运算之后为真
System.out.println("a = "+b);

输出结果：

位运算符

位运算符是用来对二进制位进行操作的运算符。（不常用的话可以只了解一下就行了哦~）

表 7 - 3 位运算符

运算符	用法	描述
~	~ a	按位取反
&	a & b	按位与
|	a | b	按位或
^	a ^ b	按位异或
>>	a >> b	a 右移 b 位
<<	a << b	a 左移 b 位
>>>	a >>> b	a 无符号右移 b 位

什么意思呢？一个个来聊。

1. 按位取反  ~  ，对数据的每个二进制位都取反（0变1,1变0）ep: ~111000 = 000111
2. 按位与  &  ，对两个数据进行按位与运算（同一个位置有一个为0，则结果为0，其他情况为1）ep:

   这个可以用来对二进制某些位进行清零操作，比如11111，我想让他第四个变成0，只需与11101进行按位与运算即可。

3. 按位或  |  ，对两个数据进行按位或运算（同一个位置有一个为1，则结果为1，其他情况为0）ep:

   同理，这个可以用来将二进制某些位变成1，比如11101，我想让他第四个变成0，只需与11111进行按位或运算即可。

4. 按位异或  ^  ，对两个数据进行按位异或运算（同一个位置两个相同，则结果为0，不同则为1）ep:

   这个可以用来将二进制某些位进行翻转操作，比如10101，我想让他前三位翻转，只需与11100进行按位或运算即可。还可以用于进行两个值的交换：

5. 左移  <<  ，将一个数的各二进位全部左移，ep: 

   在不溢出的情况下可以用来实现 *2 操作。

6. 右移  >>  ，将一个数的各二进位全部右移，第一位是多少就补多少。ep: 

   在不溢出的情况下可以用来实现 /2 操作。

7. 无符号右移  >>>  ，将一个数的各二进位无符号全部右移，高位补0，ep: 

   如果两个数据长度不同，那么在位运算时会先将短型前补满，如果为正，则全补0，如果为负，则全补1。

其他运算符

除了以上几种运算符以外，Java中还有一些特殊的运算符~

1. Java实例运算符   instanceof

这个用来测试一个对象是否是一个指定的类的实例。

2. Java内存分配运算符   new

很多时候我们说new一个对象，其实是为这个对象分配一个内存存储它。

3. 三目运算符   a ? b : c

这个的意思就是： a 是真的就输出冒号 : 前面的 b ，a 是假的，就执行冒输出: 后面的 c 。

int a = 1 >2 ? 3 : 6;
System.out.println("a = "+a);

输出结果：

#运算符的优先级

当然，当从小学一年级开始慢慢深入学习，我们肯定不会是一直就是要么加要么减的运算了。多个运算符写在一起的时候，肯定会有优先计算的符号，比如加减乘除中，“先乘除后加减，有括号的先算括号里面的。”

Java中也一样~这里再次贴上一个表：

表 7 - 4 运算符的优先级

优先级	运算符	综合性
1	()   []   .	从左到右
2	!   +(正)   -(负)   ~   ++   --	从右到左
3	*   /   %	从左到右
4	+(加)   -(减)	从左到右
5	<<   >>   >>>	从左到右
6	<  <=  >=  >>  instanceof	从左到右
7	==   !=	从左到右
8	&(按位与)	从左到右
9	^	从左到右
10	|	从左到右
11	&&	从左到右
12	||	从左到右
13	? :(三目运算符)	从右到左
14	=   +=   -=   *=   /=   %=   &=   |=   ^=   ~=   <<=   >>=   >>>=	从右到左

注：　　优先级为1的优先级最高，14为优先级最低。

　　　　综合性是指运算符结合的顺序，一般从左到右。

　　　　注意区分正负号与加减号的区别。

注2：emm哈哈哈，其实不用刻意记这个表，在该打括号的地方打上括号就什么都不怕了！！！

int a = 1 >2 ? (12 - 8) : (67-3);

像这样的，也会方便代码的阅读性。

--------------------------------------------------

以上，阿里嘎多，20190413 from ahanwhite。