你的位置:首页 > 信息动态 > 新闻中心
信息动态
联系我们

从零开始学Java-Day04 彻底搞懂运算符

2021-11-24 12:46:27

今天我们开始第四天的学习,学习是一个艰苦的过程,让我们努力付出,享受收获吧!

这边我放上前几期的链接,希望可以到帮助大家

目录内容链接
从零开始学Java-Day01Java简介、编写第一个Java程序从零开始学Java - Day01_阿怂Jun的博客-CSDN博客前言: 作为一个非科班毕业的大专生,很高兴能够进入Java这个大家庭。在这里,我会分享一些Java初学阶段所需要知道的一些内容,如果各位感觉有什么写的不对的地方,可以随意指出,我们共同学习,共同进步。一、计算机简介在开始学习Java之前,我们首先需要了解一些计算机的一些常识。相信大家可能比我还要了解计算机了,这里我就找了些资料,简单的描述一下。1.1、第一台计算机的诞生世界上第一台通用计算机“ENIAC”于1946年2月14日...https://blog.csdn.net/weixin_57228654/article/details/121095116?spm=1001.2014.3001.5502
从零开始学Java-Day02八大基本数据类型从零开始学Java - Day02_阿怂Jun的博客-CSDN博客今天,我们学习Java的一些基础知识,循序渐进,让我们慢慢的发现Java的魅力!一、Java须知的命名规则和规范 1.1 标识符 标识符,通俗意义上讲,就是我们程序员自己定义的名称,例如类名,方法名,变量名等等。也可以这样理解,只要需要我们自己起名字的,就是标识符。当然,名字也不能随便取,Java定义了合法标识符的规则: 1)由26个英文字母大小写,0-9,_或者$组成 2)数字不可以开头...https://blog.csdn.net/weixin_57228654/article/details/121122112?spm=1001.2014.3001.5502
从零开始学Java-Day03变量、常量、数据类型转换从零开始学Java-Day03 -- 基础语法、类型转换_阿怂Jun的博客-CSDN博客兄弟们,时隔多天,我们又见面了。今天,我们学习一下Java的一些基础语法。一、常量 常量的定义:常量就是固定不变的量,一旦被定义,它的值就不能再被改变。通过final关键字进行修饰,是否使用static关键字根据实际情况而定。 常量的语法:final 数据类型 常量名 = 值; 使用示例:/** * Java基础语法 */public class JavaGrammar { s...https://blog.csdn.net/weixin_57228654/article/details/121222314?spm=1001.2014.3001.5502

目录

 一、运算符

         1.1、算术运算符

        1.2、关系运算符 

        1.3、赋值运算符 

        1.4、逻辑运算符

        1.5、位运算符

二、运算符的优先级 


 

 一、运算符

        Java中的语句有多种形式,表达式就是其中的一种形式。表达式是由操作数与运算符所组成;
        例如表达式(num + 100),“num” 与 “100”都是操作数,而“+”就是运算符。

         1.1、算术运算符

        算术运算符主要用于进行基本的算术运算,如加减乘除等。

  

代码示例:

/**
 * 算术运算符演示
 */
public class CountTest {
    public static void main(String[] args) {
        int number1 = 10;
        int number2 = 3;
        /*
        *   ‘+’,用于运算操作时,表示加法运算
        * */
        int result = number1 + number2;
        System.out.println("+ :result = " + result);

        /*
        *   '-',用于运算操作时,表示减法运算
        * */
        result = number1 + number2;
        System.out.println("- :result = " + result);

        /*
         *   '*',用于运算操作时,表示乘法运算
         * */
        result = number1 * number2;
        System.out.println("* :result = " + result);

        /*
         *   '/',用于运算操作时,表示除法运算
         * */
        result = number1 / number2;
        System.out.println("/ :result = " + result);

        /*
         *   '%',用于运算操作时,表示取余(取模)运算
         *   这里需要注意:取余结果的正负取决于被余数。
         * */
        result = 10 % 3;
        System.out.println("% :result = " + result);
        result = 10 % -3;
        System.out.println("% :result = " + result);
        result = -10 % 3;
        System.out.println("% :result = " + result);
        result = -10 % -3;
        System.out.println("% :result = " + result);

        /*
         *   '++',用于运算操作时,表示自增1运算
         *   ++在操作数后面时,表示这次操作结束后进行自增
         *   ++在操作数前面时,表示先进行自增,自增完成后再继续操作
         * */
        //这次运算结束后,number1被赋值为11
        result = number1++;
        System.out.println("number1++:result = " + result);
        //这里number1的值已经为11了,在进行一次自增1,所以number的值为12
        result = ++number1;
        System.out.println("++number1:result = " + result);

        /*
         *   '--',用于运算操作时,表示自减1运算
         *   --在操作数后面时,表示这次操作结束后进行自减
         *   --在操作数前面时,表示先进行自减,自减完成后再继续操作
         * */
        //程序运行到这里,number1的值已经经过自增操作后变成了12,在这次操作结束后进行自减1
        result = number1--;
        System.out.println("number1--:result = " + result);
        //这里number1已经自减过一次,值为11,又因为这次--在操作数前面,先进行自减,再操作。所以11再自减1,最终值为10
        result = --number1;
        System.out.println("--number1:result = " + result);
    }
}

运行结果如下:

 注意点:

        1)进行取余操作时,计算结果的正负取决于被余数。

        2)‘+’ 在算术运算中做加法处理,不过在处理字符串时,被当做拼接符。

        3)在‘++’,‘--’操作时,当运算符在操作数的左边时,先自增/自减,再赋值。当运算符在操作数的右边是,先赋值,再自增/自减。

        4)在‘++’,‘--’操作时,运算符只能对变量进行操作,无法直接用于常量和数值。例如 5++,6--这样的写法是错误的。

        5)在进行除法运算时,当除数和被除数都为整数时,得到的结果会忽略小数点后面的小数部分,结果只取整数。当除数或被除数有一方为小数时,结果会是一个小数。

        1.2、关系运算符 

        Java中的关系运算符的表示方式和在数学中类似,但是由于赋值运算符为“=”,为了避免混淆,关系运算符“等于”时,必须用“==”表示;而关系运算符“不等于”“!=”表示,这是因为键盘想输入数学中的“≠”符号毕竟困难,所以就使用“!=”表示不等于。关系运算符用于对两个数值或变量进行比较,得到的结果是一个布尔值。

 代码示例:

/**
 * 关系运算符演示
 */
public class RelationalOperator {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;  //声明两个变量
        boolean result; //定义一个boolean类型result保存结果
        result = a > b;
        System.out.println("a > b:result = " + result);
        result = a < b;
        System.out.println("a < b:result = " + result);
        result = a >= b;
        System.out.println("a >= b:result = " + result);
        result = a + 1 >= b;
        System.out.println("a + 1 >= b:result = " + result);
        result = a <= b;
        System.out.println("a <= b:result = " + result);
        result = a + 1 <= b;
        System.out.println("a + 1 <= b:result = " + result);
        result = a == b;
        System.out.println("a == b:result = " + result);
        result = a != b;
        System.out.println("a != b:result = " + result);
    }
}

运行结果如下:

         注意:Java允许“==”和“!=”两种运算符用于任何数据类型,例如,既可以判断两个数的值是否相等,也可以判断对象或数组的实例是否相等。判断实例时比较的是两个对象在内存中的引用地址是否相等。

        1.3、赋值运算符 

        赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量

代码示例:

/**
 * 赋值运算符演示
 */
public class AssigningOperator {
    public static void main(String[] args) {
        /*
         *  “=”就是将右边的表达式或变量的值传入左边的变量中
         * */
        int a = 10;
        int b = 4;

        /*
        * +=在这里相当于a = a + b;
        * 程序走到这里 a = 14; b = 4
        * */
        a += b;
        System.out.println("a = " + a);

        /*
         * -=在这里相当于a = a - b;
         * 程序走到这里 a = 10; b = 4
         * */
        a -= b;
        System.out.println("a = " + a);

        /*
         * *=在这里相当于a = a * b;
         * 程序走到这里 a = 40; b = 4
         * */
        a *= b;
        System.out.println("a = " + a);

        /*
         * /=在这里相当于a = a / b;
         * 程序走到这里 a = 10; b =4
         * */
        a /= b;
        System.out.println("a = " + a);

        /*
         * %=在这里相当于a = a % b;
         * 程序走到这里 a = 2; b =4
         * */
        a %= b;
        System.out.println("a = " + a);

    }
}

运行结果如下:

        1.4、逻辑运算符

         逻辑运算符主要用于进行逻辑运算

        

代码示例:

/**
 * 逻辑运算符演示
 */
public class LogicalOperator {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;

        /*
        * 一假即假
        * 当 a < b  并且 ++a < b 同时满足时,返回true,否则返回false
        * ‘&’,当第一个条件判断为false时,仍然会继续执行第二个条件进行判断
        * */
        System.out.println(a > b & ++a < b);    //此时a = 2;b = 2
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("=======================");

        /*
         * 一假即假
         * 当 a < b  并且 ++a < b 同时满足时,返回true,否则返回false
         *“&&”,当第一个条件判断为false时,语句直接结束,不会继续执行
         * */
        System.out.println(a < b && ++a < b);   //此时a = 2;b = 2
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("=======================");

        /*
        * 一真即真
        * 当a == b 或者 a > ++b中  有一个满足条件,返回true,两个都不满足则返回false
        * ‘|’,当第一个条件判断为true时,仍然会继续执行第二个条件进行判断
        * */
        System.out.println(a == b | a > ++b);   //此时a = 2; b =3
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("=======================");

        /*
         * 一真即真
         * 当a == b 或者 a > ++b中  有一个满足条件,返回true,两个都不满足则返回false
         * ‘|’,当第一个条件判断为true时,语句直接结束,不会继续执行
         * */
        System.out.println(a < b || a > ++b);   //此时a = 2; b =3
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("=======================");

        /*
        * ‘!’,结果取反,如果(a < b)返回true,则!(a<b)就返回false,反之亦然。
        * */
        System.out.println(!(a < b));   //此时a = 2; b =3
        System.out.println(!(a > b));
        System.out.println("=======================");

        /*
        * ‘^’,当两边的表达式返回结果不一样时,返回true,若两边表达式返回一样,返回false
        * 此时a = 2; b =3
        * */
        System.out.println(a < b ^ a > b);  //左边表达式返回true,右边表达式返回false,最终返回true
        System.out.println(a < b ^ b > a);  //左边表达式返回true,右边表达式返回true,最终返回false
        System.out.println(a > b ^ b < a);  //左边表达式返回false,右边表达式返回false,最终返回false
    }
}

运行结果如下:

注意:“|| / &&”,当第一个条件就能判断出结果的时候,语句就不会继续执行,效率要高于“| / &”。

        1.5、位运算符

        位运算就是操作数进行二进制的运算。

代码示例:

        

/**
 * 位运算符演示
 */
public class AnOperator {
    public static void main(String[] args) {
        /*
        * “&”与运算符,在位运算中,如果两个二进制位都为1,则该位的运算结果为1,否则为0.
        * 可以理解为:遇0为0,无0为1。
        *我们可以看一下下面两个表达式的运算过程:
        * 1的二进制:0000 0001,2的二进制:0000 0010
        *       0000 0001
        *     & 0000 0010
        *     =============
        *       0000 0000       转换为十进制为:0
        *
        * 11的的二进制:0000 1011,22的二进制为:0001 0110
        *       0000 1011
        *     & 0001 0110
        *     =============
        *       0000 0010       转换为十进制为:2
        * */
        System.out.println("&运算符:" + (1 & 2));  //运行结果:0
        System.out.println("&运算符:" + (11 & 22));    //运行结果:2
        System.out.println("======================");

        /*
        * “|”或运算符,在位运算中,如果二进制位上有一个值为1,则该位的运行结果为1,否则为0
         * 1的二进制:0000 0001,2的二进制:0000 0010
         *       0000 0001
         *     | 0000 0010
         *     =============
         *       0000 0011       转换为十进制为:3
         *
         * 11的的二进制:0000 1011,22的二进制为:0001 0110
         *       0000 1011
         *     | 0001 0110
         *     =============
         *       0001 1111       转换为十进制为:31        * */
        System.out.println("|运算符:" + (1 | 2));      //运行结果:3
        System.out.println("|运算符:" + (11 | 22));    //运行结果:31
        System.out.println("======================");

        /*
        *“^”异或运算符,在位运算中,如果二进制位相同,则值为0,否则为1
         * 1的二进制:0000 0001,2的二进制:0000 0010
         *       0000 0001
         *     ^ 0000 0010
         *     =============
         *       0000 0011       转换为十进制为:3
         *
         * 11的的二进制:0000 1011,22的二进制为:0001 0110
         *       0000 1011
         *     ^ 0001 0110
         *     =============
         *       0001 1101       转换为十进制为:29
        * */
        System.out.println("^运算符:" + (1 ^ 2));      //运行结果:3
        System.out.println("^运算符:" + (11 ^ 22));    //运行结果:29
        System.out.println("======================");


        /*
        * “~”取反运算符,只对一个操作数进行运算,如果二进制位是0,则取反值为1;如果是1,则取反值为0
        * 2的二进制:0000 0010
        * 取反后:1111 1101 ,转换为二进制为:-3
        * 22的二进制位:0001 0110
        * 取反后:1110 1001,转换为二进制为:-23
        * */
        System.out.println("~运算符:" + ~2);  //运行结果:-3
        System.out.println("~运算符:" + ~22);  //运行结果:-23
        System.out.println("======================");

        /*
        * “<<”左移运算符,就是将被操作数转换为2进制后,向左移动指定的位数,空位补0;
        * 127的二进制:0111 1111
        * 进行“<<2”位的运算后:01 1111 1100,转换为十进制后:508
        * 22的二进制:0001 0110
        * 进行“<<2”位的运算后:0101 1000,转换为十进制后:88
        * */
        System.out.println("<<运算符:" + (127 << 2));    //运行结果:508
        System.out.println("<<运算符:" + (22 << 2));     //运行结果:88
        System.out.println("======================");

        /*
        * “>>”右移运算符,就是将被操作数转换为2进制后,向右移动指定的位数,正数空位补0,负数空位补1
        * 127的二进制:0111 1111
        * 进行“>>2”位的运算后:0001 1111,转换为十进制后:31
        * -22的二进制:1001 0110
        * 进行“>>2”位的运算后:1000 0101,转换为十进制后:-6
        * */
        System.out.println(">>运算符:" + (127 >> 2));    //运行结果:31
        System.out.println(">>运算符:" + (-22 >> 2));     //运行结果:-6
        System.out.println("======================");

        /*
        * “>>>”无符号位移符,无符号右移的计算规则与右移相同,区别在于,不会进行正负的区分,高位一律用0补位
        *22转换为32位的二进制数: 0000 0000 0000 0000 0000 0000 0001 0110,
        * 进行“>>>2”位的运算后:0000 0000 0000 0000 0000 0000 0000 0101,转换为10进制为:5
        * -22转换为32位的二进制数: 1000 0000 0000 0000 0000 0000 0001 0110,
        * 取补码:                  1111 1111 1111 1111 1111 1111 1110 1010
        * 进行“>>>2”位的运算后:  0011 1111 1111 1111 1111 1111 1111 1010
        * 转换为10进制后:1073741818
        * */
        System.out.println(">>>运算符:" + (22 >>> 2));     //运行结果:5
        System.out.println(">>>运算符:" + (-22 >>> 2));    //运行结果:1073741818
        int i = 1073741821;
    }
}

 运行结果如下:

为了方便理解<</>>/>>>三个位操作符,可以看下面这张图:

注意:

        1)移动的位数不应该超过该数字对应的二进制位数,不然会得到毫无意义的结果。
        2)当x,y都为正整数时,且满足第一条注意事项的情况下,进行
x << y运算时,运算结果和 {\color{Magenta} }x*2^y相同。进行x>>y运算时,运算结果和x/2^y相同。
        3)>>>无论正负最高位取0,<<空位补0,>>正数补0,负数补1。

二、运算符的优先级 

        在Java中大多数的运算符也是从左向右结合的,其中,单目运算符、赋值运算符和三目运算符是从右向左结合的,也就是从右向左运算。运算符有不同的优先级,所谓优先级就是在表达式运算中的运算顺序。

 这里演示几种常见的使用:

public class Priority {
    public static void main(String[] args) {
        int x = 2;
        int y = 3;
        int z = 4;
        /*
        * 在这个表达式中,*的优先级要大于+,而()的优先级要高于*,与正常的数学运算中的计算顺序相同
        * 1)先计算(2+3)
        * 2)再计算5*4,结果为201
        * */
        System.out.println("结果为:" + (x+y)*z);

        /*
        * 1)优先计算自增,3*5
        * 2)然后再计算*,结果为15
        * */
        System.out.println("结果为:" + (++x * ++z));

        x = 2;
        z = 4;
        /*
        * 1)先计算自增,2 += 5;
        * 2)再计算赋值,2 = 2 + 5,结果为7
        * */
        System.out.println("结果为:" + (x += ++z));

    }
}

运行结果如下:

 

 注意:为了提高代码的可读性,尽量不要使用太过复杂的表达式。尽量使用()来控制计算顺序。