Java-4 运算符

一、运算符：（算术运算符 赋值运算符 关系运算符 逻辑运算符 位运算符 三目运算符）

1.算术运算符 

　　

举例：＋号的使用：

1.对于数值就是加号
2.对于字符char来说，在计算之前，char会被提升为int，然后再计算
3.对于字符串String（首字母大写，并不是关键字），加号代表字符串连接操作，任何数据类型和字符串进行连接都会变成字符串
二、自增运算，自减运算(只有变量可以使用自增自减运算符，常量不可用)
1、单独使用，自己独立成为一个步骤
2、混合使用 ，和其它操作一起，例如与赋值混合，或者与打印操作混合等
使用区别：
1、单独使用++i,i++没有什么区别，两个完全一样
2、在混合的时候，有重大区别
    A、如果是i++，那么变量立刻加一，然后拿着结果使用          先加后用
    B、如果是++i，那么先使用变量本来的值，然后再让变量加一     先用后加

String str1 = "hello" ;
        String str2 = "world";
        System.out.println(str1+str2);
        System.out.println(str1+1);
        System.out.println(str1+1+2);//优先级问题 String+int+int 输出hello12
        //自增自减运算
        int i = 10 ;
        i++;//单独使用
        System.out.println(i);  //11
        ++i;
        System.out.println(i);  //12
        //与打印混合操作时
        int j = 11;
        System.out.println(++j);//12  变量立马加1打印结果
        System.out.println(j);//12
        System.out.println(j++);//12  变量先打印结果，再加1
        System.out.println(j);//13

2.赋值运算符（=  +=  -=  *=  /=  %=）

　　1. 基本赋值：=

        例子：int a = 1;

　　错误写法：int = a = b =1；

　　2.注意事项：

　　　　a += 1 ；和 a = a + 1；有什么区别？

　　　　a += 1 并不是转换成a = a + 1 ；而是转换成 a = （a的数据类型）（a + 1）

3.关系运算符

注意事项：

　　　　1. 关系运算符结果都是Boolean型，也就是要么是true，要么是false

　　　　2.如果进行多次比较不能连着写，可以使用逻辑运算符拆开写

　　　　3.常量也可以比较

4.逻辑运算符

public class LogicDemo {
    public static void main(String[] args) {
        int a = 2 ;
        int b = 3 ;
        int c = 4 ;
        //&逻辑运算   System.out.println( a & b );则变成了位运算中的与运算
        System.out.println(a > b & a < c );//false
        System.out.println(a > b & a > c );//false
        System.out.println(a < b & a < c );//true
        System.out.println(a < b & a > c );//false
        //|逻辑或运算
        System.out.println(a > b | a < c );//true
        System.out.println(a > b | a > c );//false
        System.out.println(a < b | a < c );//true
        System.out.println(a < b | a > c );//true
        //^异或运算
        System.out.println(a > b ^ a < c );//true
        System.out.println(a > b ^ a > c );//false
        System.out.println(a < b ^ a < c );//false
        System.out.println(a < b ^ a > c );//true
    }
}

　　4.1 结论：

　　　　逻辑与&：有false则false   逻辑或|：有true则true  逻辑异或^:  相同为false，不同为true

　　4.2 注意事项： 

　　　　1.逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。　

　　　　2.“&”和“&&”的区别： 单&时，左边无论真假，右边都进行运算； 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

　　　　3.“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

 int x = 3;
        int y = 4;
//        boolean b1 = ((x++==3) & (y++==4));
//        System.out.println(b1); //true
//        System.out.println("x: "+x);
//        System.out.println("y: "+y);

//        System.out.println("--------------------------");
//        boolean b2 = ((x++==5) && (y++==4));
//        System.out.println(b2); //true
//        System.out.println("x: "+x);
//        System.out.println("y: "+y);

//        boolean b2 = ((x++==3) | (y++==4));
//        System.out.println(b2); //true
//        System.out.println("x: "+x); //4
//        System.out.println("y: "+y); //5

        boolean b2 = ((x++==3) || (y++==6));
        System.out.println(b2); //true
        System.out.println("x: "+x); //4
        System.out.println("y: "+y); //4

5.位运算符

public class OptPositionDemo1 {
    public static void main(String[] args) {

        int x = 3;
        int y = 4;

        System.out.println(x&y); //0
        System.out.println(x|y); //7
        System.out.println(x^y); //7
        System.out.println(~x);  //-4

    }
}

/*
       分析：
            要先得到二进制  计算机中数据参与运算的都是补码

      3的二进制：11
      4的二进制：100
      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 00000011
         --------------------------------------
        ~ 11111111 11111111 11111111 11111100

        补码求原码：
              符号位                    数值位
        补码：  1              1111111 11111111 11111111 11111100
        反码：  1              1111111 11111111 11111111 11111011
        原码：  1              0000000 00000000 00000000 00000100
        结果是-4
 */

/*
    位运算：
            >>,>>>,<<

            <<:左移：向左移动，最高位丢弃，右边补0
            >>:右移：向右移动，最高位是0，左边补0，最高位是1，左边补1
            >>>:无符号右移：向右移动，无论最高位是0还是1，右边都用0补齐
 */
public class OptPositionDemo2 {
    public static void main(String[] args) {
        System.out.println(3 << 2);
        System.out.println(24 >> 2);
        System.out.println(24 >>> 2);

        System.out.println(-24>>2);
        System.out.println(-24>>>2);
    }
}

/*
        分析：
            想要参与位运算，就必须得先知道二进制
        1、计算出3的二进制：11
        3的二进制补码：
                       00000000 00000000 00000000 00000011
                   (00)000000 00000000 00000000 0000001100
        结果是：12

        2、计算出24的二进制：11000
        24的二进制的补码：
                       00000000 00000000 00000000 00011000
                       0000000000 00000000 00000000 000110(00)
        结果是：6


        3、计算出24的二进制：11000
        24的二进制的补码：
                       00000000 00000000 00000000 00011000
                       0000000000 00000000 00000000 000110(00)
        结果是：6

        4、计算出-24的二进制：11000
           原码： 10000000 00000000 00000000 00011000
           反码： 11111111 11111111 11111111 11100111
           补码： 11111111 11111111 11111111 11101000

           -24的补码：
                  11111111 11111111 11111111 11101000
                  11111111 11111111 11111111 11111010(00)
           补码：11111111 11111111 11111111 11111010
           反码：11111111 11111111 11111111 11111001
           原码：10000000 00000000 00000000 00000110    
           结果是：-6

       5、 计算出-24的二进制：11000
           原码： 10000000 00000000 00000000 00011000
           反码： 11111111 11111111 11111111 11100111
           补码： 11111111 11111111 11111111 11101000     //右移

           -24的补码：
                  11111111 11111111 11111111 11101000
                  0011111111 11111111 11111111 111010(00)  //无符号右移
          结果是：1073741818
 */

6.三目运算符　

1.一元运算符：只需要一个数据就可以进行操作的运算符。 例如;取反！、自增++、自减--
2.二元运算符：需要两个数据才可以操作的运算符。  例：加法+、赋值=
3.三元运算符：需要三个数据才可以进行操作的运算符
格式
数据类型 变量名称 = 条件判断 ？表达式A ：表达式B;
流程：
    如果条件判断成立，将表达式A的值赋值给左侧变量
    如果不成立，将表达式B的值赋值给左侧变量
注意事项：
    1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求
    2.三元运算符的结果必须被使用

public class Perator1 {
    public static void main(String[] args) {
        int a = 10 ;
        a += 10 ;
        System.out.println(a);//20

        //三元运算符
        int b = 20 ;
        int c = 30 ;
        int max = b > c ? b : c ;
        System.out.println("最大值"+max);   //正确写法
        System.out.println(b > c ? b : c ); //正确写法
        //int result = 3 > 4 ? 2.5 : 3;   //错误写法   必须同时保证表达式A和表达式B都符合左侧数据类型的要求
    }
}