常量是一些不变的数据，我们用变量的方式把常量给记录下来，变量是内存中一个空间，空间中可以存储某些类型的数据，变量还有一个好处，就是可以给一些常量取名称，方便阅读；


取模运算

    就是取余数。模2运算，非0即1，用于切换。

    -3%6结果是-3 。 3%-6结果是3 。 负数运算参考左边符号。

    对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

    例如：int x=3510;x=x/1000*1000;  x的结果是3.



自增运算 ++

int a=3,b;

(a++ 对a加1再赋值给a，相当于a=a+1,)

b = a++;  //temp=a, a= a+1; b = temp;(运算原理，必须是右边都运算结束后，才可以赋值 给左边。在内存中会临时开辟一个空间temp，将a先存起来。

b = ++a;  //a = a+1; b = a;


赋值运算

    符号：

        = , +=, -=, *=, /=, %=

    示例：

        int a,b,c;  a=b=c =3;

        int a = 3;   a+=5;等同运算a=a+5;

    思考：

        short s = 3;

        s=s+2;//编译失败（类型自动转换，左边short,右边是int）

        s+=2;   //编译通过，赋值运算，具备自动转换。(+=是一个符号，只是一次赋值运算)

    有什么区别？  


比较运算

    判断是否相等   == 两个数是相等的吗？的意思。其他的比较运算符也是这样相比较的意思。

注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false


逻辑运算

    是种关系

在做比较运算的时候，比较的数据不是唯一的

        1.

               int x = 7;

                //3<x<6;（Java中无法运算）

            //逻辑运算符是用于连接boolean型表达式的。

                    // x>3 & x<6

            System.out.println(x>3 & x<6);

            /*

            true & false = false;

            false & true = false;

            false & false = false;

            true & true = true;

            &:只有两边为true结果为true，否则为false。

            或者 只要有一边为false，结果是false。

             

         2.       //x<3 | x>6

            true | false = true;

            false | true = true;

            true | true = true;

            false | false  = false;

             

            |:只有两边都为false，结果为false，否则为true。

            只要有一边为true，结果是true.

        3.异或： ^

            true ^ false = true;

            false ^ true = true;

            false ^ false = false;

            true ^ true = false;

            ^:两边相同为false，不同为true。(可以用来加密)

         

        4.   // 非判断结果的另一面  ！   boolean b = !true;

            int a = 2;

            a>3 & a<6

            a>3 && a<6 

       

        5.& 和 && 的区别：

            &：无论左边结果是什么，两边都参与运算。

            &&：当左边为false时，右边不参与运算。

         

        6.| 和 || 的区别：

            |：无论左边结果是什么，两边都参与运算。

            ||：当左边为true时，右边不参与运算。

         

         

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

            “&”和“&&”的区别：

            单&时，左边无论真假，右边都进行运算；

            双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

            “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

            异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

             

         

位运算 (不常用)  

        是直接对二进制进行运算。

    1. 左移   3<<2  3的二进制向左移动2位

        空位补0.

        3<<4 .  3乘以2的4次幂了. 当一个数想乘以2的次幂的是后可以左移。

        

    2. 右移   6的二进制向右移动一位

     

        快速运算除以2的次幂。

            >> : 高位出现空位时，原高位是什么，就补什么。

            >>> : 无论高位是什么，都补0.

             

    3.  &与运算 数字写成二进制，0为假，1为真。当两个数相同位上都为1时，结果为真，

         为1.

     

        & 与运算可以获取一段二进制中的某段二进制数字

        例如：获取0010101101中后四位数字，可以&0000001111

         

        如果想获取00 1010 1101中1010这四位数，可以无符号右移该数>>>0010101101

          

    4. |或运算  有真都为真

     

     

    5.  ^异或运算

          相同为假，异同为真

                  

        一个数据异或另一个数两次，结果还是该数。异或运算可以用于加密。

     

    6. ~反码

      ~6是对6的二进制取反。结果为-7

      -6是对6的二进制进行取反再加1

 

   位运算练习。（不常用）

        最有效率的方式算出2乘以8等于几？

                 2<<3；

         

        对两个整数变量的值进行互换(不需要第三方变量)

        int x = 3,y = 5;

         

                int z;//使用第三方变量的方式。

                 z = x;

                 x = y;

                 y = z;

         

         

          1.      x = x + y;  //x = 3 + 5;

                y = x - y;   //y = (3 + 5) - 5; y = 3;

                x = x - y;   //x = (3 + 5) - 3; x = 5;

        

          2.     x = x ^ y;  //x = 3 ^ 5;

                y = x ^ y;   //y = (3 ^ 5) ^ 5 ; y = 3;

               x = x ^ y;    //x = (3 ^ 5) ^ 3 ; x = 5;

        

三元运算

    格式

        (条件表达式)?表达式1：表达式2；

        如果条件为true，运算后的结果是表达式1；

        如果条件为false，运算后的结果是表达式2；

    示例：

        获取两个数中大数。

        int x=3,y=4,z;

    z = (x>y)?x:y;//  z变量存储的就是两个数的大数。

     

    //(条件表达式)？表达式1 :表达式2；

    int x = 1,y;

    y = x>1?100:50;

    System.out.println("y="+y); //结果是y=50.

     

    int a,b,max;

    max = a>b?a:b;如果a>b则把a赋值给max.

   

 //记住：既然是运算符，运算完都有结果。