Java篇第二章：运算符

public class Test {
    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类型，而且会向下取整：

public class Test {
    public static void main(String[] args) {
        int a = 7;
        int b = 3;
        System.out.println(a / b);//2
        //想要得到小数部分,在计算前将一个操作数强制转换成double或者floatl类型即可
        double c=(double)a/b;
        System.out.println(c);
    }
}

算数运算符都是二元操作符，使用时左右两边必须都要有操作数，并且做除法和取余时，右操作数不能为0

1.2 增量运算符

增量操作符操作完成后，会将运算后的结果赋值给左操作数

例如：

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

        int b=2;
        b-=1;//相当于b=b-1;
        System.out.println(b);//1

        int c=3;
        c*=3;//相当于c=c*3;
        System.out.println(c);//9

        int d=4;
        d/=2;//相当于d=d/2;
        System.out.println(d);//2

        int e=5;
        e%=2;//相当于e=e%2;
        System.out.println(e);//1

    }

注意：只有变量才能使用这类操作符，常量不能使用。

1.3 自增/自减运算符

（1）自增运算符（++）分为前置++和后置++；

前置++：是先将变量的值进行+1再使用该变量

public class Test {
    public static void main(String[] args) {
       int a=2;
       int b=++a;//先将a的值进行+1,再赋值给b
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

后置++：是先使用该变量，使用结束后，再将变量本身进行+1

public class Test {
    public static void main(String[] args) {
       int a=2;
       int b=a++;//先将a的值赋值给b，赋值完成后再对a本身进行+1
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

（2）自减运算符（--）也分为前置--和后置--，使用原理与自增运算符相同：

public class Test {
    public static void main(String[] args) {
        int a=2;
        int b=--a;//先将a的值进行-1，再将a赋值给b
        System.out.println(a);// 1
        System.out.println(b);// 1

        int c=2;
        int d=c--;//先将C的值赋值给d，再将c的值进行-1
        System.out.println(c);// 1
        System.out.println(d);// 2
    }
}

2.关系运算符

关系运算符主要有6种：==、!=、<、>、<=、>=，当表达式成立时，返回值为true，当表达式不成立时返回值为false。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
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

注意：当需要进行多次判断时，不能连着写，例如：4<a<6，程序与数学不同，所以这时候我们应该借助逻辑运算符进行多次判断。

3. 逻辑运算符

逻辑运算符主要包括三个：&&（与）、||（或）、！（非），运算结果的返回值都是boolean类型即true或者false

(1) 逻辑与 --- &&

语法规则：表达式1 &&表达式2

public class Test {
    public static void main(String[] args) {
        int a=10,b=30;
        System.out.println(a==10 && b>a);// 左右表达式的结果都为真，所以结果为true
        System.out.println(a==10 && a>b);// 左为真、右为假，所以结果为false
        System.out.println(a!=10 && a>b);// 左右表达式的结果都为假，所以结果为false
        System.out.println(a!=10 && b>a);// 左为假、右为真，所以结果为false

    }
}

只有左右两个表达式都为真，结果才为真，只要有一个为假，结果就是假。

(2) 逻辑或 --- ||

语法规则：表达式1 || 表达式2

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a == 10 || b == 20); // 左为真 且 右为真 则结果为true
        System.out.println(a == 10 || b > 100); // 左为真 但 右为假 则结果也为true
        System.out.println(a > 100 || b == 20); // 左为假 但 右为真 则结果也为true
        System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为false
    }

只要左右表达式有一个为真，那么结果就是真，只有左右表达式都为假，结果才为假。

(3) 逻辑非--- !

语法规则： ! 表达式

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(!(a == 10)); // a == 10 为true，取个非就是!true,就是false
        System.out.println(!(a != 10)); // a != 10 为false，取个非就是!false，就是true
    }
}

逻辑非的作用就是将真变假，假变真。

(4) 短路求值

&& 和 || 遵守短路求值的规则

public class Test {
    public static void main(String[] args) {
        System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
        System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
    }
}

我们都知道 , 计算 10 / 0 会导致程序抛出异常 . 但是上面的代码却能正常运行 , 说明 10 / 0 并没有真正被求值

如果表达式结果为 boolean 时 , 也表示逻辑运算：

public class Test {
    public static void main(String[] args) {
        System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
        System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
    }
}

总结：

1. 对于 && , 如果 左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式 .

2. 对于 ||, 如果 左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式 .

3. & 和 | 如果表达式结果为 boolean 时 , 也表示逻辑运算 . 但与 && || 相比 , 它们不支持短路求值 .

4. 位运算符

计算机中都是使用二进制位来表示数据的，位运算符就是对二进制位进行操作的。

（1）按位与 &：如果两个2进制位都是1，计算结果则为1，否则结果为0

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);// 结果为0
    }
}

画图演示：

（2） 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a | b);//结果为30
    }
}

画图演示：

（3） 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

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

画图演示：

（4） 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1

public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = 15;
        System.out.println(a^b);//结果为10
    }
}

画图演示：

注意：按位运算符都是对二进制补码进行操作的，正数源码、反码、补码相同，除了 ~ 是一元运算符外，其余都是二元运算符。

5. 条件运算符

条件运算符也叫做三目操作符，是条件判断语句的简化写法

例如：求两个数较大值

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
//如果a>b，那么将a的值赋给max,否则将b的值赋值给max;

注意：表达式不能单独存在，产生的结果必须要被使用

6.运算符优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如： * 和 / 的优先级要高于 + 和 -，具体的优先级规则我们 不必记忆 . 在可能存在歧义的代码中加上括号即可

public class Test {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        System.out.println((a+b)%4);//a+b=30,30%4=2
    }
}

结语

以上就是java中常用的运算符，希望大家看完本篇后能够有所收获，能够掌握这些运算符的用法，在此感谢大家的观看！！！