目 录CONTENT

文章目录

从0开始学Java——运算符(3)

Eric
2022-01-23 / 0 评论 / 0 点赞 / 162 阅读 / 2,621 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2023-12-12,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

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值truefalse

  • ><>=<=不支持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类型值truefalse
逻辑运算符符号解释符号特点
&与,且falsefalse
|truetrue
^异或相同为false,不同为true
!falsetrue,非truefalse
&&双与,短路与左边为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 运算符的优先级(了解)

img

注意:

  • 表达式不要太复杂。

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

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

0

评论区