3.运算符 —— Java SE

1. 运算符是什么

运算符就是对操作数进行操作时的符号

如 a+b;a<b;//+ < 就是运算符

在Java中也提供了一套丰富的运算符来操纵变量，运算符可分为以下：算数运算符（+-*/%），

关系运算符（<>==），逻辑运算符，位运算符，移位运算符，条件运算符等。

2. 算数运算符

2.1 基本四则运算符：加减乘除模

基本的四则运算符：+ - * / %,直接上个例子，直观的看一下

public class TestDome {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(a+b);//30
        System.out.println(a-b);//10
        System.out.println(a*b);//200
        System.out.println(a/b);//2
        System.out.println(a%b);//0
    }
}

注意在int/int时结果还是int，并且会向下取整

下面看一下，在这基本的四则运算符中：+ - * / %，容易出现的问题

（1）运算除法输出完整的数字，包括小数点后的数字

    public static void main(String[] args) {
        int a = 3;
        int b = 2;
        System.out.println(a/b);
        //在数学中a/b应该等于1.5，但在Java中等于1，因为会int会向下取整，也就是小数点后都会舍弃掉

        //要想让结果等于1.5，可以用double类型来接收
        double d = (double)a/b;
        System.out.println(d);
    }

（2）除法和取模时，右操作数不能为0，也就是除数

    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a/b);
        //运行结果会报错
    }

运行结果会报错，这里是异常，指的是这个程序运行时，出现的不正常行为

（3）%既可以对整形取模，也可以对double取模，但是没有意义

    public static void main(String[] args) {
        System.out.println(11.5%2.0);//1.5
    }

（4）两侧操作数类型不一致时，向类型大的提升

    public static void main(String[] args) {
        System.out.println(1+0.2);//1.2
        //+的左侧是int，右侧是double，在加之前int被提升为double
    }

2.2 增量运算符

这种运算符（+=，-=，/=, %=, *=）操作完成后，会将结果赋值给左操作数，直接看例子吧

    public static void main(String[] args) {
        int a = 1;
        a += 2;//相当于a=a+2
        System.out.println(a);//3

        a -= 1;//a=a-1
        System.out.println(a);//2

        a *= 3;//a=a*3
        System.out.println(a);//6

        a /= 3;//a=a/3
        System.out.println(a);//2

        a %= 3;//a=a%3
        System.out.println(a);//2
    }

注意，只有变量才能使用该运算符，常量不能使用

2.3 自增/自减运算符

++是给变量的值 +1，--是给变量的值 -1

下面举个自增++的例子，--类似

    public static void main(String[] args) {
        int a = 1;
        a++;//2
        //后置++，表示先使用后++，此时a为2
        System.out.println(a++);//2
        //后置++，表示先使用后++，先使用的话a为2，用完后给a+1，
        System.out.println(a);//3
        //前面用完a++后，a变为了3，这里直接输出3

        ++a;//4
        // 前置++，表示先++，后使用
        System.out.println(++a);//5
        //后置++，先++后使用，所以先给a+1就等于5，然后再输出
        System.out.println(a);//5
        //前面是先++,再使用的，所以不用考虑，直接输出5
    }

注意：（1）在单独使用时，前置++和后置++，没有区别

       （2）**在混合使用时，要区分是前置++，还是后置++，**

** 前置++，就是先++，后使用；后置++，就是先使用，后++**

3. 关系运算符

关系运算符有六种（==, !=, < , >, <=, >=）

这里注意，计算结果是true和false，和C语言要区别开

直接看例子吧

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
        System.out.println(a<b);//true
        System.out.println(a>b);//false
        System.out.println(a<=b);//true
        System.out.println(a>=b);//false
    }

和C语言一样的是，比如 =是赋值，==是相等

同样，比如需要多次判断时，不能连着写，比如3<a<5,

可以写为 3<a&&a<5

4. 逻辑运算符

逻辑运算符主要有三个（&&, ||, !）,注意在逻辑运算符中，使用的表达式，都必须为布尔表达式，并且运算结果都是boolean类型

4.1 逻辑与&&

布尔表达式1 && 布尔表达式2 //运算结果是true或falsel类型

逻辑与的结果用数学上的话来说，就是****一假必假

    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        //逻辑与真假判断用数学上的话是，一假必假
        System.out.println(a==1 && b==2);//左为真，右为真，结果为ture
        System.out.println(a==1 && b>100);//左为真，右为假，结果为false
        System.out.println(a>100 && b==2);//左为假，右为真，结果为false
        System.out.println(a>100 && b>100);//左为假，右为假，结果为false
    }

4.2 逻辑或||

布尔表达式1 || 布尔表达式2 //运算结果是true或falsel类型

逻辑或的结果用数学上的话来说，就是****一真必真

    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        //逻辑或真假判断用数学上的话是，一真必真
        System.out.println(a==1 || b==2);//左为真，右为真，结果为ture
        System.out.println(a==1 || b>100);//左为真，右为假，结果为ture
        System.out.println(a>100 || b==2);//左为假，右为真，结果为ture
        System.out.println(a>100 || b>100);//左为假，右为假，结果为false
    }

4.3 逻辑非！

逻辑非！，就是取反，真变假，假变真

    public static void main(String[] args) {
        int a = 1;
        System.out.println(!(a==1));//a==1为true,取反是false
        System.out.println(!(a!=1));//a!=1为false，取反是true
    }

4.4 短路求值

与C语言不同的是Java多了个短路求值，&&和||遵循短路求值规则

（1）布尔表达式1 && 布尔表达式2

如果布尔表达式1为false，那么表达式结果一定为false，不执行布尔表达式2

（1）布尔表达式1 || 布尔表达式2

如果布尔表达式1为true，那么表达式结果一定为true，不执行布尔表达式2

    public static void main(String[] args) {
        System.out.println(10>20 && 10/0==0);//false
        //&&左边表达式为假，直接输出false，不看&&右边的表达式
        System.out.println(10<20 || 10/0==0);//true
        //||左边表达式为真，直接输出true，不看||右边的表达式
    }

5. 位运算符

Java中数据存储最小单位是字节，而数据操作的最小单位是比特位，1Byte=8bit

位运算符有四个（&， |， ， ^）,是一元运算符，剩下的三种是二元运算符

位操作是按二进制位运算，按位运算就是按照二进制位的每一位依次进行运算

5.1 按位与&

按位与 就是两个2进制位都是1，结果就是1，否则是0

   public static void main(String[] args) {
        int a = 10;
        int b = 23;
        System.out.println(a & b);//2
    }

5.2 按位或|

按位或 就是两个2进制位，只要有一个有1，那结果就是1

    public static void main(String[] args) {
        int a = 10;
        int b = 23;
        System.out.println(a | b);//31
    }

5.3 按位取反~

按位取反 该位为0，就变为1；该位为1，就变为0；

    public static void main(String[] args) {
        int a = 10;
        System.out.println(~a);//-11
    }

5.4 按位异或^

按位异或 如果两个数字的二进制位相同，则结果为0，相异结果为1

    public static void main(String[] args) {
        int a = 10;
        int b = 6;
        System.out.println(a^b);
    }

6. 移位运算符

移位运算符有三个（<<, >>, >>> ）,都是二元运算符

6.1 左移<<

最左侧的位不要了，最右侧补0

    public static void main(String[] args) {
        int a = 20;
        System.out.println(a<<2);//80
    }

6.2 右移>>

同理最右侧的二进制位不要，最左侧补0

    public static void main(String[] args) {
        int a = 20;
        System.out.println(a>>2);
    }

6.3 无符号右移>>>

最右侧位二进制不要了，最左侧补0

不管符号位是0，还是1，都补0

   public static void main(String[] args) {
        int a = 20;
        System.out.println(a>>>2);//5
    }

7. 条件运算符

布尔表达式1？表达式2：表达式3

布尔表达式1为真，执行表达式2，否则执行表达式3

（1）表达式2,3要同类型的

（2）表达式不能单独存在，也就是产生的结果必须要被使用

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = a>b?a:b;
        System.out.println(max);//20
    }

int c = a>b?1:2.0;//报错，必须是同类型

a>b?a:b;//报错，表达式不能单独存在，结果必须被使用

8. 运算符优先级

这里只需要记住一句话，运算符是有优先级的，具体的规则我们不用记忆，只要感觉代码有歧义就加括号