lesson4 - Java运算符

Codefengfeng

已于 2024-05-15 19:36:50 修改

阅读量669

点赞数 24

分类专栏： Java学习路线文章标签： java 开发语言

于 2024-05-14 23:06:36 首次发布

本文链接：https://blog.csdn.net/Codefengfeng/article/details/138873358

版权

Java学习路线专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

1. 算术运算符
2.进制、补码与位运算符
3. 关系运算符
4. 逻辑运算符

运算符是一种表示数据的计算、赋值和比较的符号

1. 算术运算符

知识点概述：
算术运算符是对数值型变量进行运算的符号。
在这里插入图片描述

（常用的算数运算符）

在上面的运算符中，需要重点掌握 /, % , ++ 。
1. 使用 / 时要注意是否有浮点数参与运算
2. 使用 % 时，要清楚 %的本质。在Java中， a%b的本质是a-a/b*b
3. 使用 ++(–)时，要看++是单独使用还是作为表达式使用。
单独使用 ++ 符号时，无论++在前还是在后都等价于i = i + 1
作为表达式使用 ++ 符号时，前++时变量先自增后赋值，后++时变量先赋值后自增。

代码验证：

// 1.除号/的使用
int num1 = 10 / 4;         // 2
double num2 = 10.0 / 4;    // 2.5
double num3 = 10 / 4;      // 2.0

// 2.取余%的使用  
int num4 = 10 % 3;         // 1
int num5 = -10 % 3 ;       // -1
int num6 = 10 % -3 ;       // 1 , a%b的本质是a-a/b*b 

// 3. ++ 的使用
// 3.1 单独使用
int i = 10;
i++ ;                      // 此时i为11
++i ;                      // 此时i为12，
// 3.2 作为表达式使用
int j = ++i ;
System.out.println(i);
System.out.println(j);     // i=13,j=13
int k = i++;
System.out.println(i);
System.out.println(k);     // i=14,k=13

课堂练习：

// ++面试题1
		int i = 1;
        i = i++;
        System.out.println(i);  //使用临时变量，先赋值temp = i , 再自增i = i + 1 , 最后换回来 i = temp

        // ++面试题2
        int j = 1;
        j = ++j; 
        System.out.println("=========="); 
        System.out.println(j);  //使用临时变量，先自增 j = j + 1 , 再赋值 temp = j , 最后换回来 j = temp  

        // ++面试题3 
        int k1 = 10 ;
        int k2 = 20 ;
        int k = k1++ ;
        System.out.println("=========="); 
        System.out.println(k); 
        System.out.println(k1); 
        System.out.println(k2);             // i=10, i1=11, i2=20
        k = --k2;
        System.out.println("=========="); 
        System.out.println(k); 
        System.out.println(k1); 
        System.out.println(k2);             // i=19, i1=11, i2=19

        //课堂练习：假如还有59天放假，这是几个星期零几天？
        int days = 59 ;
        int weeks = 59 / 7;
        int left_days = 59 % 7;
        System.out.println("=========="); 
        System.out.println(weeks); 
        System.out.println(left_days);

        //课堂练习： 华氏温度转摄氏温度。 转换公式为摄氏温度= 5/9*(华氏温度-100)
        double huashi = 1234.6 ;
        double sheshi = 5.0 / 9 * (huashi - 100) ;
        System.out.println("=========="); 
        System.out.println(sheshi);

2.进制、补码与位运算符

进制概述：
1. 二进制。0和1，满2进1，以0b或0B开头；
2. 十进制。0-9，满10进1；
3. 八进制。0-7，满8进1，以数字0开头；
4. 十六进制。0-9和A-F，满16进1，以0x或0X开头，A-F代表10-15，不区分大小写。
代码1验证：

// 各进制演示
int n1 = 0b1010;  // 二进制
int n2 = 1010;    // 十进制
int n3 = 01010;   // 八进制
int n4 = 0x1010;  // 十六进制
System.out.println(n1+" "+n2+" "+n3+" "+n4);

原码、反码、补码概述：
1. 二进制的最高位是符号位，0表示正数，1表示负数；
2. 正数的原码、反码和补码都一样；
3. 负数的原码、反码和补码间的转换关系如下图（注意只能负数这样用，正数不行）；
在这里插入图片描述

（负数的原码、反码、补码转换关系）

4. 0的反码和补码都是0；
5. Java没有无符号数，也即是所有数都是带符号位的；
6. 计算机在进行位运算时以补码来进行；看结果时看的是原码

位运算符概述：
1. Java中有7个位运算符&、| 、 ^ 、 ~ 、 >> 、<< 、>>>
2. 按位与&。两位全为1则结果为1；
3. 按位或 | 。两位有一个为1则结果为1；
4. 按位异或^。两位不相同则结果为1；
5. 按位取反~。0->1, 1->0；
6. 算数右移>> 。低位溢出（溢出的意思就是丢掉），符号位不变，用符号位补空缺的高位。右移的效果是数字的值除以2，每移1个单位就除以2;
7. 算数左移<< 。高位溢出，符号位不变，用0补空缺的低位。右移的效果是数字的值除以2，每移1个单位就除以2;
8. 无符号右移>>>。低位溢出，高位补0 ;
代码验证：

   
	// 1.. 位运算符& | ^ ~
	int num1 = 2 & 3;
	// 上面的运算过程为： 
	// 1.写补码
	//   2的原码： 00000000 00000000 00000000 00000010
	//   2的补码： 00000000 00000000 00000000 00000010
	//   3的原码： 00000000 00000000 00000000 00000011
	//   3的补码： 00000000 00000000 00000000 00000011
	// 2. 按位与&
	//   2和3的补码进行按位与的结果为：00000000 00000000 00000000 00000010
	// 3. 补码转原码
	//   由于符号位为，正数，原码与补码相同，因此结果的原码为：00000000 00000000 00000000 00000010
	//   翻译成10进制，就是+2
	int num2 = ~-2;
	// 上面的运算过程为： 
	// 1.写补码
	//   -2的原码： 10000000 00000000 00000000 00000010
	//	 -2的反码： 11111111 11111111 11111111 11111101
	//   -2的补码： 11111111 11111111 11111111 11111110
	// 2. 按位取反~
	//   结果为：   00000000 00000000 00000000 00000001
	// 3. 补码转原码
	//   由于符号位为0，是正数，原码与补码相同，为00000000 00000000 00000000 00000001，翻译成十进制就是+1
	int num3 = ~2;
	// 上面的运算过程为： 
	// 1.写补码
	//   2的原码： 00000000 00000000 00000000 00000010
	//   2的补码： 00000000 00000000 00000000 00000010
	// 2. 按位取反~
	//   结果为：  11111111 11111111 11111111 11111101
	// 3. 补码转原码
	//   由于符号位为1，是负数
	//   先补码转反码 ，直接减1即可，结果为        11111111 11111111 11111111 11111100
	//   随后转原码，符号位不动，其他位取反，结果为 10000000 00000000 00000000 00000011 ，翻译成十进制就是-3
	int num4 = 2 | 3;
	int num5 = 2 ^ 3;
	System.out.println(num1+" "+num2+" "+num3+" "+num4+" "+num5);


	// 2.. 位运算符<< >> >>>
	int a = 1 >> 2;
	int b = -1 >> 2;
	//  上面的运算过程为：
	//  1.写补码
	//   -1的原码： 10000000 00000000 00000000 00000001
	//	 -1的反码： 11111111 11111111 11111111 11111110
	//   -1的补码： 11111111 11111111 11111111 11111111
	//  2. 右移>>两位
	//	  右移两位后的补码为：1_ _11111 11111111 11111111 11111111
	//    _ _处表示空出来两位，于是用符号位填充，得到补码为: 11111111 11111111 11111111 11111111
	//  3. 补码转原码
	//   由于符号位为1，是负数
	//   先补码转反码 ，直接减1即可，结果为        11111111 11111111 11111111 11111110
	//   随后转原码，符号位不动，其他位取反，结果为 10000000 00000000 00000000 00000001 ，翻译成十进制就是-1	
	int c = 1 << 2;
	int d = -1 << 2;
	int e = 3 >>> 2;
	System.out.println(a+" "+b+" "+c+" "+d+" "+e);

3. 关系运算符

功能概述：
关系运算符的运算结果都是boolean型，要么为true，要么为false
关系运算符组成的式子称为关系表达式
常见的关系运算符使用方法如下表：
在这里插入图片描述
代码验证：

int a = 9;
int b = 8;
boolean c = "lxf" instanceof String;
System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);
System.out.println(a == b);
System.out.println(a != b);
System.out.println(c);

4. 逻辑运算符

知识点概述：
1.逻辑运算符用于连接多个关系表达式，运算结果也是一个逻辑值true或false。
2.分两组，短路与&& 短路或||
逻辑与& 逻辑或| 逻辑非! 逻辑异或^
在这里插入图片描述

（各逻辑运算符示意）

1. 短路与&&、逻辑与&。当a，b同时为true时，结果为true
2. 短路或||、逻辑或|。当a, b有一个为true时，结果为true
3. 逻辑非！。当原操作数为true时，结果为false；当原操作数为false时，结果为true。
4. 逻辑异或^。当a与b的逻辑值不同时，结果为true。
使用细节：
1. 短路与&&、逻辑与&的区别。短路与&&在执行时，若第一个条件表达式为false，则第二个条件直接不判断返回false结果；而逻辑与&在执行时对两个条件表示式都会判断；开发时基本用短路与&&，这样执行效率高；
2. 短路或||、逻辑或|的区别。短路或||在执行时，若第一个条件表达式为true，则第二个条件直接不判断返回true结果；而逻辑或|在执行时对两个条件表示式都会判断；开发时基本用短路或||，这样执行效率高；
代码验证：

// 1. 短路与&& 逻辑与&  
		// 相同之处
		int  age = 50 ;
		if(age > 20 && age < 90){
			System.out.println("ok100");      // 可输出ok100
		}
		if(age > 20 & age < 90){
			System.out.println("ok200");      //  可输出ok200
		}
		// 不同之处
		int a = 4; int b = 9;
		if(a < 1 && ++b < 90){
			System.out.println("ok400");      
		}
		System.out.println("a="+a+"b="+b);     // 输出a=4 , b=9
		if(a < 1 & ++b < 90){
			System.out.println("ok300");      
		}
		System.out.println("a="+a+"b="+b);     // 输出a=4 , b=10


		// 2. 短路或|| 逻辑或|  
		// 相同之处
		int  age = 50 ;
		if(age > 20 || age < 30){
			System.out.println("ok100");      // 可输出ok100
		}
		if(age > 20 | age < 30){
			System.out.println("ok200");      //  可输出ok200
		}
		// 不同之处
		int a = 4; int b = 9;
		if(a > 1 || ++b < 90){
			System.out.println("ok300");      
		}
		System.out.println("a="+a+"b="+b);     // 输出a=4 , b=9
		if(a > 1 | ++b < 90){
			System.out.println("ok400");      
		}
		System.out.println("a="+a+"b="+b);     // 输出a=4 , b=10

		// 3. 逻辑非!
		boolean b = (60>20);
		System.out.println(b);                  // 输出true 
		System.out.println(!b);                 // 输出false

		// 4. 逻辑异或^
		boolean c = (10>1)^(3<5);
		boolean d = (10>1)^(3>5);
		System.out.println(c);                  // 输出flase
		System.out.println(d);                 // 输出true

课堂练习：

// practice 1
        int x = 5 ; int y = 5;
        if(x++ == 6 & ++y == 6){
            x = 11;
        }
        System.out.println("x=" +x + "y=" +y);   // 输出x=6,y=6 

        // practice 2
        int x = 5 ; int y = 5;
        if(x++ == 6 && ++y == 6){
            x = 11;
        }
        System.out.println("x=" +x + "y=" +y);   // 输出x=6,y=5

        // practice 3
        int x = 5 ; int y = 5;
        if(x++ == 5 | ++y == 5){
            x = 11;
        }
        System.out.println("x=" +x + "y=" +y);   // 输出x=11,y=6

        // practice 4
        int x = 5 ; int y = 5;
        if(x++ == 5 || ++y == 5){
            x = 11;
        }
        System.out.println("x=" +x + "y=" +y);   // 输出x=11,y=5

        // practice 5
        boolean x = true;
        boolean y = false;
        short z = 46;
        if((z++==46)&&(y=true)) z++;
        if((x=false)||(++z==49)) z++;
        System.out.println(z);                    // 输出50