运算符和表达式
运算符
对字面量或者变量进行操作的符号
表达式
用运算符把字面量或者变量连接起来，符合java语法的式子就可以称为表达式。
不同运算符连接的表达式体现的是不同类型的表达式
int a = 10;
int b = 20;
int c = a + b;
// +：是运算符，并且是算术运算符
// a + b：是表达式，因为 + 是算术运算符，所以这个表达式叫算术表达式
算术运算符
| 符号 | 作用 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取模、取余 |
public class ArithmeticoperatorDemo {
public static void main(String[] args) {
// +
System.out.println(2 + 3); // 5
// -
System.out.println(3 - 2); // 1
// *
System.out.println(2 * 3); // 6
// 代码中，如果有小数参与计算，结果可能并不精确
System.out.println(1.1 + 1.1); // 2.2
System.out.println(1.1 + 1.01); // 2.1100000000000003
// 整数参与计算，结果只能得到整数
// 小数参与计算，结果有可能并不精确
// 除法
System.out.println(10 / 2); // 5
System.out.println(10 / 3); // 3
System.out.println(10.0 / 3); // 3.3333333333333335
// 取模、取余。实际上也是除法运算，只不过的到得是余数而已
System.out.println(10 % 2); // 0
System.out.println(10 % 3); // 1
}
}
整数参与计算，结果只能得到整数
小数参与计算，结果有可能并不精确
取模、取余的应用场景
- 可以用取模来判断，A是否可以被B整除
A % B 10 % 3
- 可以判断A是否为偶数
A % 2 如果结果为0，那么证明A是一个偶数。如果结果为1，那么证明A是一个奇数
- 斗地主发牌
把每一张牌都定义一个序号
拿着序号 % 3。如果结果为1，就发给第一个玩家
如果结果为2，那么就发给第二个玩家
如果结果为0，那么就发给第三个玩家
数值拆分
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
公式总结：
个位：数值 % 10
十位：数值 / 10 % 10
百位：数值 / 100 % 10
前位：数值 / 1000 % 10
...
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入三位数");
int num = sc.nextInt();
int g = num % 10;
int s = num / 10 % 10;
int b = num / 100 % 10;
System.out.println(g);
System.out.println(s);
System.out.println(b);
}
}
数字相加
数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算
类型转换的分类
-
隐式转换
- 把一个取值范围小的数值，转成取值范围大的数据
-
强制转换
- 取值范围大的数值
- 取值范围小的数值
隐式转换的两种提升规则
取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算
byte short char 三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算
隐式转换小结
-
取值范围
- byte < short < int < long < float < double
-
什么时候转换
- 数据类型不一样，不能进行计算，需要转成一样的才可以进行计算
-
转换规则
- 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算
- byte short char 三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算
强制转换
- 如果把一个取值范围大的数值，赋值给取值范围小的变量，是不允许直接赋值的。如果一定要这么做就需要加入强制转换
- 格式：目标数据类型 变量名 = (目标数据类型)被强制的数据;
public class Test2 {
public static void main(String[] args) {
byte num1 = 10;
byte num2 = 10;
byte res1 = (byte)(num1 + num2);
System.out.println(res1); // 20
byte num3 = 100;
byte num4 = 100;
byte res2 = (byte)(num3 + num4);
System.out.println(res2); // -56 错误
}
}
"+" 操作的三种情况
-
数字相加
-
字符串相加
- 当 "+" 操作中出现字符串时，这个 "+" 是字符串连接符，而不是算术运算符。会将前后的数据进行拼接，并产生一个新的字符串
- 连续进行 "+" 操作时，从左到右逐个执行
-
字符相加
- byte short char 三种类型的数据在运算的时候，都会直接先提升为 int，然后再进行运算
- 当 字符 + 字符 / 字符 + 数字 时，会把字符通过 ASCII 码表查询到对应的数字再进行计算
A => 65
a => 97
自增自减运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 加 | 变量的值加1 |
| -- | 减 | 变量的值减1 |
注意事项： a ++ 和 -- 既可以放在变量的前边，也可以放在变量的后边
- 单独使用
- ++ 和 -- 无论是放在变量的前边还是后边，单独写一行结果都是一样的
- 参与计算
- i++ => 先用后加
- ++i => 先加后用
public class Test3 {
public static void main(String[] args) {
// ++ 和 --
int num = 10;
// 表示把变量 num 里面的值 +1
num++;
System.out.println(num); // 11
// 表示把变量 num 里面的值 +1
++num;
System.out.println(num); // 12
// 表示把变量 num 里面的值 -1
num--;
System.out.println(num); // 11
// 表示把变量 num 里面的值 -1
--num;
System.out.println(num); // 10
}
}
public class Test4 {
public static void main(String[] args) {
int num = 10;
// 后++：先用后加
// 先把 num 变量中的值拿出来用，赋值给 y，然后再进行自增
// 赋值给 y 的值是自增前的
int y = num++;
// 先++：先加后用
// 先把 num 进行自增，然后把自增后的结果赋值给左边的变量
// 先把 num 自增，变成 12，然后再把自增后的 12 赋值给 z
int z = ++num;
System.out.println("num:" + num); // 12
System.out.println("y:" + y); // 10
System.out.println("z:" + z); // 12
}
}
赋值运算符
分类
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | int num = 10; 将10赋值给变量 num |
| += | 加后赋值 | a += b; 将 a + b 的值给 a |
| -= | 减后赋值 | a -= b; 将 a - b 的值给 a |
| *= | 乘后赋值 | a *= b; 将 a * b 的值给 a |
| /= | 除后赋值 | a /= b; 将 a / b 的商给 a |
| %= | 取余后赋值 | a %= b; 将 a / b 的余数给 a |
注意：扩展的赋值运算符隐含了强制类型转换
public class Test5 {
public static void main(String[] args) {
// +=：将左边和右边进行相加，然后再把结果赋值给做百年
int a = 10;
int b = 20;
a += b;
// 等同于 a = (int)(a + b)
System.out.println(a); // 30
System.out.println(b); // 20
// 细节：+=、-=、*=、/=、%= 底层都隐藏了一个强制类型转换
short s = 1;
// 把左边和右边进行相加，得到结果2，再赋值给左边的变量
s += 1;
// 等同于：s = (short)(s + 1);
System.out.println(s); // 2
byte e = 1;
e += 160;
System.out.println(e); // -95 强制转换精度丢失
}
}
关系运算符
（关系运算符/比较运算符）的分类
| 符号 | 说明 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
| a>b，判断a是否大于b，成立为true，不成立为false | |
| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
| < | a<b，判断a是否小于b，成立为true，不成立为false |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
注意：关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把 "==" 误写成 “=”
练习：约会
需求：
您和您的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入 0～10 之间的整数，不能录其他）
如果你的时髦程度大于你对象的时髦程度，相亲就成功，输出true
否则输出false
import java.util.Scanner;
public class FashionTest {
public static void main(String[] args) {
// 1.键盘录入两个整数表示衣服的时髦度
Scanner sc = new Scanner(System.in);
System.out.println("请输入我们自己度衣服时髦度");
int myFashion = sc.nextInt();
System.out.println("请输入相亲对象衣服的时髦度");
int girlFashion = sc.nextInt();
// 2.把我衣服度时髦度跟女孩的时髦度进行对比就可以了
boolean result = myFashion > girlFashion;
// 3.打印结果
System.out.println(result);
}
}
逻辑运算符
什么是逻辑运算符？
在数学中，一个数据 x，大于 5，小于 15，可以表示为：5 < x < 15
在 Java 中，需要把上面的式子先进行拆解，再进行合并表示
拆解为：x > 5 和 x < 15
合并后：x > 5 & x < 15
分类
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与（且） | 并且，两边都为真，结果才是真 |
| | | 逻辑或 | 或者，两边都为假，结果才是假 |
| ^ | 逻辑异或 | 相同为false，不同为true |
| ! | 逻辑非 | 取反 |
public class logicDemo {
public static void main(String[] args) {
// 1.& 并且，两边都为真，结果才是真
// IDEA command/ctrl + D 复制换行
System.out.println(true & true); // true
System.out.println(false & false); // false
System.out.println(true & false); // false
System.out.println(false & true); // false
// 2.| 或者，两边都为假，结果才是假
System.out.println(true | true); // true
System.out.println(false | false); // false
System.out.println(true | false); // true
System.out.println(false | true); // true
// 3.^ 异或，相同为false，不同为true
System.out.println(true ^ true); // false
System.out.println(false ^ false); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
// 4.| 取反的感叹号不要写多次，要么不写，要么只写一次
System.out.println(!false); // true
System.out.println(!true); // false
}
}
短路逻辑运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 结果和&相同，但是有短路效果 |
| || | 短路或 | 结果和|相同，但是有短路效果 |
注意：
&、|，无论左边true false，右边都要执行
&&、||，如果左边能确定整个表达式的结果，右边不执行
&&：左边为false，右边不管是真是假，整个表达式的结果一定是false
||：左边为true，右边不管是真是假，整个表达式的结果一定是true
这两种情况下，右边不执行，提高了效率
最常用的逻辑运算符：&&、||、!
public class LogicDemo2 {
public static void main(String[] args) {
// 1.&& 运行结果跟单个 & 是一样的，表示两边都为真，结果才是真
System.out.println(true && true); // true
System.out.println(false && false); // false
System.out.println(false && true); // false
System.out.println(true && false); // false
// 2.|| 运行结果跟单个 | 是一样的，表示两边都为假，结果才是假
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println(false || true); // true
System.out.println(true || false); // true
// 3.短路逻辑运算符具有短路效果，当左边的表达式能确定最终的结果，那么右边就不会参与运行了
int a = 10;
int b = 10;
boolean result = ++a < 5 && ++b < 15;
System.out.println(result); // false
System.out.println(a); // 11
System.out.println(b); // 10
}
}
练习：数字6
需求：
数字 6 是一个伟大的数字，键盘录入两个整数
如果其中一个为 6，最终结果输出 true
如果它们的和为 6 的倍数，最终结果输出 true
其他情况都是 false
import java.util.Scanner;
public class Test6 {
public static void main(String[] args) {
// 1.键盘录入两个整数 变量a 变量b
// 2.a == 6、b == 6 、(a + b) % 6 == 0，满足任意条件输出 true
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数");
int a = sc.nextInt();
System.out.println("请输入第二个整数");
int b = sc.nextInt();
boolean result = a == 6 || b == 6 || (a + b) % 6 == 0;
System.out.println(result);
}
}
三元运算符
什么是三元运算符
需求：定义一个变量记录两个整数的较大值
作用：可以进行判断，根据判断的结果得到不同的内容
(三元运算符/三元表达式)格式
格式：关系表达式 ? 表达式1 : 表达式2;
范例：求两个数的较大值。把三元运算符的结果赋值给一个变量
计算规则：首先计算关系表达式的值，如果为 true，表达式1的值就是运算结果；如果为false，表达式2的值就是运算结果
public class Test7 {
public static void main(String[] args) {
// 使用三元运算符获取两个数的较大值
int num1 = 10;
int num2 = 20;
int max = num1 > num2 ? num1 : num2;
System.out.println(max);
}
}
练习：三元运算符练习
需求：一座寺庙里住着三个和尚，已知他们的身高分别为 150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高
public class Test8 {
public static void main(String[] args) {
int height1 = 150;
int height2 = 210;
int height3 = 165;
int temp = height1 > height2 ? height1 : height2;
int max = temp > height3 ? temp : height3;
// ctrl + alt + l 自动格式化代码
System.out.println(max);
}
}
运算符优先级
| 优先级 | 运算符 | ||
|---|---|---|---|
| 1 | . () {} | ||
| 2 | ! - ++ -- | ||
| 3 | * / % | ||
| 4 | + - | ||
| 5 | << >> >>> | ||
| 6 | < <= > >= instanceof | ||
| 7 | == != | ||
| 8 | & | ||
| 9 | |||
| 10 | |||
| 11 | && | ||
| 12 | |||
| 13 | ?: | ||
| 14 | = += -= *= /= %= &= |
