Day02 Java学习笔记之《运算符》

---

1. 类型转换

在Java中，类型转换分为隐式（自动）类型转换和强制类型转换

1.1隐式类型转换

把一个表示数据范围小的常量或者变量赋值给另一个表示数据范围大的变量。不需要我们做任何操作，这叫做隐式转换

double num = 3;  // 将int型整数3赋值给double类型的变量num
System.out.println(sum);  // 输出3.0

数据类型从小到大的关系

若需清楚了解各个数据类型占的字节数及其最大或最小的表示范围，请点我

注意：整数默认为int类型，但是byte、short和char类型参与运算结果均会自动转换为int类型

byte a1 = 10;  // 不报错
byte a2 = 20;  // 不报错
byte a = 128;  // 报错
byte a3 = a1 + a2;  // 报错

1. 我们刚刚说了将一个表示数据范围小的常量或者变量，赋值给另一个表示数据范围大的变量才会发生隐式类型转换，又说了在Java中所有的整数都是int类型，那为什么将10赋值给byte类型的a1不会报错呢？？？

• 因为常量优化机制：在编译时，整数常量的计算会得出结果，并且会自动判断该结果是否在byte取值范围内。隐含了强制类型转换。在：通过编译。不在：编译失败。byte类型的数据占一个字节，表示的范围在 -128~127 之间

2. 为什么最后一行代码报错了呢？

• 因为我们说过byte、short和char类型的变量参与运算结果均会自动转换为int类型，在这里a1和a2都是byte类型的变量，所以最终的相加运算后得到的结果为int类型，将int类型赋值给byte类型就会报错了。

解决方案

int num1 = a1 + a2;  // 直接赋值给int类型的变量
byte num2 = (byte)(a1+a2);  // 使用强制类型转换

注意：！！ 一定得写的 (byte)(a1 + a2)，将运算后的结果转为byte类型。如果写成 (byte)a1 + a2仍报错

我上面特意强调了是变量，而不是常量，那两个常量参与运算能够直接赋值给byte类型的变量吗？

byte a = 3;
byte b = 4;
byte c = a + b;  // 错误。因为两个byte变量相加，最终的结果为int类型
byte d = 3 + 4;  // 正确。因为常量优化机制
byte e = a + 3;  // 错误。有byte类型的变量参与了运算，最终结果为int类型

1.2 强制类型转换

把一个表示数据范围大的常量或者变量赋值给另一个表示数据范围小的变量。

强制类型转换格式：数据类型 变量名 = (数据类型)常量或者变量;

double pi = 3.14;
int num = (int)pi;  // 将double类型的变量pi强制转换为int类型
System.out.println(num);  // 输出3（小数位不管是多少直接舍弃）

2. 算术运算符和表达式

1. 运算符：对常量或者变量进行操作的符号
2. 表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。

符号	作用	示例
+	加	1 + 1
-	减	2 - 1
*	乘	1 * 1
/	除	5 / 2
%	取余	4%2

注意：

1. /和%的区别：两个数据做运算，/得到的是商，%得到的是余数。
2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

System.out.println(5 / 2);  // 输出结果2
System.out.println(5 / 2.0);  // 输出结果2.5
System.out.println(5 % 2);  // 输出结果1

2.1 字符的 “+” 操作

在计算机中实际存储的并不是字符，而是字符所对应的ASCII码，ASCIII码表。我们一定要记住的只有3个。

1. 字符’a’对应的十进制ASCII码为97
2. 字符’A’对应的十进制ASCII码为65
3. 字符’0’对应的十进制ASCII码为48

根据上述值就可以推出

• ‘a’: 97。a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
• ‘A’: 65。A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
• ‘0’: 48。0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

// 根据之前的原理：字符与整数做算术运算,得出的结果为int类型
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

注意: 将大写字符加上32即可得到对应的小写字符

2.2 字符串的 ‘+’ 操作

注意：当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算符

System.out.println("老铁双击"+ 666); // 输出：老铁双击666

注意：当一个表达式中既有整数/浮点数常量，又有字符串时，要注意 ‘+’ 号连接的是什么常量

System.out.println(1 + 1999 + "年");       // 输出：2000年
System.out.println(3 + 4 + "月" + 3 + 1);  // 输出：7日31
// 可以使用小括号改变运算的优先级
System.out.println(3 + 4 + "月" + (3 + 1)); // 输出：7月4

2.3 算术运算符案例

需求： 键盘录入一个三位数，将其拆分为个位，十位，百位，打印在控制台

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 使用Scanner键盘录入一个三位数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int num = sc.nextInt();

// 1. 个位的计算：数值 % 10
int ge = num % 10;
// 2. 十位的计算：数值 / 10 % 10
int shi = num / 10 % 10;
// 3. 百位的计算：数值 / 100
int bai = num / 100;

System.out.println("整数"+num+"的个位为:" + ge);
System.out.println("整数"+num+"的十位为:" + shi);
System.out.println("整数"+num+"的百位为:" + bai);
}

2.4 自增自减运算符

符号	作用	说明
++	自增	变量的值加1
- -	自减	变量的值减1

1. 自增运算符分为 前自增 和 后自增
2. 自减运算符分为 前自减 和 后自减

区别和联系:

1. 单独使用的时候， ++和- - 无论是放在变量的前边还是后边，结果是一样的。
2. 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者- -。
3. 参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。

int i = 10;
i++;  // 单独使用
System.out.println("i=" + i);  // i=11

int j = 10;
++j;  // 单独使用
System.out.println("j=" + j);  // j=11

int x = 10;
int y = x++;  // 后加加，使用x原来的值赋值给y，结束后x本身自增1。先赋值后自增
System.out.println("x=" + x + ", y=" + y);  // x=11，y=10

int m = 10;
int n = ++m;  // 前加加，使用m自增后的值赋值给n，先自增后赋值
System.out.println("m=" + m + ", n=" + n);  // m=11，n=11

2.5 赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	先加后赋值	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

short s = 10;
s = s + 10;  // 报错，因为运算后s+10的结果提升为int类型，int类型赋值给short需要强转
s += 10;  // 不报错，隐含了强制类型转换，相当于 s = (short) (s + 10);

2.6 关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、大于等于、等于、不等于

符号	说明
==	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

注意事项:

1. 关系运算符的结果都是boolean类型，要么是true，要么是false。
2. "==“是判断是否相等的关系，”="是赋值

int a = 10;
int b = 20;
System.out.println(a == b);  // false
System.out.println(a != b);  // true
System.out.println(a > b);  // false
System.out.println(a >= b);  // false
System.out.println(a < b);  // true
System.out.println(a <= b);  // true
// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag);  // 输出false

2.7 逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
|	逻辑或	a|b，a和b都是false，结果为false，否则为true
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k));  //false | false,输出false
System.out.println((i < j) | (i > k));  //true | false,输出true
System.out.println((i > j) | (i < k));  //false | true,输出true
System.out.println((i < j) | (i < k));  //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k));  //false ^ false,输出false
System.out.println((i < j) ^ (i > k));  //true ^ false,输出true
System.out.println((i > j) ^ (i < k));  //false ^ true,输出true
System.out.println((i < j) ^ (i < k));  //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j));  //false
System.out.println(!(i > j));  //!false，,输出true

2.7.1 短路运算符

符号	作用	说明
&&	短路与	作用和&相同，但具有短路效果
||	短路或	作用和|相同，但是有短路效果

• 逻辑与&: 无论左边真假，右边都要执行。
• 短路与&&: 如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或|: 无论左边真假，右边都要执行。
• 短路或||: 如果左边为假，右边执行；如果左边为真，右边不执行

int x = 1;
int y = 1;

System.out.println((x++ > 1) & (y++ > 2)); // 两个表达都会运算
System.out.println(x); // 2
System.out.println(y); // 2

x = 1;
y = 1;
System.out.println((x++ > 1) && (y++ > 2)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 2
System.out.println(y); // 1

2.8 三元运算符

三元运算符结构：关系表达式 ? 表达式1 : 表达式2;

解释：问号前面是判断条件，判断结果为boolean类型，为true时执行表达式1并将最终的结果返回，为false时执行表达式2并将最终结果返回。

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断条件为a>b。在这里结果为false。执行 冒号: 后面的内容，将b的值返回给了c

2.8.1 三元运算符案例

需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高

public class Demo2 {
public static void main(String[] args) {
//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
int height1 = 150;
int height2 = 210;
int height3 = 165;

//2：用三元运算符获取前两个和尚的较高身高值，并用临时变量保存起来。
int tempHeight = height1 > height2 ? height1 : height2;

//3：用三元运算符获取临时身高值和第三个和尚身高进行比较，并用最大身高变量保存。
int maxHeight = tempHeight > height3 ? tempHeight : height3;
// 简便写法
int maxHeight1 = ((height1 > height2 ? height1 : height2) > height3) ? (height1 > height2 ? height1 : height2) : height3;

//4：输出结果
System.out.println("maxHeight:" + maxHeight);
System.out.println("maxHeight1:" + maxHeight1);
}
}