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

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

一元运算符就是只有一个元素参加的运算，如【 !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 是确定的，将确定的值赋给不确定的变量，使变量的确定就叫赋值。【等于的两边是等价的，而赋值确实右边的值成立后，左边的变量才成立。】

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

For example:（以 += 为例）

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

关系运算符

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

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

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

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

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

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

位运算符

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

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

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 中也一样~ 这里再次贴上一个表：

注：
优先级为 1 的优先级最高，14 为优先级最低。
综合性是指运算符结合的顺序，一般从左到右。
注意区分正负号与加减号的区别。

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

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

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

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