运算符的运用

运算符

基本算术运算符

先从最基本的算术运算符开始学习，算术运算符有 + - * / % ，其中 * 表示乘法， / 表示除法， % 表示取余数

需要我们注意以下几点

/: 两个整数相除，结果也是一个整数
%: 表示两个数相除，取余数

需要我们注意的是： + 符号除了用于加法运算，还可以作为连接符。 + 符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串。

public class OperatorDemo1 {
public static void main(String[] args) {
// 目标：掌握基本的算术运算符的使用。
int a = 10;
int b = 2;
System.out.println(a + b); // 12
System.out.println(a - b); // 8
System.out.println(a * b); // 20
System.out.println(a / b); // 5 整数 / 整数 = 整数
System.out.println(5 / 2); // 2
System.out.println(5.0 / 2); // 2.5
int i = 5;
int j = 2;
System.out.println(1.0 * i / j); // 2.5
System.out.println(a % b); // 0
System.out.println(3 % 2); // 1
System.out.println("---------------------------------------");
// 目标2：掌握使用+符号做连接符的情况。
int a2 = 5;
System.out.println("abc" + a2); // abc5
System.out.println(a2 + 5); // 10
System.out.println("kaifamiao" + a2 + 'a'); //kaifamiao5a
System.out.println(a2 + 'a' + "kaifamiao"); //5akaifamiao 102kaifamiao
}
}

自增自减运算符

接下来，学习一种比较常用的运算符： ++ 和 –

++ 读作自增， – 读作自减； 运算规则如下

需要我们注意的是，自增自减只能对变量进行操作，不能操作字面量。具体使用时也分为两种情况，如下:

1.单独使用：++或者--放在变量前面没有区别
int a = 10;
a++; // 1
--a; // 10
System.out.println(a); // 10
2.混合使用：++或者--放在变量或者前面运算规则稍有不通过 ++ 在后 先赋值 再自
增 ++ 在前 先自增再赋值
int a = 10;
int b = a++;
int c = ++a;
System.out.println(a); // 12
System.out.println(b); // 10
System.out.println(c); // 12
int x = 10;
int y = --x;
x = 9 y = 9

下面通过代码演示一下 ++ 和 – 的用法

public class OperatorDemo2 {
public static void main(String[] args) {
// 目标：掌握自增自减运算符的使用。
int a = 10;
++a;
System.out.println(a); // 11
--a;
System.out.println(a); // 10
System.out.println("--------------------------------------");
int i = 10;
int rs = ++i;
System.out.println(rs); // 11
System.out.println(i); // 11
int j = 10;
int rs2 = j++;
System.out.println(rs2); // 10
System.out.println(j); // 11
int num1 = 2;
int num2 = 3;
int num3 = ++num1; // num3 = 3 num1 = 3
System.out.println(++num1 + num2++ + num3); // 10 num1 = 4 num2 = 4 num3 = 3
System.out.println(--num1 + num2-- + --num3);// 9 num1 = 3 num2 = 3 num3 = 2
System.out.println(num1-- + num2-- + --num3);// 7 num1 = 2 num2 = 2 num3 = 1
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
	}
}

赋值运算符

接下来，我们学习赋值运算符。基本的赋值运算符其实就是 = 号，意思就是把右边的数据赋值给左边的变量。

int a = 10; // 将数据10赋值给左边的变量a

除了基本的赋值运算符，我们这里主要学习一下扩展的赋值运算符。有 += -= *= /= %=

以 += 为例来看一下它的运算规则，其他的运算符运算同理分析即可

int a = 10;
a += 5; // a = a + 5;
System.out.println(a); // 15

下面通过一个首发红包的例子给大家演示一下

public class OperatorDemo3 {
	public static void main(String[] args) {
	// 目标：掌握扩展赋值运算符的使用。
	// +=
		double a = 9.5;
		int b = 520;
		a += b; // a = (double)(a + b);
		System.out.println(a); // 529.5
		// -= 需求：发红包
		double i = 600;
		double j = 520;
		i -= j; // i = (double)(i - j);
		System.out.println(i); // 80
		int m = 10;
		int n = 5;
		// m *= n; // 等价形式： m = (int)(m * n)
		// m /= n; // 等价形式： m = (int)(m / n)
		m %= n; // 等价形式： m = (int)(m % n)
		System.out.println(m); // 0
	}
}

扩展赋值运算符的面试题:

问题1：下面的代码否有问题？
	byte x = 10;
	byte y = 30;
	(byte)x = (int)(x + y); // byte char short 转换成int类型进行计算
	System.out.println(x); // 报错
问题2：下面的代码是否有问题？
	byte x = 10;
	byte y = 30;
	// x+=3;
	x += y; // x = (byte) (x + y);//会强制类型转化
	System.out.println(x); // 40

总结：

1.基本赋值运算符：
	=符号含义： 把右边的值赋值给左边的变量
2.扩展赋值运算符：
	+= -= *= /= %=符号含义：将右边的数据和左边的变量相加、相减、相乘、相除、取余数后，将结果重新赋值给左边的变量。
	int j = 2;
	int i = 1;
	// i = j ++; // i = 2 j = 3
	i = ++ j; // j = 3 i = 3
	int b = 2;
	b = b++;
	System.out.println(b); // 2
	int b = 2;
	b = ++b;
	System.out.println(b); // 3

关系运算符

关系运算符（也叫比较运算符）。

下图是每一种关系运算符的符号及作用，每一个关系运算符的结果都是boolean值(true、false)。

下面通过代码来家演示一下，各种关系运算符的效果

public class OperatorDemo4 {
    public static void main(String[] args) {
	// 目标：掌握关系运算符的基本使用。
		int a = 10;
		int b = 5;
		boolean rs = a > b;
		System.out.println(rs); // true
		System.out.println(a >= b); // true
		System.out.println(2 >= 2); // true
		System.out.println(a < b); // false
		System.out.println(a <= b); // false
		System.out.println(2 <= 2); // true
		System.out.println(a == b); // false
		System.out.println(5 == 5); // true
		// 注意了：判断是否相等一定是用 == ，=是用来赋值的。
		System.out.println(a = b); // 5 报错
		System.out.println(a != b); // true
		System.out.println(10 != 10); // false
	}
}

关系运算符在程序中常用于条件判断，根据条件判断的结果是true还是false，来决定后续该执行哪些操作。

逻辑运算符

逻辑运算符是用来将多个条件放在一起运算，最终结果是true或者false

下面我们通过几个案例来演示一下逻辑运算符的使用:

// 需求1：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.
// 需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.
boolean size>=6.95&&rongl>=8;
boolean size>=6.95||rongl>=8;

案例：键盘输入一个年份，判断是否是闰年

import java.util.Scanner;
public class IsHeap{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();
        //能被4整除但不能被100整除且能被400整除
        //boolean res=year%4==0&&year%100!=0||year%400==0;
        boolean a = year % 4 == 0;
		boolean b = year % 100 != 0;
		boolean c = year % 400 == 0;
		boolean res = a && b || c;
        System.out.println("这个年份是否是闰年呢？"+res);
    }
}

练习：键盘输入一个数字，判断是否是奇数

public class Shu{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int odd=sc.nextInt();
        boolean res=odd%2!=0;
        System.out.println("你输入的"+odd+"是否是奇数呢？"+res);
    }
}

位运算符

在计算机内部，数据以二进制位（0和1）的形式存储和处理。计算机通过将数据转换为二进制形式，将其存储在内存中，并对其进行操作和计算。不同的数据类型在内存中占据不同长度的二进制位，以便正确地表示和处理数据。

1. 原码

原码是一种最简单的机器数表示法，其中最高位表示符号位，其余位表示该数的二进制的绝对值。

2. 反码

正数的反码与原码相同，而负数的反码是其原码除符号位外，按位取反的结果。

3. 补码

正数的补码等于其原码，而负数的补码等于其反码加1。

1. 计算5&6的结果 4
2. 计算5|6的结果 7
3. 计算3<<2的结果 12
4. 计算16>>2的结果 4
5. 计算-12 | 2的结果 -10

1.计算5&6的结果
00…0101
00…0110

00…0100

2.计算5|6的结果

00…0101
00…0110

00…0111

3.计算3<<2的结果

00…0011(左移两位)

00…1100

4.计算16>>2的结果

00…10000(右移两位)

00…0100

5.计算-12 | 2的结果

10000…1100 原码（-12）

11111…0011 反码（-12）

11111…0100 补码（-12）

00000…0010 原码（2）

11111…0110 补码

11111…0101 反码（补码-1）

10000…1010 原码

三元运算符

三元运算符的格式：

数据类型 变量名 = 关系表达式 ? 值1 : 值2;

三元运算的执行流程：首先计算关系表达式的值，如果关系表达式的值为true，则返回值1；如果关系表达式的值为false, 则返回值2；

如下图所示：判断学生的成绩是否>=60，如果为true，就考试通过；如果为false，就成绩不合格。

接下来通过代码来演示一下

public class OperatorDemo6 {
	public static void main(String[] args) {
	// 目标：掌握三元运算符的基本使用。
		double score = 58.5;
		String rs = score >= 60 ? "成绩及格" : "成绩不及格";
		System.out.println(rs);
	// 需求2：找出2个整数中的较大值，并输出。
		int a = 99;
		int b = 69;
		int max = a > b ? a : b;
		System.out.println(max);
	// 需求3：找3个整数中的较大值。
		int i = 10;
		int j = 45;
		int k = 34;
	// 找出2个整数中的较大值。
		int temp = i > j ? i : j;
	// 找出temp与k中的较大值。
		int max2 = temp > k ? temp : k;
		System.out.println(max2);
	}
}

运算优先级

最后介绍一下运算符的优先级，如果你想要知道各个运算符的优先级，哪些先算哪些后算，可以参考下面这张图

优先级	运算符	结合性
1	()、[]	从左向右
2	!、~、++、–	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	<<、>>、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、%=、&=、|=、^=、~=、<<=、>>=、>>>=	从右向左

从图中我们发现，&&运算比||运算的优先级高，所以&&和||同时存在时，是先算&&再算||；

比如下面的代码

// 这里&&先算 相当于 true || false 结果为true
System.out.println(10 > 3 || 10 > 3 && 10 < 3); // true

最后给大家说一下，在实际开发中，其实我们很少考虑运算优先级， 因为如果你想让某些数据先运算，其实加 () 就可以了，这样阅读性更高

//有括号先算 相当于 true && false 结果为false
System.out.println((10 > 3 || 10 > 3) && 10 < 3); //false

14 | =、+=、-=、*=、/=、%=、&=、|=、^=、~=、<<=、>>=、>>>= | 从右向左 |

从图中我们发现，&&运算比||运算的优先级高，所以&&和||同时存在时，是先算&&再算||；

比如下面的代码

// 这里&&先算 相当于 true || false 结果为true
System.out.println(10 > 3 || 10 > 3 && 10 < 3); // true

最后给大家说一下，在实际开发中，其实我们很少考虑运算优先级， 因为如果你想让某些数据先运算，其实加 () 就可以了，这样阅读性更高

//有括号先算 相当于 true && false 结果为false
System.out.println((10 > 3 || 10 > 3) && 10 < 3); //false