学完基础的变量常量等知识。再往后和变量常量紧密相关的当然是加减乘除等等运算方法了~（当然加减乘除也只是一部分）
首先按照运算过程参与的元素，把运算符号简单粗暴的分为一元运算符、二元运算符、三元运算符等等。
一元运算符就是只有一个元素参加的运算，如【 !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 位 |
什么意思呢？一个个来聊。
- 按位取反 ~ ，对数据的每个二进制位都取反（0变1,1变0）ep: ~111000 = 000111
- 按位与 & ，对两个数据进行按位与运算（同一个位置有一个为0，则结果为0，其他情况为1）ep:
这个可以用来对二进制某些位进行清零操作，比如11111，我想让他第四个变成0，只需与11101进行按位与运算即可。
- 按位或 | ，对两个数据进行按位或运算（同一个位置有一个为1，则结果为1，其他情况为0）ep:
同理，这个可以用来将二进制某些位变成1，比如11101，我想让他第四个变成0，只需与11111进行按位或运算即可。
- 按位异或 ^ ，对两个数据进行按位异或运算（同一个位置两个相同，则结果为0，不同则为1）ep:
这个可以用来将二进制某些位进行翻转操作，比如10101，我想让他前三位翻转，只需与11100进行按位或运算即可。还可以用于进行两个值的交换：
- 左移 << ，将一个数的各二进位全部左移，ep:
在不溢出的情况下可以用来实现 *2 - 右移 >> ，将一个数的各二进位全部右移，第一位是多少就补多少。ep:
在不溢出的情况下可以用来实现 /2
- 无符号右移 >>> ，将一个数的各二进位无符号全部右移，高位补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);
像这样的，也会方便代码的阅读性。
