目录
数据类型转换
小类型->大类型
大类型->小类型
int类型和byte类型转换
int类型和String类型转换
String->int
int->String
运算符
算数运算符
关系运算符== != < > <= >=
逻辑运算符 && || !
位运算符 & | ~ ^
移位运算<< >> >>>
条件运算符(三目运算符)
运算符的优先级
关键字
数据类型转换
小类型->大类型
小类型会自动提升成大类型
只有当a为int类型,b为long类型的时候,a+b才会先将int类型提升为long类型
public class Test {
public static void main(String[] args) {
//输出-2147483648
int a = 1;
int b = Integer.MAX_VALUE;
long c = a + b;
System.out.println(c);
//输出2147483648
int d = 1;
long e = Integer.MAX_VALUE;
long f = d + e;
System.out.println(f);
}
}
public class Test {
public static void main(String[] args){
int a = 10;
double b = 1.0;
char c = 'a';
//输出108.0
System.out.println(a + b + c);//a+b+c的类型是double
}
}
当不同的数据类型进行算数运算/赋值时,小类型自动转换为大类型进行运算。
char->int :根据Unicode编码(16进制编码)转换成整型。
大类型->小类型
需要强制类型转换
double a = 2.5;
int b = (int)a;
byte/char在存储时都会转换为int存储,因为byte/char是小于四字节的数据类型
byte存储范围:-128-127
可能会丢失精度,溢出
public class Test {
public static void main(String[] args){
int a = Integer.MAX_VALUE;
long b = 1L;
long c = a + b;
int d = (int)c;
//输出-2147483648
System.out.println(d);
}
}
int类型和byte类型转换
1. 若值在byte的保存范围内,可以直接赋值,否则编译出错
byte a = 100; // 编译通过
byte b = 200; // 编译报错, 提示 从int转换到byte可能会有损失
2.当进行byte变量之间运算时,JVM会将byte转换为int
byte a = 10;
byte b = 20;
byte c = a + b;//编译出错
byte d = (byte)(a+b);//需要进行强制类型转换
int类型和String类型转换
Web开发中,默认从输入框拿到的数据为String类型
String->int
public class Test {
public static void main(String[] args){
String str = "12345";
int num = Integer.parseInt(str);
//输出12345
System.out.println(num);
}
}
报错:非纯数字组成的字符串转化为int
int->String
public class Test {
public static void main(String[] args){
int a = 10;
//方法1,输出10
String str1 = a + "";
System.out.println(str1);
//方法2,输出101
String str2 = String.valueOf(a);
System.out.println(str2+1);
}
}
运算符
算数运算符
- 基本四则运算符 + - * / %
在进行/运算时,0不能作为除数
- 增量赋值运算符 += -= *= /= %=
- 自增/自减运算符 ++ --
public class Test {
public static void main(String[] args){
int a = 10;
//输出10
System.out.println(a++);//a++是先对a取值,然后赋值
//输出12
//此时a的值已经变成11,然后进行++a操作
System.out.println(++a);//++a是先赋值,然后对a取值
int b= 10;
//输出11
System.out.println(++b);
}
}
关系运算符== != < > <= >=
关系运算符的表达式返回值都是 boolean 类型
public class Test {
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println(a == b);//false
System.out.println(a != b);//true
System.out.println(a < b);//true
System.out.println(a > b);//false
System.out.println(a <= b);//true
System.out.println(a >= b);//false
}
}
逻辑运算符 && || !
逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean
- 逻辑与 &&
规则: 两个操作数都为 true, 结果为 true, 否则结果为 false
int a = 10;
int b = 20;
int c = 30;
//true
System.out.println(a < b && b < c);
- 逻辑或 ||
//规则: 两个操作数都为 false, 结果为 false, 否则结果为 true
int a = 10;
int b = 20;
int c = 30;
//true
System.out.println(a < b || b < c);
- 逻辑非 !
//规则: 操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数)
int a = 10;
int b = 20;
//false
System.out.println(!(a < b));
- 短路求值
//&& 和 || 遵守短路求值的规则
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
计算 10 / 0 会导致程序抛出异常, 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值
1. 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式 .
2. 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式
- & 和 | (不推荐)
和 && 以及 || 相比,& 和 | 不支持短路求值
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
位运算符 & | ~ ^
Java 中对数据的操作的最小单位不是字节, 而是二进制位
位操作表示 按二进制位运算 , 计算机中都是使用二进制来表示数据的 (01 构成的序列 ), 按位运算就是在按照二进制位的
- 按位与 &
// 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.
int a = 10;
int b = 20;
//0
System.out.println(a & b);
进行按位运算 , 需要先把 10 和 20 转成二进制 , 分别为 1010 和 10100
- 按位或 |
// 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.
int a = 10;
int b = 20;
//30
System.out.println(a | b);
注意:当 & 和 | 的操作数为整数(int, short, long, byte) 的时候,表示按位运算,当操作数为 boolean 的时候, 表示逻辑运算
- 按位取反 ~
// 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
int a = 0xf;
//fffffff0
System.out.printf("%x\n", ~a);
- 按位异或 ^
// 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.
int a = 0x1;
int b = 0x2;
//3
System.out.printf("%x\n", a ^ b);
移位运算<< >> >>>
注意
1.左移 1 位,相当于原数字 * 2,左移 N 位,相当于原数字 * 2 的N次方
2. 右移 1 位,相当于原数字 / 2,右移 N 位, 相当于原数字 / 2 的N次方
- 左移 <<
// 左移 <<: 最左侧位不要了, 最右侧补 0.
int a = 0x10;
// 运行结果(十六进制)20
System.out.printf("%x\n", a << 1);
- 右移 >>
// 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
int a = 0x10;
// 运行结果(十六进制) 8
System.out.printf("%x\n", a >> 1);
int b = 0xffff0000;
// 运行结果(十六进制) ffff8000
System.out.printf("%x\n", b >> 1);
- 无符号右移 >>>
//最右侧位不要了, 最左侧补 0.
int a = 0xffffffff;
// 运行结果(十六进制)7fffffff
System.out.printf("%x\n", a >>> 1);
条件运算符(三目运算符)
表达式1 ? 表达式2 : 表达式3
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
//20
System.out.println(max);
运算符的优先级
同一优先级的运算符,运算次序由结合方向所决定
! > 算术运算符 > 关系运算符 > && > || > 赋值运算符
关键字
1.定义访问权限修饰符的关键字:private protected public
2.定义类、函数、变量修饰符的关键字:abstract final static synchroized
3.定义类与类之间关系的关键字:extends implements
4.定义建立实例及引用实例、判断实例的关键字:new this super instanceof
5.用于异常处理的关键字:try catch finally throw throws
6.用于包的关键字:package import