美文网首页Java
6.操作符与表达式

6.操作符与表达式

作者: 荼蘼toome | 来源:发表于2020-06-19 22:41 被阅读0次

    操作符(Operator)

    也称为运算符,比如 + - * / 这些符号都是操作符

    表达式(Expression)

    是一个由数值和操作符组成的式子。把
    所有的变量的值代入表达式,计算出的最终的值,称为表达式的
    值。

    算术操作符

    操作符 名称 作用 
    +       加  加法运算
    -       减  减法运算
    *       乘  乘法运算
    /       除  除法运算
    %       模  模运算
    

    整型的算术运算

    假定在以下式子中,a,b 为 int 型。
    a + b 求和
    a - b 求差
    a * b 求积
    a / b 求商 (结果不保留小数)
    a % b 求余
    规定两个 int 型在算术运算后,结果仍为 int 型。运算规则和小
    学算术基本一样,下面只需要解释一下除法和模运算
    (1) 整型的除法运算,结果舍去小数部分
    (2) 整型的模运算,结果为余数

    浮点型的算术运算

    对于小数的算术运算,规则也是类似的。重点在于它的除法和模运算
    (1) 浮点型的除法运算,结果保留小数部分
    (2) 浮点型的模运算,结果为余数

    类型提升
    int a = 14; double b = 5.0; System.out.println( "结果为: " + ( a / b) );
    规定:当 int 型与 double 型混合运算时,把 int 型视为 double型,称为类型的提升

    这是因为,double 型是可以兼容整数的表示的,所以都提升为double 型来运算比较好,不会丢失数据。所以,上式 a/b 的结果
    按 double/double 来进行,结果为 2.8。

    混合运算与优先级

    当一个式子中包含多种符号时,需要考虑优先级问题
    a* b + c / d
    在这个式子里有 3 种运算符:乘、加、除。那么,在运算的时候,谁先执行、谁后执行是一个要考虑的问题。和直观理解的一致,
    乘、除的优先级是略高于加的

    在 Java 里规定了
    * 和 / 的优先级要高于 + ,所以才有了上面的结果。

    关系操作符

    操作符 名称
       <   小于
       <=  小于或等于
       >   大于
       >=  大于或等于
       ==  等于
       !=  不等于
    
    关系操作符的运算

    对于关系表达式,只需要把相应的值代入式子,从逻辑上判断一下。
    如果是成立的,则值为 true;如果不成立,则值为 false。
    int a = 10; System.out.println (" 结果: " + ( a < 5) );

    在 println 里的表达式最好加上小括号,以显式地指定运算的优先级。

    注意事项

    (1) 操作符是一个整体,中间不能加空格
    例如 >= <= == !=
    (2) 对于初学者来说,注意区分 == 和 =
    编程并不是数学,不要把数学的习惯带过来。当判断是否相等时,要用==来判断

    逻辑操作符

    操作符 名称   作用 
    &&     逻辑与 并且
    ||     逻辑或 或者
    !      逻辑非 非
    
    逻辑与 &&

    这个操作符用于表示“并且”的关系。形式如下,
    a && b
    其中,a,b 均为 boolean 类型。当 a 成立并且 b 成立时,结果才成立(true)。否则,结果不成立(false)。

    通俗地讲,就是表示日常生活中“并且”的逻辑。比如,一件事情需要 a,b 同时在场才能处理,那就是并且的关系。

    逻辑或 ||

    这个操作符用于表示“或者”的关系。形式如下,
    a || b
    当 a 成立或者成立时,结果成立(true)。否则,结果不成立(false)。

    通俗地讲,就是表示日常生活中“或者”的逻辑。比如,一件事情 a,b 均能处理,则只要 a 在场或者 b 在场即可,这就是或者的关系

    逻辑非 !

    逻辑非表示“否”。
    !a
    其中,如果 a 为 true,则结果为 false; 如果 a 为 false,则结果为 true。

    注意事项

    (1) 操作符是一个整体,中间不能加空格
    例如 && ||
    (2) 操作符与操作数之间,可以加空格
    比如,! k 也可以

    赋值操作符

    在 Java 语言里,等号称为赋值操作符。例如,
    a = b + 100;

    其中,不要把 Java 语言理解为数学。在 Java 里,这个等号的作用是“赋值”,就是把右侧的值赋给左边的变量。

    • 等号左边必须是变量;
      - 将等号右边表达式的值,赋给左边的变量。

    区分初始值与赋值

    在定义一个变量的时候,可以指定初始值。
    int a = 10;// 定义一个变量 a,初始值为 10
    int b;// 如果未指定初始值,则初始值为 0

    下面演示一下赋值操作。

    int a = 10;// 此行的等号为初始化
    int b = 22;// 此行的等号为初始化
    a = b + 100;// 此行的等号表示赋值操作

    赋值操作的过程

    赋值操作分为 2 步运行:
    ① 先计算等号右侧的式子的值;
    ② 再把右侧的值赋给左侧的变量。
    例如
    int a = 10; a = a + 99;// 重点理解这一行的赋值操作 System.out.println("a 的值为 " + a );

    来分析一下, a = a + 99 这一行是分两步来运算的:(1) 首先,计算出右侧表达式 (a+99) 的值,为 109;
    (2) 然后,将右侧的值赋给左侧的变量,即 a=109

    组合赋值操作符

    赋值操作符可以和其他操作符组合起来使用
    a += b; a -= b; a *= b; a /= b; a %= b;
    规则都是一样的,a+=b 相当于 a = a + b。
    int a = 10; a += 12; // 相当于 a = a + 12 System.out.println("现在 a 为: " + a); // a 的最终值为 22

    自增操作符

    在 Java 语言里,++ 称为自增操作符。
    int a = 10; a++; System.out.println("现在 a 为: " + a);
    其中,a ++ 可以理解为 a = a +1 。所以,最终 a 的值为 11

    前置自增与后置自增

    自增操作符有 2 种写法,写在前面的称为前置自增,写在后面叫后置自增。

    后置自增:

    int b = 10; a = b++ ;
    后置自增时,先把 b 的值代入式子运算,之后再对 b 自
    增加 1。所以,最终的结果 a 为 10, b 为 11。

    前置自增:

    int b = 10; a = ++b ;
    前置自增时,先对 b 自增加 1,然后再代入式子运算。
    前置自增与后置自增分辨起来有点烧脑,但它并不是 Java 编程的重点,所以不要在这个知识点上花太多时间。

    通常为了增加代码的可读性,可以分成 2 行书写。
    a = b; b ++; // 分成两行来写,以消除可能的误解

    自减操作符

    int a = 0; int b = 10; a = b --; // 先代入运算,后自减。所以 a 变成 10,b 变成 9。

    再次强调,++和--不是学习的重点,不要过分地研究和练习。

    操作符的优先级

    当一个表达式里有多种操作符时,就需要明确操作符的优先级顺序。也就是说,哪些部分先运算,哪些部分后运算。比如,
    a - b * 10 / 2
    这个表达式看起来很简单。之所以会觉得简单,因为事先知道了算术符的优先级。毕竟在小学时代就学过了算术运算的优先级,乘除法的优先级是高于加减法的
    但是,当把多种 Java 操作符综合在一起时,就不那么简单了。

    比如,
    a>10 && !ok
    对于这样的式子,含有关系操作符 > 和逻辑操作符 && ! 。
    要进行运算,就必须明确优先级。在这里,关系操作符比逻辑操作符的优先级高,而逻辑非又与逻辑与的优先级高所以,它的运算顺序是这样的:
    ( ( a>10 ) && ( !ok )
    然而,在 Java 语言里,操作符约有几十种,想要记住它们的
    优先级顺序是不太现实的,也是不必要的。并不需要强记这些优先级,只要知道几种常用的操作符的优先级就足够了。当表达式较为复杂的时候,建议多加一些小括号,用小括号来明确指定运算的先后顺序

    类型转换操作符

    在整型与浮点型之间,允许类型转换。
    double a = 12.77; int b = (int) a; // 将 double 类型转成 int 类型 System.out.println("b 的值:" + b);
    a 是 double 型 ,
    b 是 int 型,
    b = a 赋值时,要求左右两侧的类型相同。所以,可以把 a 转换成 int 型。也就是说,一个 double 类型可以转成 int 类型。把这对小括号称为类型转换操作符

    反过来,一个 int 类型也可以转换成 double 类型。
    int c = 10; double d = (double) c; // 将 int 类型转成 double 类型

    类型转换时的数据损失

    在 double -> int 的转换过程中,数据可能发生损失。
    double a = 12.77; int b = (int) a; // 存在数据损失
    转换后的 b 的结果为 12,即小数部分被截断。
    反过来,在 int -> double 的转换过程中,数据不会损失。
    int c = 10; double d = (double) c; // 没有数据损失

    显式转换与隐式转换

    在类型转换的过程中,如果没有风险和数据损失,就可以把类型转换符省略
    int c = 10; double d = c; // 省略 (double) 转换符
    在 d=c 的过程中,发生了隐式的类型转换,相当于
    int c = 10; double d = (double)c ; // 加不加 (double)都可以
    把这种自然而然的、没有任何风险的转换,称为隐式转换。如果可以隐式转换,就可以把转换符()省略不写

    注意事项

    (1) 小数转整数时,小数部分被截断。注意不是四舍五入!
    double a = 12.9; int b = (int) a; // b 的值是 12,没有四舍五入
    (2) 默认其他类型是不能转换的
    例如,boolean 与 int 是不能相互转换的。例如,
    boolean k = true; int a = (int) k; // 错!别乱写!

    相关文章

      网友评论

        本文标题:6.操作符与表达式

        本文链接:https://www.haomeiwen.com/subject/ozybxktx.html