【Java基本语法-运算符】

运算符的概念

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
>算术运算符
>赋值运算符
>比较运算符（关系运算符）
>逻辑运算符
>位运算符
>三元运算符

算术运算符

+、 -、 *、/、 % 、 （前）++、（后）++、（前）-- 、（后）- -、（拼接）+

除号：a / b，a是被除数。

  	  int num = 12;
      int num2 = 5;
      int result1 = num/num2;
      System.out.println(result1);//2

      int result2 = num/num2*num2;
      System.out.println(result2);//10

      double result3 = num/num2;
      System.out.println(result3);//2.0

      double result4 = num/num2+0.0;//2.0
      double result5 = num/(num2+0.0);//2.4 强制类型转换，相当于double result5 =(num+0.0)/num2；或double result5 = (double)num/num2;
      double result6 = num/(double)num2;//2.4
      System.out.println(result6);

%取模：a%b，a是被模数。

结果的正负符号与被模数一致。
开发中，经常使用%来判断能否被除尽的情况。

		int m1 = 12;
        int n1 = 5;
        int l1= m1%n1;
        System.out.println(l1);//2

        int m2 = -12;
        int n2 = 5;
        int l2= m2%n2;
        System.out.println(l2);//-2

        int m3 = 12;
        int n3 = -5;
        int l3= m3%n3;
        System.out.println(l3);//2

        int m4 = -12;
        int n4 = -5;
        int l4= m4%n4;
        System.out.println(l4);//-2

（前）++、（后）++

（前）++：先自增1，然后再运算。: ++i
（后）++：先运算，后自增1。 : i++

		int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1="+a1+",b1="+b1);//a1=11,b1=11,因为前++是先自增1再运算，所以是a1先自增1后再做赋值运算给了b1，所以b1也是11。

        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2="+a2+",b2="+b2);//a2=11,b2=10,因为后++是先运算后自增1，所以b2是先被a2赋值运算后，再自增了1。

        //注意点：
        short s1 = 10;
        //s1=s1+1;编译错误 1是int型的，不能拿表数范围更小的short型的s1去接收
        s1=(short) (s1+1);
        s1++;
        s1+=1;
        System.out.println(s1);//13

        //问题：
        byte bb1 = 127;
        bb1++;
        System.out.println(bb1);//-128,因为byte是1个字节8个bit，127在内存中的二进制码是11111111，此时加00000001就变成了100000000，因为只有8个bit，
                                //所以最高位1被截断，变成了00000000，就是-128；

（前）- -、（后）- -

与自增逻辑相同

		int a4 = 10;
        int b4 = a4--;
        System.out.println("a4="+a4+",b4="+b4);//a4=9,b4=10

        int a5 = 10;
        int b5 = --a5;
        System.out.println("a5="+a5+",b5="+b5);//a5=9,b5=9

赋值符号：=

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值。
扩展赋值运算符： +=, -=, *=, /=, %=

		int i1 = 10;
        int j1 = 10;

        int i2,j2;
        i2=j2= 10;//连续赋值

        int i3=10,j3=20;

        short num1 = 10;
        num1+= 2;//类似num1 = num1 + 2;但是不会改变数据类型。
        System.out.println(num1);//12

        int num3 = 12;
        num3 %= 5;//类似num3 = num1 % 5;但是不会改变数据类型。
        System.out.println(num3);//2

        //开发中，如果希望变量实现+2的操作，有几种方法？（前提是：int num  = 10）
        //方式一：num = num + 2;
        //方式二：num += 2；（推荐）

        //开发中，如果希望变量实现+1的操作，有几种方法？（前提是：int num  = 10）
        //方式一：num = num + 1;
        //方式二：num += 1；
        //方式三：num++/++num;（推荐）

比较运算符

比较运算符： == 、!= 、>、 <、 >= 、<= 、instanceof
>比较运算符的结果都是boolean型，也就是要么是true，要么是false
>比较运算符“==”不能误写成“=”

		 int i = 10;
         int j = 20;
         System.out.println(i==j);//false
         System.out.println(i=j);//20

        boolean b3 = true;
        boolean b6 = false;
        System.out.println(b3==b6);//false
        System.out.println(b6=b3);//true

逻辑运算符

逻辑运算符：

& ：逻辑与	|：逻辑或	!：逻辑非
&&：短路与	||：短路或	^：逻辑异或

a	b	a&b	a&&b	a | b	a || b	!a	!b	a^b
true	true	true	true	true	true	false	false	false
true	false	false	false	true	true	false	true	true
false	true	false	false	true	true	true	false	true
false	false	false	false	false	false	true	true	false

a&b : a与b都是true，结果为true。否则结果为false。
a&&b：同a&b。
a | b：a与b都是false，结果为false，否则结果为true。
a||b：同a|b。
!a：结果与a相反。
a^b：a与b相同，结果为false。不同，结果为true。

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
理解：异或，追求的是“异”!

区分&和&&：
相同点1：&与&&的运算结果相同,都需要满足两者都是true。所以叫做与或且。
相同点2：当符号左边是true时，二者都会执行符号右边的运算。
不同点：当符号左边是false时，&继续执行符号右边的运算，&&不再执行符号右边的运算。
开发中推荐&&

		boolean bo1 = true;
        int numm = 10;
        if(bo1 & (numm++>0)){
            System.out.println("北京");//bo1=true,numm=11>0也是true，true & true，所以执行北京。
        }else{
            System.out.println("南京");
        }
        System.out.println(numm);//11

        boolean bo2 = true;
        int numm2 = 10;
        if(bo2 && (numm2++>0)){
            System.out.println("北京");//bo2=true,numm2=11>0也是true，true & true，所以执行北京。
        }else{
            System.out.println("南京");
        }
        System.out.println(numm2);//11

        boolean bo3 = false;
        int numm3 = 10;
        if(bo3 & (numm3++>0)){
            System.out.println("北京");
        }else{
            System.out.println("南京");//bo3=false,继续看numm3++执行后是否大于0，false & true，所以执行南京。
        }
        System.out.println(numm3);//11

        boolean bo4 = false;
        int numm4 = 10;
        if(bo4 && (numm4++>0)){
            System.out.println("北京");
        }else{
            System.out.println("南京");//bo4=false,不再看numm4++执行后是否大于0，false所以执行南京。
        }
        System.out.println(numm4);//10

区分|和||：和上面同理
相同点1：|和||的运算结果相同，只要有一个true就行。
相同点2：当符号左边是false时，二者都会执行符号右边的运算来检测右边是否为true。
不同点：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算。
开发中推荐||

	   boolean bo5 = false;
       int numm5 = 10;
       if(bo5 | (numm5++>0)){
           System.out.println("北京");//bo5=false,继续看numm5++执行后是否大于0，false | true，所以执行北京。
       }else{
           System.out.println("南京");
       }
       System.out.println(numm5);//11

       boolean bo6 = false;
       int numm6 = 10;
       if(bo6 || (numm6++>0)){
           System.out.println("北京");//bo6=false,继续看numm6++执行后是否大于0，false | true，所以执行北京。
       }else{
           System.out.println("南京");
       }
       System.out.println(numm6);//11

       boolean bo7 = true;
       int numm7 = 10;
       if(bo7 | (numm7++>0)){
           System.out.println("北京");//bo7=true,继续看numm7++执行后是否大于0，true | true，所以执行北京。
       }else{
           System.out.println("南京");
       }
       System.out.println(numm7);//11

       boolean bo8 = true;
       int numm8 = 10;
       if(bo8 || (numm8++>0)){
           System.out.println("北京");//bo8=true,不再看numm8++执行后是否大于0， true，所以执行北京。
       }else{
           System.out.println("南京");
       }
       System.out.println(numm8);//10

位运算符

位运算符：
位运算是直接对整数的二进制进行的运算

运算符	表示	范例
<<	左移	3 << 2 = 12 --> 322=12
>>	右移	3 >> 1 = 1 --> 3/2=1
>>>	无符号右移	3 >>> 1 = 1 --> 3/2=1
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 7
^	异或运算	6 ^ 3 = 5
~	取反运算	~6 = -7

位运算符的细节
<< : 空位补0，被移除的高位丢弃，空缺位补0。
>> : 被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。
>>> : 被移位二进制最高位无论是0或者是1，空缺位都用0补。
& : 二进制位进行&运算，只有1&1时结果是1，否则是0;
| : 二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;
^ : 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0,不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
~ : 正数取反，各二进制码按补码各位取反,负数取反，各二进制码按补码各位取反。

位运算符操作的都是整型数据
<<：在一点范围内，每向左移1位，相当于*2
>>：在一点范围内，每向右移1位，相当于/2

  	  int ii1 = 21;
      System.out.println("ii1<<2="+(ii1<<2));//84
      System.out.println("ii1<<3="+(ii1<<3));//168
      System.out.println("ii1<<27="+(ii1<<27));//-1400.....左移27位刚好把1停在了int的第32位，所以变成了负数。

与，或，异或：
&
0 0 0 0 1 1 0 0 = 12
0 0 0 0 0 1 0 1 = 5
0 0 0 0 0 1 0 0 = 4
|
0 0 0 0 1 1 0 0 = 12
0 0 0 0 0 1 0 1 = 5
0 0 0 0 1 1 0 1 = 13
^
0 0 0 0 1 1 0 0 = 12
0 0 0 0 0 1 0 1 = 5
0 0 0 0 1 0 0 1 = 9

 		int m = 12;
        int n = 5;
        System.out.println("m&n="+(m&n));//4
        System.out.println("m|n="+(m|n));//13
        System.out.println("m^n="+(m^n));//9

        //取反，正数和负数都直接二进制取反（包括符号位），得到它的取反。

        int a =6;
        System.out.println("~a="+(~a));

三元运算符

1、结构：（条件表达式）？表达式1：表达式2
2、说明
①条件表达式的结构为boolean类型
②根据条件表达式真或假，决定执行表达式1，还是表达式2
如果条件表达式为true，则执行表达式1
如果条件表达式为false，则执行表达式2
③表达式1和表达式2，可以不是一种类型，但是至少可以被同一种类型接收。
④三元运算符是可以嵌套使用的
3、凡是可以使用三元运算符的地方，都可以改写为if-else语句,反之不成立。
4、如果程序即可以使用三元运算，又可以使用if-else语句，那么优先使用三元运算。原因：简洁，效率高。

		int mm = 12;
        int nn = 5;
        int max = (mm>nn)?mm:nn;
        System.out.println(max);//12

        double nummm =(mm>nn)?2:1.0;//表达式1和表达式2，可以不是一种类型，但是至少可以被同一种类型接收。
        //  (mm>nn)?"m大":nn; 编译错误，表达式1和表达式2不能被同一种类型接收。

        nn=12;
        String maxStr = (mm>nn)?"m大":(mm==nn)?"m和n一样大":"n大";//可以嵌套使用
        System.out.println(maxStr);//一样大

        //三个数字求大小
        //方法一：推荐
        int nn1 = 12;
        int nn2 = 30;
        int nn3 = -43;

        int max1 = (nn1>nn2)?nn1:nn2;
        int max2 = (max1>nn3)?max1:nn3;
        System.out.println(max2);//30

        //方法二：不推荐
        int max3 =(((nn1>nn2)?nn1:nn2)>nn3)?((nn1>nn2)?nn1:nn2):nn3;
        System.out.println(max3);//30

        //改写成if-else语句
        if(mm>nn){
            System.out.println(mm);
        }else{
            System.out.println(nn);
        }