Java基本语法-运算符

• 运算符的概念
• 算术运算符
• • 除号：a / b，a是被除数。
  • %取模：a%b，a是被模数。
  • （前）++、（后）++
  • （前）- -、（后）- -
  • 赋值符号：=
• 比较运算符
• 逻辑运算符
• 位运算符
• 三元运算符

运算符的概念

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

算术运算符

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

除号：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都是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。

区分&和&&：
相同点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

位运算符

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

位运算符的细节
<< : 空位补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);
        }