java学习笔记(10)_运算符

运算符

介绍

​ 运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

算术运算符

  1. 列表

    image-20230706103712038

  2. 演示

    public class ArithmeticOperator{
	public static void main(String[] args){
		// 运算符的使用
		System.out.println(10 / 4); // 2;
		System.out.println(10.0 / 4); // 2.5;
		// 取余的使用
		// 取余的公式: a - a / b * b;
		System.out.println(10 % 3);	// 1;
		System.out.println(-10 % 3); // -1;
		System.out.println(10 % -3); // 1;
		System.out.println(-10 % -3); // -1;
		// ++的使用
		
		int c1 = 10;
		c1++;
		++c1;
		System.out.println(c1);
		// 在++赋值时的情况
		// ++在前，先加1，然后赋值
		// ++在后，先赋值，然后在加1
		int c2 = 10;
		int c3 = c2++;
		System.out.println(c2+"-----"+c3); // 10----11;
		int c4 = 10;
		int c5 = ++c4;
		System.out.println(c4+"-----"+c5); // 11----11;
	}
}

赋值运算符

  1. 介绍

    赋值运算符就是将某个运算后的值，赋给指定的变量

  2. 分类

    1. 基本赋值运算符
      1. =
    2. 复合赋值运算符
      1. +=
      2. -=
      3. *=
      4. %=

  3. 特点

    1. 运算顺序从右往左 int num = a + b + c;
    2. 赋值运算符的左边 只能是变量，右边可以是变量、表达式、常量int num = 20;int num2 = 78 * 34 - 10; int num3 = a;
    3. 复合赋值运算符等价于下面的效果，比如：a+=3等价于a = a + 3
    4. 复合赋值运算符会进行类型转换

  4. 演示

    public class AssignOperator{
	public static void main(String[] args){
		int n1 = 10;
		n1 += 4; // 等价于 n1 = n1 + 4;
		System.out.println(n1);
		// 复合赋值运算符会进行类型转换
		byte n2 = 2;
		n2 += 1; // 等价于 n2 = (byte)n2 + 1;
		System.out.println(n2);
	}
}

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

  1. 介绍

    1. 关系运算符的结果都是boolean型，也就是要么是true，要么是false
    2. 关系表达式，经常用在if结构的条件中或循环结构的条件中

  2. 列表

    image-20230706145815213

  3. 细节

    1. 关系运算符的结果都是boolean型，也就是要么是true，要么是false
    2. 关系运算符组成的表达式，我们称为关系表达式。a > b
    3. 比较运算符==不能误写成=

逻辑运算符

  1. 介绍

    用于连接多个条件（多个关系表达式）,最终的结果也是一个boolean值

  2. 列表

    image-20230706150627598

  3. &&和&的基本原则

    1. 名称 语法 特点
      短路与&& 条件1&&条件2 两个条件都为true，结果为true，否则为false
      逻辑与& 条件1&条件2 两个条件都为true，结果为true，否则为false

    2. &&和&的区别

      1. &&短路与，当第一个条件成立时，才会去判断第二个条件
      2. &逻辑与，无论第一个条件成不成立，都回去判断第二个条件

    3. 在开发中，为了确保效率，我们经常使用短路与&&

    public class LogicOperator01{
	public static void main(String[] args){
		// &&和&的使用
		int a1 = 19;
		int a2 = 4;
		if(a1 < 40 && a2 > 1){
			System.out.println("Ok");
		}
		if(a1 < 40 & a2 > 1){
			System.out.println("Ok");
		}
		// &&和&的区别

		int a3 = 20;
		int a4 = 40;
		// && 短路与,当第一个条件不成立时，就不会再去判断第二个条件
		if(a3 > 20 && ++a4 < 50){
			System.out.println("ok");	
		}
		System.out.println("a3=" + a3 + "a4=" + a4); // a3=20a4=40
		// & 逻辑与，不管第一个条件成不成立，都会去判断第二个条件
		if(a3 > 20 & ++a4 < 50){
			System.out.println("ok");	
		}
		System.out.println("a3=" + a3 + "a4=" + a4); // a3=20a4=41

	}
}

  4. ||和|的基本原则

    1. 名称 语法 特点
      短路或&& 条件1||条件2 两个条件只要有一个条件成立，那么就为true，否则为false
      逻辑或& 条件1|条件2 两个条件只要有一个条件成立，那么就为true，否则为false

    2. ||和||的区别

      1. ||短路与，当第一个条件成立时，才会去判断第二个条件
      2. |逻辑与，无论第一个条件成不成立，都会去判断第二个条件

    3. 在开发中，为了确保效率，我们经常使用短路与||

    public class LogicOperator01{
	public static void main(String[] args){
		// ||和|的使用
		int a1 = 19;
		int a2 = 4;
		if(a1 < 40 || a2 > 1){
			System.out.println("Ok");
		}
		if(a1 < 40 | a2 > 1){
			System.out.println("Ok");
		}
		// ||和|的区别

		int a3 = 20;
		int a4 = 40;
		// || 短路或,当第一个条件成立时，就不会再去判断第二个条件
		if(a3 > 20 || ++a4 < 50){
			System.out.println("ok");	
		}
		System.out.println("a3=" + a3 + "a4=" + a4);
		// | 逻辑或，不管第一个条件成不成立，都会去判断第二个条件 
		if(a3 > 20 | ++a4 < 50){
			System.out.println("ok");	
		}
		System.out.println("a3=" + a3 + "a4=" + a4);

	}
}

位运算符(需要二进制基础)

  1. 按位与&

    两位全为1，结果为1，否则为0

  2. 按位或|

    两位有一个为1，结果为1，否则为0

  3. 按位异或^

    两位一个为0，一个位1，结果为1，否则为0

  4. 按位取反~

    0 ---> 1, 1---->0

  5. 算术右移>>

    低位溢出，符号位不变。并用符号位补溢出的高位

  6. 算术左移<<

    符号位不变，低位补0

  7. 无符号右移>>>

    低位溢出，高位补0

  8. 演示

    public class BitOperator{
	public static void main(String[] args){
		// 推导
		// 获取到2的补码 00000000 00000000 00000000 00000010
		// 获取到3的补码 00000000 00000000 00000000 00000011
		// 按位与& 两位全为1，结果为1，否则为0
		// 运算出来的补码 00000000 00000000 00000000 00000010
		// 运算结果看原码，由于最高位为0是正，那么原码就是补码 所以结果为2
		System.out.println(2&3); // 2
		// 推导
		// 获取到-2的原码 10000000 00000000 00000000 00000010
		// 负数的补码=它的反码+1，负数的反码 = 它的原码符号不变，其他位取反（0-> 1,1->0）
		// 获取到-2的反码 111111111 11111111 11111111 11111101
		// 获取到-2的补码 111111111 11111111 11111111 11111110
		// 按位取反~:0->1,1->0
		// 运算结果的补码 00000000 00000000 00000000 00000001
		// 由于这个补码是正数，所以补码就是原码，运算结果为 1
		System.out.println(~-2); // 1
		// 推导
		// 获取到2的原码 10000000 00000000 00000000 00000010
		// 负数的补码=它的反码+1，负数的反码 = 它的原码符号不变，其他位取反（0-> 1,1->0）
		// 按位取反~:0->1,1->0
		// 运算结果的补码 01111111 11111111 11111111 11111101
		// 获取到结果的反码 01111111 11111111 11111111 11111100
		// 获取到运算结果的原码 10000000 00000000 00000000 00000011
		// 所以运算结果为 -3
		System.out.println(~2); // -3
	}
}

三元运算符

  1. 基础语法

    条件表达式?表达式1:表达式2;

  2. 运算规则

    1. 如果条件表达式为true，运算后的结果是表达式1;
    2. 如果条件表达式为false，运算后的结果是表达式2;

  3. 细节

    1. 表达式1和表达式2要为可以赋值给接收变量的类型(或可以自动转换类型，或强制转换类型)
    2. 三元运算符可以转成if---else语句

  4. 演示

    public class TemaryOperatorDetail{
	public static void main(String[] args) {
		// 表达式1和表达式2要为可以赋给接收变量的类型（或可以自动转换）
		int a = 3;
		int b = 8;
		int c  = a > b ? 1.1 : 3.4; // 错误的
		double c  = a > b ? 1.1 : 3.4;  // 可以的
		System.out.println(c);
	}
}

运算符优先级

image-20230706175257254

原码、反码、补码

  1. 二进制的最高位是符号位：0表示正数，1表示负数（口诀:0->0 1-> -）
  2. 正数的原码、反码、补码都一样（三码合一）
  3. 负数的反码=它的原码符号位不变，其他位取反（0->1,1->0)
  4. 负数的补码=它的反码+1，负数的反码 = 负数的补码 - 1
  5. 0的反码，补码都是0
  6. java没有无符号数，换言之，java中的数都是有符号的
  7. 在计算机运算的时候，都是以补码的方式来运算的
  8. 当我们看运算结果的时候要看他的原码
posted @ 2023-07-07 17:48  xiaowei123456  阅读(2)  评论(0)    收藏  举报