Java运算符详解
一.算术运算符
（一）+(正数、加法、连接符)
class demo8{
public static void main(String[] args){
int age = +30; //+代表正数
System.out.println("age="+age);
int a = 12;
int b = 23;
int c = a+b; //+代表加法求和，将和赋值给c变量
System.out.println("c="+c);
int i1 = 1;
System.out.println(i1+" world"); //+代表着连接符
System.out.println(1+2+3+" world"+1+2+3); //计算机每次运算的时候只能取两个 //数据运算，而且是从左到右运算。
}
}
运行结果如下图所示：
注意：
（1）如果+号用于字符串的时候，那么+号就是一个连接符，并不是做加法功能了。
（2）连接符的作用：让任何的数据都可以与字符串进行拼接。
（3）任何类型的数据与字符串使用连接符连接，那么结果都是字符串类型的数据。
（二）-（负数、减法）
class demo9{
public static void main(String[] args){
int age = -30; //-充当整数的符号，代表负数
System.out.println("age="+age);
int a = 34;
int b = 23;
int c = a-b; //-代表做减法运算
System.out.println("c="+c);
}
}
运行结果如下图所示
（三）/ （除法）
class Demo10{
public static void main(String[] args){
int a = 1234;
int b = 10;
int c = a/b; //分别取出两个变量名的值 求商 取整
System.out.println("c="+c);
System.out.println(1234/10);//两个int类型的数据做运算，结果肯定还是int类型的数据
double d = 12.0;
int e = 3;
System.out.println(d/e);//两个不同类型的数据做运算，结果取决于大的数据类型
System.out.println(1234/10*10); //1230
int f = 12;
int g = 0;
System.out.println(f/g); //除数不能为0，会报异常
}
}
运行结果如下图所示
（四）* （乘法）
（五）% （取模、取余数）
//在Java中做取模运算时，结果的正负号取决于被除数
class Demo11{
public static void main(String[] args){
System.out.println("结果:"+(10%3)); // 1
System.out.println("结果:"+(10%-3)); // 1
System.out.println("结果:"+(-10%3)); // -1
System.out.println("结果:"+(-10%-3)); // -1
}
}运行结果如下图所示：
（六）++ （自增）：自增就是相当于操作数+1
1.前自增：++位于操作数的前面，如++a；先自增完毕，再运算整个表达式，即先自增，后使用。
class Demo12{
public static void main(String[] args){
int i = 0;
int sum = 0;
sum = ++i;
System.out.println("sum:"+sum); //sum=1
}
}
运行结果如下图所示：
2.后自增：++位于操作数的后面，如a++；先运算完整个表达式，再进行自增，即先使用，后自增。
class Demo13{
public static void main(String[] args){
int a = 0;
int sum = a++; //后自增 sum = 0，a = a+1；
System.out.println("sum="+sum); //sum = 0
System.out.println("a="+a); //i = 1
}
}
运行结果如下图所示
后自增在JVM的运行原理：
（1）int temp = i； 因为后自增要使用到没有加1之前的值，那么JVM会先声明一个临时变量用于保存没有加1之前的值。
（2）自增； i=i+1；i=1；
（3）temp记录了没有加1之前的值，把temp用作了表达式的结果，i=i++就会变为i=temp。
综上所述，i的值发生了两次变化。i=0 ----------> 1 ----------> 0
（七）--（自减）
1.前自减：--位于操作数的前面，如--a；先自减完毕，再运算整个表达式，即先自减，后使用。
2.后自减：--位于操作数的后面，如a--；先运算完整个表达式，再进行自减，即先使用，后自减。
结论：如果运算符在变量的前面，则该变量自增1或者自减1，然后返回的是变量的新值；如果运算符在变量的后面，则变量也会自增或者自减1，但是返回的是变量原来的值。
++在前就是先运算，再取值；++在后就是先取值，再运算。
二.赋值运算符
注意：！=不属于赋值运算符
class Demo14{
public static void main(String[] args){
byte b1 = 1;
byte b2 = 2;
b2 += b1;
System.out.println("b2:"+b2);
}
}
运行结果如下图所示：
注意：虽然b2 += b1;从数值的角度上分析为b2 = b2+b1,但是如果代码写成b2 = b2+b1;在编译的时候会报错，因为需要强制类型转换，虽然b2和b1都是byte数据类型，但是在它们相加时JVM会自动将它们升为int类型的数据再相加，目的是防止它们相加后超出byte数据类型能表示的范围。如果表达式中没有long、float、double，不论参数的数据类型是什么类型，都把表达式的每一部分都转换为int类型。而当我们写成b2 += b1;时，Java编译器会进行隐式类型转换，不需要我们手动转换了。
三.比较运算符
1.比较运算符的两边加的是算术表达式，而且比较运算符的结果都是返回一个布尔值的，只有两种结果true和false。
2.==（判断是否等于）
（1）==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一致。
（2）==用于比较两个引用类型变量的时候，比较的是两个引用类型变量所记录的内存地址是否一致。
3.instanceof的格式是：变量 instanceof 类名
注意：instanceof左边加的是变量，右边加的是类名，结果是true或false，它是用来判断左边的变量所指向的对象是不是通过右边的类创建出来的。
class Demo15{
public static void main(String[] args){
int a = 10;
int b = 10;
System.out.println("10等于10吗？"+(a==b));
System.out.println("10不等于1吗？"+(10!=1));
byte c = 10;
long l = 30;
System.out.println(l>c);
System.out.println('a'>50);
}
}
运行结果如下图所示：
注意：两个不同数据类型的数据也是可以比较的，但是两个不同数据类型的数据必须是兼容的数据（如两个都是整数），如果一个是整数，一个是布尔类型则不能比较。上述long类型的l与byte类型的c比较的过程会先把c转换成long类型的数据，再进行比较。
四.逻辑运算符
（逻辑运算符的作用是用来连接两个布尔表达式的，可以将比较运算符连接起来，运算结果是boolean型）
1. &（与/逻辑与）：可以理解为并且
（1）&（与）符号规律：只有左右变量同时为true，结果才是true；否则就为false。
（2）实例：
class Demo16{
public static void main(String[] args){
System.out.println(true&true); //true
System.out.println(true&false); //false
System.out.println(false&true); //false
System.out.println(false&false); //false
}
}
运行结果如下图所示：
2. | （或/逻辑或）：可以理解为或者
（1） |（或）符号规律：只要两边的布尔表达式有一边为true，那么结果就为true；只有两边同时为false的时候，结果才是false。
（2）实例：
class Demo17{
public static void main(String[] args){
System.out.println(true|true); //true
System.out.println(true|false); //true
System.out.println(false|true); //true
System.out.println(false|false); //false
}
}
运行结果如下图所示：
3. ^ （异或）：可以从“异”字入手去理解
（1）规律：只要两边的布尔表达式结果不一致，结果就为true；如果左右两边的布尔表达式一致，结果就为false。
（2）实例：
class Demo18{
public static void main(String[] args){
System.out.println(true^true); //false
System.out.println(true^false); //true
System.out.println(false^true); //true
System.out.println(false^false); //false
}
}
运行结果如下图所示：
4. ！（非）
（1）规律：结果取反
（2）实例：
class Demo19{
public static void main(String[] args){
System.out.println(!true); //false
System.out.println(!false); //true
}
}
运行结果如下图所示：
5. &&（短路与/双与）
（1）短路与和单与符号的相同点和不同点：
①相同点：短路与和单与的运算结果是一致的。
②不同点：使用短路与的时候，如果左边的布尔表达式为false，则不会再运算右边的布尔表达式，从而提高了效率；而 使用单与的时候即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的。
（2）注意：“双与的效率高于单与的”这句话不一定正确，因为只有左边的布尔表达式为false时，双与的效率才会高于单与的。
（3）实例1：短路与和逻辑与的运算结果是一致的。
class Demo20{
public static void main(String[] args){
System.out.println(true&&true); //true
System.out.println(true&&false); //false
System.out.println(false&&true); //false
System.out.println(false&&false); //false
}
}
运行结果如下图所示：
（4）实例2：证明逻辑与和短路与的不同点：
class Demo21{
public static void main(String[] args){
boolean a = false;
boolean b = false;
System.out.println("----------短路与的运行结果----------");
System.out.println(b&&(a=true)); //false
System.out.println("a="+a);//false,短路与发现左边布尔表达式为false，不会运行右边
System.out.println("----------逻辑与的运行结果----------");
System.out.println(b&(a=true)); //false
System.out.println("a="+a);//true,逻辑与发现左边布尔表达式为false，还会运行右边
}
}
运行结果如下图所示：
6. ||（短路或/双或）
（1）短路或和单或的相同点和不同点：
①相同点：短路或和单或的运算结果是一致的。
②不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式；而使用单或的时 候，当发现左边的布尔表达式结果为true，还是会运算右边的布尔表达式。
（2）实例1：逻辑或和短路或的运行结果是一致的。
class Demo22{
public static void main(String[] args){
System.out.println(true||true); //true
System.out.println(true||false); //true
System.out.println(false||true); //true
System.out.println(false||false); //false
}
}
运行结果如下图所示：
（3）实例2：证明逻辑或与短路或的不同点
class Demo23{
public static void main(String[] args){
boolean a = false;
boolean b = true;
System.out.println("----------短路或的运行结果----------");
System.out.println(b||(a=true)); //true
System.out.println("a="+a); //false,短路或发现左边布尔表达式为true， //就不会运行右边的布尔表达式
System.out.println("----------逻辑或的运行结果----------");
System.out.println(b&(a=true)); //true
System.out.println("a="+a); //true,逻辑或即使发现左边布尔表达式为 //true，还是会运行右边的布尔表达式
}
}运行结果如下图所示：
五.位运算符
（位运算符就是直接操作二进制位的）
可以把1当做true，0当做false。
1. &（与）
只有参与运算的两位都为1，&运算的结果才为1，否则就为0。
2. |（或）
只有参与运算的两位都为0，|运算的结果才为0，否则就为1。
3. ^（异或）
（1）只有参与运算的两位不同，^运算的结果才为1，否则就为0。
（2）规律：如果操作数A连续异或同一个操作数两次，那么结果还是操作数A。
（3）应用：对数据进行加密。（实例在博客中会单独列出一篇）
4. ~（取反）
就是二进制位按位取反，二进制只有1和0，取反就是1取反是0,0取反是1。
注意：
（1）如果符号左右连接的是整数，则是位运算符；如果符号左右连接的是布尔表达式，那么就是逻辑运算符。
（2）计算机中一个数的取反并不是像数值运算中的正数取反就是负数，而是按计算机中存储的二进制位取反。
(3)要注意负数在计算机中的存储原理，如下图所示：
结论：
（1）当参与取反的数值是正数时，把对应的值加上负号，再-1。
（2）当参与取反的数值是负数时，把对应的值加上负号，再-1。
（3）负数表现形式就是对应的正数取反再+1，负数的最高位肯定是1。
实例;
class Demo24{
public static void main(String[] args){
System.out.println(6&3); //2
System.out.println(6|3); //7
System.out.println(6^3); //5
System.out.println(~7); //-8
}
}
运行结果如下图所示：
六.移位运算符
（也是属于位运算符的一种）
1. <<（左移）
（1）二进制数全部向左移动一位，把前面多出的一位删掉，后面少了的一位用0去补。
（2）规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移的位数。
2. >>（右移）
（1）一个操作数在进行右移运算的时候，如果该操作数是一个正数，那么左边空缺位使用0补；如果该操作数是一个负数，那么使用1来补充。
（2）规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。
3. >>>（无符号右移）
无符号右移与右移的区别：
（1）进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补；如果操作数是一个负数，那么左边的空缺位使用1补。
（2）使用无符号右移的时候，不管是正数还是负数，都统一使用0补。
实例：
class Demo26{
public static void main(String[] args){
System.out.println("----------左移----------");
System.out.println(3<<1); //6; 3*2(1)=6
System.out.println(3<<2); //12; 3*2(2)=12
System.out.println(3<<3); //24; 3*2(3)=24
System.out.println("----------右移----------");
System.out.println(3>>1); //1; 3/2(1)=1
System.out.println(3>>2); //0; 3/2(2)=0
System.out.println("----------无符号右移----------");
System.out.println(12>>>2); //3;
System.out.println(-12>>>2); //1073741821
}
}
运行结果如下图所示：
七.三元运算符
1.格式：布尔表达式？表达式1:表达式2;
2.结果：如果布尔表达式的结果为true，运行后的结果为表达式1；如果布尔表达式的结果为false，运行后的结果为表达式2。
3.注意细节：使用三元运算符的时候，一定要使用该表达式返回的结果，或者是定义一个变量接收该表达式返回的结果。
4.三元运算符的优点：结构比较简洁。
5.三元运算符的缺点：符合条件必须要返回一个结果，不能执行语句。
6.实例：
class Demo27{
public static void main(String[] args){
int age = 26;
String result = age>=18?"成年人":"未成年人"; //定义变量接收表达式返回的结果
System.out.println(result); //使用表达式返回的结果
}
}
运行结果如下图所示;
八.运算符的优先级表
