再从头|再回首1.算术运算符：
+，-，*，/，%， ++，--。
A. 二元运算符
+，-，*，/，%
没什么好说的，这最要注意的是，%，取余，在Java中叫模运算，运算时要注意精度问题。
运算时，byte，short 类型运算后的结果为 int类型。
示例：
package operator;
public class Demo01 {
public static void main(String[] args) {
int i1 = 10 ;
int i2 = 20 ;
int i3 = 30 ;
int i4 = 40 ;
System.out.println(i1+i2);
System.out.println(i2-i3);
System.out.println(i3*i4);
System.out.println(i1/i4); //输出结果为0，产生精度问题 10/40 = 0.4
System.out.println((double)i1/i4); //输出0.25，要强转
}
}
输出：
30
-10
1200
0
0.25示例二：
package operator;
public class Demo02 {
public static void main(String[] args) {
byte b1 = 10 ;
short s1 = 21 ;
int i1 = 31 ;
long l1 = 400L ; //Long 类型，加后缀L
float f1 = 5.1F ; //浮点类型，加后缀F
double d1 = 3.14 ;
System.out.println(b1+s1);
System.out.println(l1-s1);
System.out.println(l1*f1);
System.out.println(d1/b1);
System.out.println(b1%s1); //结果为10，%求余，Java中叫求模运算
/*
System.out.println((String) (b1+b1)); //byte 相加，提示cannot cast 'int' to java.lang.String
System.out.println((String) (s1+s1)); //short 相加，提示cannot cast 'int' to java.lang.String
System.out.println((String) (i1+i1)); //int 相加 ，提示cannot cast 'int' to java.lang.String
System.out.println((String) (l1+l1)); //long 相加，提示cannot cast 'long' to java.lang.String
System.out.println((String) (f1+f1)); //float 相加，提示cannot cast 'float' to java.lang.String
System.out.println((String) (d1+d1)); //double 相加，提示cannot cast 'double' to java.lang.String
*/
/*
System.out.println((String) (b1+s1)); // byte short 相加，提示cannot cast 'int' to java.lang.String
System.out.println((String) (l1+s1)); // short long 相加，提示cannot cast 'long' to java.lang.String
System.out.println((String) (l1+f1)); // long float 相加，提示cannot cast 'float' to java.lang.String
System.out.println((String) (d1+b1)); // double byte 相加，提示cannot cast 'double' to java.lang.String
*/
}
}
可以看出 byte，short 类型参与运算时，会自动转换为 int 类型，其他类型依然按照 低到高的原始处理（参考：Java基础语法05 - 数据类型转换）。
B. 自增，自减一元运算符：
++, --
a++ ==> a=a+1;
++a ==> a=a+1;
//两者一样示例：
package operator;
public class Demo04 {
public static void main(String[] args) {
//一元运算符， ++ --
int a = 3;
int b = a++ ; //相当于 b = a，a = a + 1
int c = ++a ; //a = a + 1， 相当于 c = (a = a + 1)
System.out.println(a); //5， a 自增2次，所以是5
System.out.println(b); //3， 先赋值，再自增，所以是3
System.out.println(c); //5，先自增，再赋值，所以是5
}
}C. 幂运算
幂运算用到数学工具类 Math类，结果是double类型。
package operator;
public class Demo04 {
public static void main(String[] args) {
//数学工具类 Math Math.pow -> 数学求次方
double d1 = 3;
double d2 = 2;
System.out.println(Math.pow(d1,d2)); //3^2 = 9;
}
}输出：
9.02.赋值运算符：
=3.关系运算符：
>，<，>=，<=，==，！=，instanceof (判断一个对象是否为一个类的实例)。
返回结果只能是布尔值 true / false 。
示例：
package operator;
public class Demo03 {
public static void main(String[] args) {
//关系运算符 运算结果是布尔值，只能返回 true 或 false。
int i1 = 10 ;
int i2 = 20 ;
float i3 = 10.0F ;
int i4 = 10 ;
double i5 = 10.0001 ;
float i6 = 10.0001F ;
byte i7 = 10 ;
System.out.println(i1>i2); //false
System.out.println(i1<i2); //true
System.out.println(i1>=i5); //false 10 小于 10.0001F
System.out.println(i1<=i3); //true 10 等于 10.0F
System.out.println(i5!=i6); //ture 10.001 与 10.0001F 不相等
System.out.println(i1==i5); //false 10 不等于 10.0001
System.out.println(i1==i3); //true 10 与 10.0F相等
System.out.println(i1>i7); //int 10 不大于 byte 10
}
}输出：
false
true
false
true
true
false
true
false可以看到 低容量与高容量类型对比相同的值是一样的。但double 和float 相同的值，比较的结果不一样，前面说过的精度问题。
4.逻辑运算符：
&&，||，！。
&& 逻辑与运算：两个变量都为真，结果才为true。
|| 逻辑或运算：两个变量只要有一个为真，结果就是true，也就是说只有2个都为false 时才为 false。
！ 非运算：如果变量为真，结果为false，如果变了为假，结果为true。非就是取反的意思。
示例：
package operator;
public class Demo05 {
public static void main(String[] args) {
//逻辑运算符
// &&（and 与），|| （or 或），!（非，取反）
boolean flag1 = true ;
boolean flag2 = false ;
System.out.println("flag1 && flag2: " + (flag1&&flag2) ); // false, and，只有两个为真，结果才为真
System.out.println("flag1 || flag2: " + (flag1||flag2) );// ture, or, 只有两个为假，结果才粉假
System.out.println("!(flag1 && flag2): " + !(flag1&&flag2) ); // true, Opposite， 取反操作
}
}
输出：
flag1 && flag2: false
flag1 || flag2: true
!(flag1 && flag2): true中间涉及短路运算，也就是说 当操作&&时，第一个为假的时候，直接返回false，&&后面的不执行，代码被直接短路跳过了。
同时理，执行||操作时，第一个为真时，直接返回真，||后面的条件不执行。
短路运算：
示例：
package operator;
public class Demo05 {
public static void main(String[] args) {
//短路运算
int i = 4;
boolean b1 = i<4 && (++i>4) ; //and,只要第一个为假，结果为假，直接返回false,没有执行 '&&' 后面的i++
System.out.println(b1); // false
System.out.println(i); // 4， i++没被执行
System.out.println("==========");
boolean b11 = (i>=4) && (++i>4) ; //and,两个为真，结果才为真
System.out.println(b11); // true
System.out.println(i); // 5
System.out.println("==========");
int i2 = 4;
boolean b2 = i2>3 || (i2++>4) ; // or，只要第一个为真，结果为真，直接返回true，同样没执行 '||' 后面的代码
System.out.println(b2); //true
System.out.println(i2); // 4，i2++没被执行
System.out.println("==========");
boolean b21 = (i2>4) || (i2++>4) ; //and,两个为假，结果才为假,证明先执行了逻辑运算i2>4，再执行的自增运算i2++
System.out.println(b21); // false
System.out.println(i); // 5
System.out.println("==========");
}
}
输出：
false
4
==========
true
5
==========
true
4
==========
false
5
==========
Process finished with exit code 0
也就是说，当执行&&运算时，只有第一个为真，第二个条件才有机会被执行。
当执行||运算时，只有第一个为假，第二个才有机会被执行。
5.位运算符：
&，|，^，~，>>，<<，>>>。
位运算逻辑上与关系运算一样的，只是位运算是跟据位来的，二进制的运算。
&与运算，11为1，其他为0；|或运算，00为0，其他为1；^异或运算，相同为0，不同为1；~取反，就是0变1，1变0；
示例：
package operator;
public class Demo06 {
public static void main(String[] args) {
//位运算
/*
A = 0011 1100 ;
B = 0000 1101 ;
---------------------
A&B = 0000 1100 ; and 11为1，其他为0；
A|B = 0011 1101 ; or 00为0，其他为1；
A^B = 0011 0001 ; xor 同为0，不同为1；
~B = 1111 0010 ; and 11为1，其他为0；
*/
//2*8 怎么运算最快？
//答案是 位运算,直接跟计算机底层打交道，效率高
//这里要用到的位运算符是： 左移<< 右移>>
// << *2 左移相当于X2^n，n为移动位数
// >> /2 右移相当于/2^n
/*
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16 //2^4
*/
System.out.println(2<<3); //16
System.out.println(1<<3); //8
System.out.println(3<<3); //24
}
}输出：
16
8
24关于异或运算：
异或，是一个数学运算符，英文为 exclusive OR，缩写为 xor，应用于逻辑运算。异或的数学符号为“ ⊕ ”，计算机符号为“ xor ”。
如果a、b两个值不相同，则异或结果为1。如果a、b两个值相同，异或结果为0。
拓展：
异或也叫半加运算，其运算法则相当于不带进位的二进制加法：二进制下用1表示真，0表示假，则异或的运算法则为：0⊕0=0，1⊕0=1，0⊕1=1，1⊕1=0（同为0，异为1），这些法则与加法是相同的，只是不带进位。
异或略称为XOR、EOR、EX-OR
6.条件运算符(三元运算符)：
? ：
x?y:z 如果x为true，则结果为y，如果x为false，结果为z。
示例：
package operator;
public class Demo08 {
public static void main(String[] args) {
//三元运算符
// x?y:z ; 如果X真，结果y；否则结果为Z。
int score = 90 ;
String total = (score>60)?"及格":"不及格" ;
System.out.println(total);
}
}输出：
及格7.扩展赋值运算符：
+=，-=，*=，/+。
a+=b；相当于 a = a+b；其他一样
package operator;
public class Demo07 {
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
// b+=a ; //30 b = b+a
b-=a ; //10 b = b-a
System.out.println(b); //10
//字符串连接符 +
// + 旁边出现 String类型，哪里出现String，String两边的+为字符串连接符，其他是正常运算的+（加号）。
System.out.println("" + a+b); //1010 相当于""+"1010"
System.out.println(a+b+""); //20 相当于 "20"+""
System.out.println(a+b+""+a+b); //201010 相当于 "20" + "1010"
}
}输出：
10
1010
20
201010