java运算符（赋值，关系，逻辑，三目，位运算）

赋值运算符

赋值运算符：

= += -= *= /= %=

public class FuZhiOptDemo{
    public static void main(Strng[] args){
        int a1=3;
        a1+=2;
        System.out.println("a1:"+a1);
         a1-=2;
        System.out.println("a1:"+a1);
         a1*=2;
        System.out.println("a1:"+a1);
         a1/=2;
        System.out.println("a1:"+a1);
         a1%=2;
        System.out.println("a1:"+a1);
    }
}

面试题：

public class FuZhiOptDemo{
    public static void main(Strng[] args){
        short s=1,s=s+1;
        short s=1,s+=1;
        short s=1;
        s=(short)(s+1);
        System.out.println("s:"+s);
        short s=1;
        s+=1;// 并不是等同于s = s+1; 而是等同于有强制类型转换的式子：s = (short)(s + 1);
        System.out.println("s:"+s);
    }
}

关系运算符

关系运算符（比较运算符）：关系运算符一定是布尔类型的

== ！= > < >= <=

public class GuanXiOptDemo {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a>=b);
        System.out.println(a<=b);
    }
}

逻辑运算符

逻辑运算符：参与判断的是布尔类型，结果也是布尔类型

& | ^ ! && ||

public class LuoJiOptDemo1 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;

        // & 有false则false
//        System.out.println((a++>3)&(b++>4)); // false & false = false
//        System.out.println((a++>3)&(b++==4)); // false & true = false
//        System.out.println((a++==3)&(b++>4)); // true & false = false
//        System.out.println((a++==3)&(b++==4)); // true & true = true

        // | 有true则true
//        System.out.println((a++>3)|(b++>4)); // false | false = false
//        System.out.println((a++>3)|(b++==4)); // false | true = true
//        System.out.println((a++==3)|(b++>4)); // true | false = true
//        System.out.println((a++==3)|(b++==4)); // true | true = true

        // ^ 相同则false,不同则true
//        System.out.println((a++>3)^(b++>4)); // false ^ false = false
//        System.out.println((a++>3)^(b++==4)); // false ^ true = true
//        System.out.println((a++==3)^(b++>4)); // true ^ false = true
//        System.out.println((a++==3)^(b++==4)); // true ^ true = false

        // ! 将false变成true,将true变成false
        System.out.println(!(a++>3));
        
//       &&短路与: 当左边的表达式结果是false的时候，右边就不会执行，结果为false
//       ||短路或: 当左边的表达式结果是true的时候，右边就不会执行，结果为true        
//        System.out.println((a++ > 3) & (b++ > 4));
//        System.out.println((a++ > 3) && (b++ > 4)); // false && false = false

//        System.out.println((a++ > 3) && (b++ == 4)); // false & true = false
//        System.out.println((a++ == 3) && (b++ > 4)); // true & false = false
//        System.out.println((a++ == 3) & (b++ == 4)); // true & true = true

//        System.out.println((a++ > 3) | (b++ > 4));
        System.out.println(( a++ ==3) || (b++ > 4)); // true || false = true

        System.out.println("a: " + a);
        System.out.println("b: " + b);

    }
}

三目运算符

三目运算符：

 语句定义格式：(关系表达式)?表达式1:表达式2;
    注意：三目运算符必须要有一个返回结果

public class SanMuOptDemo {
    public static void main(String[] args) {
        int a = 3;
        boolean c = (a>3)?true:false;
        System.out.println(c);
    }
}

/*
    获取两个整数中的最大值
    获取三个整数中的最大值
    比较两个整数是否相同

 */
public class OptTest {
    public static void main(String[] args) {
        int a = 3;
        int b = 8;
        int res1 = (a > b) ? a : b;
        System.out.println("最大值为：" + res1);

        //获取三个整数中的最大值
        int c = 3;
        int res2 = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
        System.out.println("三个整数中最大值为：" + res2);

        //比较两个整数是否相同
        boolean res3 = (a == c) ? true : false;
        System.out.println("a和c比较的结果为：" + res3);
    }
}

位运算符

位运算符：参与运算的符号两边是数值，结果也是一个数值

& | ^ ~ >> << >>>

public class WeiOptDemo {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        System.out.println(a & b); // 0
        System.out.println(a | b); // 7
        System.out.println(a ^ b); // 7
        System.out.println(~ b); // -5
        System.out.println(24>>2); // 6  24/4=6  24/2^2=6
        System.out.println(3<<2); // 12 3*4=12 3*2^2=12
        System.out.println(-24>>>2); // 1073741818

    }
}

/*
 3的补码：00000000 00000000 00000000 00000011
    4的补码：00000000 00000000 00000000 00000100

    &：有0则0
        00000000 00000000 00000000 00000011
      &
        00000000 00000000 00000000 00000100
       --------------------------------------
        00000000 00000000 00000000 00000000  --> 0

    |：有1则1
        00000000 00000000 00000000 00000011
      |
        00000000 00000000 00000000 00000100
       --------------------------------------
        00000000 00000000 00000000 00000111  --> 7

    ^：相同则0，不同则1
        00000000 00000000 00000000 00000011
      ^
        00000000 00000000 00000000 00000100
       --------------------------------------
        00000000 00000000 00000000 00000111  --> 7

    ~：0变成1，1变成0
        00000000 00000000 00000000 00000100
     ~
        11111111 11111111 11111111 11111011
     已知补码求原码：
      补码：  1   1111111 11111111 11111111 11111011
      反码：  1   1111111 11111111 11111111 11111010
      原码：  1   0000000 00000000 00000000 00000101   -->  -5
      
      24的补码：00000000 00000000 0000000 00011000

    24>>2:
        00000000 00000000 0000000 00011000
        00000000 00000000 0000000 00000110(00)  --> 6

    3的补码：00000000 00000000 00000000 00000011
    3<<2:
        00000000 00000000 00000000 00000011
    (00)000000 00000000 00000000 0000001100   --> 12

    -24的原码：10000000 00000000 0000000 00011000
         反码：11111111 11111111 11111111 11100111
         补码：11111111 11111111 11111111 11101000

         11111111 11111111 11111111 11101000
         0011111111 11111111 11111111 111010(00)
*/

>>右移:补码向右移动若干位，右边多出的部分丢弃，左边若原本最高位是1，就用1补齐，若原本最高位是0就用0补齐
  右移n位，实际上就是除以2的n次方
<<左移:补码向左移动若干位，左边多出的部分丢弃，右边就用0补齐,左移n位，实际上就是乘2的n次方
>>>无符号右移:补码向右移动若干位，右边多出的部分丢弃，左边用0补齐