运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
1. 算术运算符
- 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
- 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
- “+”除字符串相加功能外，还能把非字符串转换成字符串。
/*
* 运算符之一：算术运算符
* + - + - * / % (前)++ (后)++ (前)-- (后)--
*/
public class AriTest {
public static void main(String[] args) {
// 除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);// 2
int result2 = num1 / num2 * num2;
System.out.println(result2);// 10
double result3 = num1 / num2;
System.out.println(result3);// 2.0
double result4 = num1 / num2 + 0.0;
double result5 = num1 / (num2 + 0.0);
double result6 = (double) num1 / num2;
double result7 = (double) (num1 / num2);
System.out.println(result4);// 2.0
System.out.println(result5);// 2.4
System.out.println(result6);// 2.4
System.out.println(result7);// 2.0
// %：取余运算
// 结果的符号与被模数的符号相同
// 开发中，经常使用%来判断能否被除尽的情况
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);// m1 % n1 = 2
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);// m2 % n2 = -2
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);// m3 % n3 = 2
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);// m4 % n4 = -2
// (前)++：先自增1，后运算
// (后)++：先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);// a1 = 11,b1 = 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);// a2 = 11,b2 = 10
int a3 = 10;
++a3;// a3++
int b3 = a3;
// 注意点：
short s1 = 10;
// s1 = s1 + 1;//编译失败
// s1 = (short)(s1 + 1);//正确的
s1++;// 自增1不会改变本身变量的数据类型
System.out.println(s1);// 11
// 问题：
byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);// bb1 = -128
// (前)--：先自减1，后运算
// (后)--：先运算，后自减1
int a4 = 10;
int b4 = --a4;
System.out.println("a4 = " + a4 + ",b4 = " + b4);// a4 = 9,b4 = 9
int b5 = a4--;
System.out.println("a4 = " + a4 + ",b5 = " + b4);// a4 = 8,b5 = 9
}
}
2. 赋值运算符
- 符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值。 - 扩展赋值运算符： +=, -=, *=, /=, %=
/*
* 运算符之二：赋值运算符
* = += -= *= /= %=
*/
public class SetValueTest {
public static void main(String[] args) {
// 赋值符号：=
int i1 = 10;
int j1 = 10;
int i2, j2;
// 连续赋值
i2 = j2 = 10;
int i3 = 10, j3 = 20;
// ------------------
int num1 = 10;
num1 += 2;// num1 = num1 + 2;
System.out.println(num1);// 12
int num2 = 12;
num2 %= 5;// num2 = num2 % 5;
System.out.println(num2);// 2
short s1 = 10;
// s1 = s1 + 2;//编译失败
s1 += 2;// 结论：不会改变变量本身的数据类型
System.out.println(s1);//12
// 开发中，如何希望变量实现+2的操作，有几种方法？（前提：int num = 10;）
// 方式一：num = num + 2;
// 方式二：num += 2;（推荐）
// 开发中，如何希望变量实现+1的操作，有几种方法？（前提：int num = 10;）
// 方式一：num = num + 1;
// 方式二：num += 1;
// 方式三：num++;（推荐）
}
}
3. 比较(关系)运算符
- 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
- 比较运算符“==”不能误写成“=” 。
/*
* 运算符之三：比较运算符
* == != > < >= <= instanceof
*
* 结论：
* 1.比较运算符的结果是boolean类型
* 2.区分 == 和 =
*/
public class CompareTest {
public static void main(String[] args) {
int i = 10;
int j = 20;
System.out.println(i == j);// false
System.out.println(i = j);// 20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);// false
System.out.println(b2 = b1);// true
}
}
4. 逻辑运算符
①& 逻辑与 ②| 逻辑或 ③! 逻辑非 ④&& 短路与 ⑤|| 短路或 ⑥^ 逻辑异或
- 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
- “&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。 - “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
- 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
/*
* 运算符之四：逻辑运算符
* & && | || ! ^
*
* 说明：
* 1.逻辑运算符操作的都是boolean类型的变量
*/
public class LogicTest {
public static void main(String[] args) {
// 区分：& 与 &&
// 相同点1：& 与 && 的运算结果相同
// 相同点2：当符号左边是true时，二者都会执行符号右边的运算
// 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
// 开发中，推荐使用&&
boolean b1 = true;
b1 = false;
int num1 = 10;
if (b1 & (num1++ > 0)) {
System.out.println("我现在在北京");
} else {
System.out.println("我现在在南京");
}
System.out.println(num1);
boolean b2 = true;
b2 = false;
int num2 = 10;
if (b2 && (num2++ > 0)) {
System.out.println("我现在在北京");
} else {
System.out.println("我现在在南京");
}
System.out.println(num2);
// 区分：| 与 ||
// 相同点1：| 与 || 的运算结果相同
// 相同点2：当符号左边是false时，二者都会执行符号右边的运算
// 不同点：当符号左右是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
// 开发中，推荐使用 ||
boolean b3 = false;
b3 = true;
int num3 = 10;
if (b3 | (num3++ > 0)) {
System.out.println("我现在在北京");
} else {
System.out.println("我现在在南京");
}
System.out.println(num3);
boolean b4 = false;
b4 = true;
int num4 = 10;
if (b4 || (num4++ > 0)) {
System.out.println("我现在在北京");
} else {
System.out.println("我现在在南京");
}
System.out.println(num4);
}
}
我现在在南京
11
我现在在南京
10
我现在在北京
11
我现在在北京
10
5. 位运算符
- 位运算是直接对整数的二进制进行的运算
- 注意：无<<<
6. 三元运算符
- (条件表达式)?表达式1：表达式2；
①条件表达式为true，运算后的结果是表达式1；
②条件表达式为false，运算后的结果是表达式2； - 表达式1和表达式2为同种类型
- 三元运算符与if-else的联系与区别：
①三元运算符可简化if-else语句
②三元运算符要求必须返回一个结果。
③if后的代码块可有多个语句
/*
* 运算符之六：三元运算符
* 1.结构：(条件表达式) ? 表达式1 : 表达式2
* 2.说明
* ①条件表达式的结果为boolean类型
* ②根据条件表达式真或假，决定执行表达式1，还是表达式2
* 如果表达式为true，则执行表达式1。
* 如果表达式为false，则执行表达式2。
* ③表达式1和表达式2要求是一致的。
* ④三元运算符可以嵌套使用。
* 3.凡是可以使用三元运算符的地方，都可以改写为if-else
* 反之，不成立。
* 4.如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁，执行效率高。
*/
public class SanYuanTest {
public static void main(String[] args) {
// 获取两个整数的较大值
int m = 12;
int n = 5;
int max = (m > n) ? m : n;
System.out.println(max);// 12
double num = (m > n) ? 2 : 1.0;
System.out.println(num);// 2.0
// --------------------------
n = 12;
String maxStr = (m > n) ? "m大" : ((m == n) ? "m和n相等" : "n大");
System.out.println(maxStr);
// --------------------------
// 获取三个数的最大值
int n1 = 12;
int n2 = 30;
int n3 = -43;
int max1 = (n1 > n2) ? n1 : n2;
int max2 = (max1 > n3) ? max1 : n3;
System.out.println("三个数中的最大值为：" + max2);
// 改写成if-else
if (m > n) {
System.out.println(m);
} else {
System.out.println(n);
}
}
}
7. 运算符的优先级
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
- 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
扫一扫
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
