Java零基础-基本的类型转换

发表于 | 分类于 |
字数统计: 1k 字 | 阅读时长 ≈ 4 分钟

关于基本数据类型之间的互相转换：转换规则

  1. 八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以相互转换

  2. 自动类型转换：小容量向大容量转换。容量从小到大排序：

    byte < short < int < long < float < double

    ​ chart <

    注意：任何浮点类型不管占用多少个字节，都比整数型容量大

    ​ chart 和 short 可表示的种类数量相同，但是 chart 可以取更大的正整数

  3. 强制类型转换：大容量转换成小容量。需要加强制类型转换符，编译才通过，但是在运行阶段可能会损失精度，所以谨慎使用

  4. 当一个==整数字面值没有超过 byte、short、char 的取值范围，可以直接赋值给 byte、short、char类型的变量

  5. byte、short、char 混合运算的时候，各自先转换成 int类型 再做运算

  6. 多种数据类型混合运算，先转换成容量最大的那种类型再做运算

注意：

byte b = 3; 编译通过，3没有超出 byte 类型取值范围

int i = 10;

byte b = i / 3; 编译报错：编译器只检查语法，不会运算 i / 3

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// 1. 出现错误，1000 超出了 byte 的范围
// byte a = 1000;

// 2. 正确，因为 20 没有超出 byte 范围
byte a = 20;

// 3. 变量不能重名
// short a = 1000;

// 4. 正确，因为数值 1000 没有超出 short 类型的范围
short b = 1000;

// 5. 正确，因为默认就是 int，并且没有超出 int 范围
int c = 1000;

// 6. 正确，可以自动转换
long d = c;

// 7. 错误，出现精度丢失问题，大类型-->>小类型会出现问题
// int e = d;

// 8. 将 long 强制转换成 int 类型
// 因为值 1000，没有超出 int 范围，所以转换是正确的
int e = (int)d;

// 9. 因为 java 中的运算会会转成最大类型
// 而 10 和 3 默认为 int,所以运算后的最大类型也是 int，所以是正确的
int f = 10/3;

// 10. 声明 10 为 long 类型
long g = 10;

// 11. 出现错误，多个数值在运算过程中，会转换成容量最大的类型
// 以下示例最大的类型为 double，而 h 为 int
// 所以就会出现大类型（long）到小类型（int）的转换，将会出现精度丢失问题
//int h = g/3;

// 12. 可以强制转换,因为运算结果没有超出 int 范围
// int h = (int)g/3;

// 13. 可以采用 long 类型来接收运算结果
// long h = g/3;

// 14. 出现精度损失问题，以下问题主要是优先级的问题
// 将 g 转换成 int，然后又将 int 类型的 g 转换成 byte,最后 byte 类型的 g 和 3 运算，
// 那么，它的运算结果类型就是 int，所以 int 赋值给 byte 就出现了精度损失问题
// byte h = (byte)(int)g/3;
// 正确
// byte h = (byte)(int)(g/3);

// 15. 不能转换,还有因为优先级的问题
// byte h = (byte)g/3;

// 16. 可以转换，因为运算结果没有超出 byte 范围
//byte h = (byte)(g/3);

// 17. 可以转换，因为运算结果没有超出 short 范围
short h = (short)(g/3);
short i = 10;
byte j = 5;

// 18. 错误，short 和 byte 运算，首先会转换成 int 再运算
// 所以运算结果为 int，int 赋值给 short 就会出现精度丢失问题
// short k = i + j;
// 可以将运算结果强制转换成 short
// short k = (short)(i + j);

// 19. 因为运算结果为 int，所以可以采用 int 类型接收
int k = i + j;

// 20. 输出结果为 97，也就是 a 的 ascii 值
char l = 'a';
System.out.println((byte)l);

// 21. 输出结构为 197,取得 a 的 ascii 码值，让后与 100 进行相加运算
int m = l + 100;
System.out.println(m);

// 22. 输出 3.0，因为 10 /3 得到的是 int类型的结果，再转换成 double 类型
double dd = 10 /3;
System.out.println(dd);

// 23. 输出3.3333333333333335，这次得到的结果就是 double类型
dd = 10.0 / 3;
System.out.println(dd);