1 概述

• 表达式：用运算符连接起来的式子。

• 运算符的分类：

• • 按照功能分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、条件运算符……

分类	运算符
算术运算符	+、-、*、/、%、++、--
赋值运算符	=、+=、-=、*=、/=、%=等
关系运算符	>、>=、<、<=、==、!=
逻辑运算符	&、|、^、!、&&、||
条件运算符	(条件表达式)?结果1:结果2；
位运算符（了解）	&、|、~、^、<<、>>、>>>

• • 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）
• • • 一元运算符：操作数只有一个
• • • • 例如：
• • • • • 正号（+）：+a
• • • • • 负号（-）：-a
• • • • • 自增（++）：++i
• • • • • 逻辑非：!true
• • • 二元运算符：操作数有两个
• • • • 例如：
• • • • • 加法：a + b
• • • • • 大于：a > b
• • • • • 逻辑与：a && b
• • • 三元运算符：条件 ? 结果1 ：结果2。

2 算术运算符

2.1 概述

算术运算符	符号解释
+	加法运算，字符串连接运算，正号
-	减法运算，负号
*	乘法运算
/	除法运算，整数/整数结果还是整数
%	求余运算，余数的符号只看被除数
++ 、--	自增自减运算

2.2 应用示例

• 示例：

/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-01 21:21
 */
public class ArithmeticOperator {
    public static void main(String[] args) {
        // 正号：+
        int operator01 = +5;
        System.out.println("operator01 = " + operator01); // 5

        // 负号：-
        int operator02 = -5;
        System.out.println("operator02 = " + operator02); // -5

        // 负负得正
        int operator03 = -3;
        System.out.println("operator03 = " + -operator03); // 3

        // 加法: +
        int operatorAdd01 = 1;
        int operatorAdd02 = 2;

        int addResult = operatorAdd01 + operatorAdd02;
        System.out.println("addResult = " + addResult);// 3

        double operatorAdd03 = 10.2;
        double operatorAdd04 = 3.8;

        double addResultDouble = operatorAdd03 + operatorAdd04;
        System.out.println("addResultDouble = " + addResultDouble); // 14.0

        // 减法：-
        int operatorMinus01 = 1;
        int operatorMinus02 = 2;

        int minusResult = operatorMinus01 - operatorMinus02;
        System.out.println("minusResult = " + minusResult); // -1

        // 乘法：*
        int operatorMulti01 = 1;
        int operatorMulti02 = 2;

        int multiResult = operatorMulti01 * operatorMulti02;
        System.out.println("multiResult = " + multiResult); // 2

        // 除法：/ ，注意：除数不能为0
        int operatorDivision01 = 6;
        int operatorDivision02 = 3;

        int divisionResult = operatorDivision01 / operatorDivision02;
        System.out.println("divisionResult = " + divisionResult); // 2

        int operatorDivision03 = 6;
        int operatorDivision04 = 4;

        int divisionResult2 = operatorDivision03 / operatorDivision04;
        System.out.println("divisionResult2 = " + divisionResult2); // 1

        // 取模：%
        int mod = operatorDivision03 % operatorDivision04;
        System.out.println("mod = " + mod); // 2

    }
}

2.3 “+”号的两种用法

• ①对于“+”号两边都是数值的情况，“+”就是加法的意思。

• ②对于“+”号两边至少一边是字符串的情况，“+”就是拼接的意思。

• 示例：

/**
 * 加号的用法
 * <p>
 * 第一种：对于`+`两边都是数值的话，`+`就是加法的意思
 * <p>
 * 第二种：对于`+`两边至少有一边是字符串得话，`+`就是拼接的意思
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-02 20:52
 */
public class PlusDemo {
    public static void main(String[] args) {
        String str = "Hello";
        System.out.println("str = " + str); // Hello

        System.out.println(str + "World"); // HelloWorld

        String str2 = "Java";

        System.out.println(str2 + 520); // Java520

        System.out.println(str2 + 5 + 20); // Java520
    }
}

2.4 自增自减运算

2.4.1 概述

• ++运算，变量自身+1；反之，--运算，变量自身-1。

2.4.2 单独使用

• 变量在单独运算的使用，变量前++和变量后++，变量的值是一样的。

• 变量前++：例如++a。

• 变量后++：例如a++。

• 示例：

/**
 * 自增和自减
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-02 20:59
 */
public class IncreaseAndDecrease {
    public static void main(String[] args) {
        int a = 3;
        a++;
        System.out.println("a = " + a); // a = 4

        int b = 3;
        ++b;
        System.out.println("b = " + b); // b = 4
    }
}

2.4.3 复合使用

• 和其他变量放在一起使用或者和输出语句在一起使用，前++和后++就产生了不同。

• 变量前++：变量先自身加1，然后再取值。

• 变量后++：变量先取值，然后再自身加1。

总结：

• ++在前，先自增，后使用。

• ++在后，先使用，后自增。

• 示例：

/**
 * 自增和自减
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-02 21:03
 */
public class IncreaseAndDecrease2 {
    public static void main(String[] args) {
        int x = 3;
        int y = x++;
        System.out.println("x = " + x); // x = 4
        System.out.println("y = " + y); // y = 3

        int z = 5;

        System.out.println("z++ = " + z++); // z++ = 5
        System.out.println("z = " + z); // z = 6

        int a = 1;
        a = a++;
        System.out.println("a = " + a); // a = 1

    }
}

3 赋值运算符

3.1 概述

赋值运算符	符号解释
=	将符号右边的值，赋值给左边的变量
+=	将符号**左边的值**和**右边的值**进行相加操作，最后将结果**赋值给左边的变量**
-=	将符号**左边的值**和**右边的值**进行相减操作，最后将结果**赋值给左边的变量**
*=	将符号**左边的值**和**右边的值**进行相乘操作，最后将结果**赋值给左边的变量**
/=	将符号**左边的值**和**右边的值**进行相除操作，最后将结果**赋值给左边的变量**
%=	将符号**左边的值**和**右边的值**进行取余操作，最后将结果**赋值给左边的变量**

注意：

• 所有的赋值运算符的左边一定是一个变量。

• 扩展赋值运算符将最后的结果赋值给左边的变量前，都做了强制类型转换。

3.2 应用示例

• 示例：

/**
 * 赋值运算符
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-03 20:39
 */
public class AssignmentOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        a = a + b;
        System.out.println("a = " + a); // 7
        System.out.println("b = " + b); // 4
    }
}

• 示例：

/**
 * 扩展赋值运算符
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-03 20:52
 */
public class AssignmentOperator2 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        b += a; // 相当于 b = b + a;
        System.out.println("a = " + a); // a = 3
        System.out.println("b = " + b); // b = 7

        short s = 3;
        // s = s + 4; 代码编译错误，因为将int类型的结果赋值给short类型的变量s，可能损失精度
        s += 4; // 代码没有报错，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型转换成short
        System.out.println("s = " + s); // s = 7

        int j = 1;
        j += ++j * j++; // 相当于  j = j + (++j * j++);
        System.out.println(j); // 5
    }
}

4 关系运算符（比较运算符）

4.1 概述

关系运算符	符号解释
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=	比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。
>=	比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。
==	比较符号两边数据是否相等，相等结果是true。
!=	不等于符号 ，如果符号两边的数据不相等，结果是true。

注意：

• 比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或false。

• >、<、>=、<=不支持boolean和String类型。

• ==和!=支持boolean和String类型。

4.2 应用示例

• 示例：

/**
 * 关系运算符
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-04 21:58
 */
public class RelationOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;

        System.out.println(a < b); // true
        System.out.println(a > b); // false
        System.out.println(a <= b); // true
        System.out.println(a >= b); // false
        System.out.println(a == b); // false
        System.out.println(a != b); // true
    }
}

5 逻辑运算符

5.1 概述

• 逻辑运算符，是用来连接两个boolean类型结果的运算符（!除外），运算结果一定是boolean类型值true或false。

逻辑运算符	符号解释	符号特点
&	与，且	有false则false
|	或	有true则true
^	异或	相同为false，不同为true
!	非	非false则true，非true则false
&&	双与，短路与	左边为false，则右边就不看
||	双或，短路或	左边为true，则右边就不看

5.2 应用示例

• 示例：

/**
 * 逻辑运算符
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-05 06:02
 */
public class LogicOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        // & 与，且；有false则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)); // false
        System.out.println("===============");

        // | 或；有true则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("===============");

        // ^ 异或；相同为false，不同为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)); // false
        System.out.println("===============");

        // ! 非：非false则true，非true则false
        System.out.println(!false); // true
        System.out.println(!true); // false

    }
}

5.3 &&和&区别，||和|区别

• **&&**和**&**区别：&&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。

• **||**和**|**区别：||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。

6 条件运算符（三元运算符）

6.1 概述

• 语法：

条件表达式 ？结果1：结果2

• 条件表达式的结果是true，条件运算符整体结果为结果1，赋值给变量。

• 条件表达式的结果是false，条件运算符整体结果为结果2，赋值给变量。

6.2 应用示例

• 示例：

/**
 * 三元运算符
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-05 06:16
 */
public class ConditionOperator {
    public static void main(String[] args) {
        int i = (1 == 2) ? 100 : 200;
        System.out.println("i = " + i); // i = 200

        int j = (3 <= 4) ? 500 : 600;
        System.out.println("j = " + j); // j = 500
    }
}

7 运算符的优先级（了解）

注意：

• 表达式不要太复杂。

• 先算的使用()，提升优先级。

• 大体的排序：算术->位-->比较-->逻辑-->三元-->赋值。