二、类型转换、运算符
（一）类型转换
1、自动类型转换
1）定义：
· 类型范围小的变量，可以直接赋值给类型范围大的变量
byte a = 20;
int b = a; //发生了自动类型转换
System.out.println(a);
System.out.println(b);
/* 20
20 */2）底层原理：
a 00001100 （8位） 12
b 00000000 00000000 00000000 00001100 （32位） 12
3）自动类型转换的其他形式：
byte → short → int → long → float → double
char → int
int age = 23;
double db = age;
System.out.println(db); // 23.0
char ch = 'a'; // 00000000 01100001
int code = ch; // 00000000 00000000 00000000 01100001
System.out.println(code); // 972、表达式的自动类型转换
1）定义：
· 在表达式中，小范围类型的变量会自动转换成当前较大范围的类型再运算
byte、short、char → int → long → float → double
byte a = 10;
int b = 20;
double c = 1.0;
double rs = a + b + c;
System.out.println(rs); // 31.0
double rs2 = a + b - 2.3;
System.out.println(rs2); // 27.7
//面试题
byte i = 100;
byte j = 120;
int k = i + j; //此时的i、j已为int类型，故k为int类型
System.out.println(k); // 2202）注意事项：
· 表达式的最终结果类型由表达式中的最高类型决定。
· 在表达式中，byte、short、char是直接转换成int类型参与运算的。
3、强制类型转换
场景：
int a = 功能1(); int a = 20;
功能2(byte b); byte b = a; // 报错
问题：
· 类型范围较大的数据或变量，不能直接赋值给类型范围小的的变量，会报错
1）定义：
· 可以强行将类型范围大的变量、数据赋值给类型范围小的变量
数据类型 变量2 = (数据类型)变量1、数据
2）底层原理：
int a = 20;
byte b = (byte)a;
System.out.println(a); // 20
System.out.println(b); // 20a 00000000 00000000 00000000 00010100 （32位）
b 00010100 （8位）
int i = 1500；
byte j = (byte)i;
System.out.println(j); // -36i 00000000 00000000 00000101 11011100 （32位）
j 11011100 （8位）
3）注意事项：
· 强制类型转换可能造成数据（丢失）溢出
· 浮点类型强转成整型，直接丢掉小数部分，保留整数部分返回
（二）运算符
1、基本算数运算符
1）运算符：
· 对字面量或者变量进行操作的符号
2）算术运算符：
| 符号 | 作用 | 说明 |
| + | 加 | 进行加法时以加号将各项连接起来 |
| - | 减 | 进行减法时以减号将各项连接起来 |
| * | 乘 | 进行乘法时以乘号将各项连接起来，与“×”相同 |
| / | 除 | 与“÷”相同，注意：在Java中两个整数相除结果还是整数 |
| % | 取余 | 获取的是两个数据做除法的余数 |
int a = 10;
int b = 3;
System.out.println(a + b); // 13
System.out.println(a - b); // 7
System.out.println(a * b); // 30
System.out.println(a / b); // 3.33333 → 3
System.out.println(a * 1.0 / b); // 3.33333
System.out.println(3 / 2); // 1
System.out.println(3 * 1.0 / 2); // 1.5
System.out.println(3 / 2 * 1.0); // 1.0
System.out.println(a % b); // 1eg. 数值拆分
一个三位数，将其拆分为个位、十位、百位后，打印在控制台
public class OperatorTest {
public static void main(String[] args) {
int data = 589;
//个位
int ge = data % 10;
System.out.println(ge);
//十位
int shi = data / 10 % 10;
System.out.println(shi);
//百位
int bai = data / 100;
System.out.println(bai);
}
}2、+符号做连接符
· “+”符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串。
int a = 5;
System.out.println("abc" + 'a'); // abca
System.out.println("abc" + a); // abc5
System.out.println(5 + a); // 10
System.out.println("abc" + 5 + 'a'); // abc5a
System.out.println(15 + "abc" + 15); // 15abc15
System.out.println(a + 'a'); // 102
System.out.println(a + "" + 'a'); //5a
System.out.println(a + 'a' +" banana "); // 102 banana
System.out.println("banana" + a + 'a'); // banana5a
System.out.println("banana" + (a + 'a')); // banan102· 能算则算，不能算就在一起。
3、自加自减运算符
1）
| 符号 | 作用 | 说明 |
| ++ | 自增 | 变量自身的值加1 |
| -- | 自减 | 变量自身的值减1 |
注意：
· ++ 和 -- 既可以放在变量的后边，也可以放在变量的前边。
· ++、-- 只能操作变量，不能操作字面量的。
· ++、-- 如果不是单独使用（如在表达式、或者同时有其它操作），放在变量前后会存在明显区别。
→ 放在变量前面，先对变量进行+1、-1，再拿变量的值进行运算
→ 放在变量后面，先拿变量的值进行运算，再对变量的值进行+1、-1
int i = 10;
int j = ++i;
System.out.println(i); // 11
System.out.println(j); // 11
int m = 10;
int n = m++;
System.out.println(m); // 11
System.out.println(n); // 10eg.案例（面试题）
int k = 3;
int p = 5;
// k 3 4 5 4
// p 5 4 3 4
// rs 3 + 5 - 4 + 4 - 5 + 4 + 2
int rs = k++ + ++k - --p + p-- - k-- + ++p + 2;
System.out.println(k); // 4
System.out.println(p); // 4
System.out.println(rs); // 94、赋值运算符
1）就是“=”。先看“=”右边
2）扩展赋值运算符
| 符号 | 作用 | 说明 |
| += | 加后赋值 | a += b 等价于 a = (a的数据类型)(a + b)；将a + b的值给a |
| -= | 减后赋值 | a -= b 等价于 a = (a的数据类型)(a - b)；将a - b的值给a |
| *= | 乘后赋值 | a *= b 等价于 a = (a的数据类型)(a * b)；将a * b的值给a |
| /= | 除后赋值 | a /= b 等价于 a = (a的数据类型)(a / b)；将a / b的值给a |
| %= | 取余后赋值 | a %= b 等价于 a = (a的数据类型)(a % b)；将a % b的值给a |
注意：扩展的赋值运算符隐含了强制类型转换。
5、关系运算符
· 是对数据进行条件判断的符号，最终会返回一个比较的布尔结果（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 |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
注意：在做相等判断是，千万不要把 == 误写成 =
int a = 10;
int b = 10;
boolean rs = a == b;
System.out.println(rs); // true
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); // false
System.out.println(a <= b); // true
int i = 10;
int j =5;
System.out.println(i == j); // false
System.out.println(i != j); // true
System.out.println(i > j); // true
System.out.println(i >= j); // true
System.out.println(i < j); // false
System.out.println(i <= j); // false
System.out.println(i = j); // 56、逻辑运算符
1）定义：
· 可以把多个条件的布尔结果放在一起运算，最终返回一个布尔结果。
| 符号 | 介绍 | 说明 |
| & | 逻辑与 | 必须都是true，结果才是true；只要有一个false，结果一定是false |
| | | 逻辑或 | 只要一个为true，结果就是true |
| ！ | 逻辑非 | 你真我假、你假我真。!true=false、!false=true |
| ^ | 逻辑异或 | 如果两个条件都是false或者都是true则结果是false。两个条件不同结果都是true。 |
| && | 短路与 | 判断结果与“&”一样。过程是左边为false，右边则不执行。 |
| || | 短路或 | 判断结果与“|”一样。过程是左边为true，右边则不执行。 |
注意：逻辑与“&”、逻辑非“|”：无论左边是false还是true，右边都要执行。
double size = 9.8;
double storage = 6;
System.out.println(size >= 6.95 & storage >=8); // false
System.out.println(size >= 6.95 | storage >=8); // true
System.out.println(!true); // false
System.out.println(!false); // true
System.out.println(false ^ true); // true
System.out.println(true ^ false); // true
System.out.println(true ^ true); // false
System.out.println(false ^ false); // false
int a =10;
int b =20;
System.out.println(a > 100 & ++b > 10);
System.out.println(b); // 21
int i = 10;
int j = 20;
System.out.println(i > 2 || ++j > 10); // true
System.out.println(j); // 20
int c = 10;
int d = 20;
System.out.println(c > 2 | ++d > 10); // true
System.out.println(d); // 217、三元运算符
1）格式：
条件表达式 ? 值1:值2;
2）执行流程：
首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2。
double score = 18;
String rs = score >= 60 ? "考试通过" : "挂科";
System.out.println(rs); // 挂科
int a = 10000;
int b = 2000;
int max = a > b ? a : b;
System.out.println(max); // 10000案例：求三个整数的最大值
需求：定义三个整数，找出最大值并打印在控制台。
分析：
①用三元运算符获取前两个整数的最大值，并用临时变量保存起来。
· num1 > num2 ? num1 : num2;
②用三元运算符，让临时最大值和第三个整数比较，并记录结果。
· temp > num3 ? temp : num3;
③输出结果
int i = 10;
int j = 30;
int k = 50;
int temp = i > j ? i : j;
int rsMax = temp > k ? temp : k;
System.out.println(rsMax); // 50
/* 拓展知识
int raMax1 = i > j ? ( i > k ? i : K ) : ( j > k ? j : k ); // 可以没有括号
System.out.println(rsMax1); // 50
*/8、运算符优先级
· 在表达式中，哪个运算符先执行后执行是要看优先级的，例如“*、/”的优先级高于“+、-”。
| 优先级 | 运算符 |
| 1 | 0 |
| 2 | !、-、++、-- |
| 3 | *、/、% |
| 4 | +、- |
| 5 | <<、>>、>>> |
| 6 | <、<=、>、>=、instanceof |
| 7 | ==、!= |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | =、+=、-=、*=、/=、%=、&= |
System.out.println(10>3 || 10>3 && 10<3); // true
System.out.println((10>3 || 10>3)&& 10<3); // false
553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
