JAVA面试题解惑系列（八）——聊聊基本类型（内置类型）

基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。 

基本类型共有九种，它们分别都有相对应的包装类。关于它们的详细信息请看下表： 

 

对于基本类型void以及它的包装类java.lang.Void，我们都无法直接进行操作。基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子： 

Java代码 

1. public class PrimitiveTypeTest {   
2.     public static void main(String[] args) {   
3.         int a = 123456;   
4.         short b = (short) a;   
5.         // b的值会是什么呢？   
6.         System.out.println(b);   
7.     }   
8. }  

运行结果： 

1. -7616

运算符对基本类型的影响  

当使用+、-、*、/、%运算符对基本类型进行运算时，遵循如下规则： 

1. 只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型；
2. 否则，只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型；
3. 否则，只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型；
4. 否则，两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。

当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时，遵循如下规则： 

• 运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型，然后再执行运算，且运算结果与运算符左边数值类型相同。

了解了这些，我们就能解答下面这个常考的面试题了。请看： 

引用

short s1=1;s1=s1+1;有什么错？short s1=1;s1+=1;有什么错？

乍一看，觉得它们都应该没有错误，可以正常运行。我们来写个例子试试： 

Java代码 

1. public static int round(float a) {   
2.     //other code   
3. }   
4.   
5. public static long round(double a) {   
6.     //other code   
7. }  

它们的返回值都是整数，且都采用四舍五入法。运算规则如下： 

1. 如果参数为正数，且小数点后第一位>=5，运算结果为参数的整数部分+1。
2. 如果参数为负数，且小数点后第一位>5，运算结果为参数的整数部分-1。
3. 如果参数为正数，且小数点后第一位<5；或者参数为负数，且小数点后第一位<=5，运算结果为参数的整数部分。

我们可以通过下面的例子来验证： 

Java代码 

1. public class MathTest {   
2.     public static void main(String[] args) {   
3.         System.out.println("小数点后第一位=5");   
4.         System.out.println("正数：Math.round(11.5)=" + Math.round(11.5));   
5.         System.out.println("负数：Math.round(-11.5)=" + Math.round(-11.5));   
6.         System.out.println();   
7.   
8.         System.out.println("小数点后第一位<5");   
9.         System.out.println("正数：Math.round(11.46)=" + Math.round(11.46));   
10.         System.out.println("负数：Math.round(-11.46)=" + Math.round(-11.46));   
11.         System.out.println();   
12.   
13.         System.out.println("小数点后第一位>5");   
14.         System.out.println("正数：Math.round(11.68)=" + Math.round(11.68));   
15.         System.out.println("负数：Math.round(-11.68)=" + Math.round(-11.68));   
16.     }   
17. }  

运行结果： 

1. 小数点后第一位=5
2. 正数：Math.round(11.5)=12
3. 负数：Math.round(-11.5)=-11
5. 小数点后第一位<5
6. 正数：Math.round(11.46)=11
7. 负数：Math.round(-11.46)=-11
9. 小数点后第一位>5
10. 正数：Math.round(11.68)=12
11. 负数：Math.round(-11.68)=-12

根据上面例子的运行结果，我们还可以按照如下方式总结，或许更加容易记忆： 

1. 参数的小数点后第一位<5，运算结果为参数整数部分。
2. 参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正负）不变。
3. 参数的小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。

switch语句  

哪些类型可以用于switch语句的判断呢？我们做个测试就知道了： 

Java代码 

1. public class MathTest {   
2.     // 枚举类型，Java5.0以上版本可用   
3.     static enum enum_e {   
4.         A, B   
5.     }   
6.   
7.     public static void main(String[] args) {   
8.         // byte   
9.         byte byte_n = 0;   
10.         switch (byte_n) {   
11.         case 0:   
12.             System.out.println("byte可以用于switch语句");   
13.             break;   
14.         }   
15.   
16.         // Byte类   
17.         Byte byte_m = 0;   
18.         // 需要Java5.0（1.5）以上版本支持   
19.         switch (byte_m) {   
20.         case 0:   
21.             System.out.println("Byte类可以用于switch语句");   
22.             System.out.println();   
23.             break;   
24.         }   
25.   
26.         // char   
27.         char char_n = 0;   
28.         switch (char_n) {   
29.         case 0:   
30.             System.out.println("char可以用于switch语句");   
31.             break;   
32.         }   
33.   
34.         // Character类   
35.         Character char_m = 0;   
36.         // 需要Java5.0（1.5）以上版本支持   
37.         switch (char_m) {   
38.         case 0:   
39.             System.out.println("Character类可以用于switch语句");   
40.             System.out.println();   
41.             break;   
42.         }   
43.   
44.         // short   
45.         short short_n = 0;   
46.         switch (short_n) {   
47.         case 0:   
48.             System.out.println("short可以用于switch语句");   
49.             break;   
50.         }   
51.   
52.         // Short   
53.         Short short_m = 0;   
54.         // 需要Java5.0（1.5）以上版本支持   
55.         switch (short_m) {   
56.         case 0:   
57.             System.out.println("Short类可以用于switch语句");   
58.             System.out.println();   
59.             break;   
60.         }   
61.   
62.         // int   
63.         int int_n = 0;   
64.         switch (int_n) {   
65.         case 0:   
66.             System.out.println("int可以用于switch语句");   
67.             break;   
68.         }   
69.   
70.         // Integer类   
71.         Integer int_m = 0;   
72.         // 需要Java5.0（1.5）以上版本支持   
73.         switch (int_m) {   
74.         case 0:   
75.             System.out.println("Integer类可以用于switch语句");   
76.             System.out.println();   
77.             break;   
78.         }   
79.   
80.         // long   
81.         long long_n = 0;   
82.         // 编译错误，long型不能用于switch语句   
83.         // switch (long_n) {   
84.         // case 0:   
85.         // System.out.println("long可以用于switch语句");   
86.         // break;   
87.         // }   
88.   
89.         // Long类   
90.         Long long_m = 0L;   
91.         // 编译错误，Long类型不能用于switch语句   
92.         // switch (long_m) {   
93.         // case 0:   
94.         // System.out.println("Long类可以用于switch语句");   
95.         // System.out.println();   
96.         // break;   
97.         // }   
98.   
99.         // float   
100.         float float_n = 0.0F;   
101.         // 编译错误，float型不能用于switch语句   
102.         // switch (float_n) {   
103.         // case 0.0F:   
104.         // System.out.println("float可以用于switch语句");   
105.         // break;   
106.         // }   
107.   
108.         // Float类   
109.         Float float_m = 0.0F;   
110.         // 编译错误，Float类型不能用于switch语句   
111.         // switch (float_m) {   
112.         // case 0.0F:   
113.         // System.out.println("Float类可以用于switch语句");   
114.         // System.out.println();   
115.         // break;   
116.         // }   
117.   
118.         // double   
119.         double double_n = 0.0;   
120.         // 编译错误，double型不能用于switch语句   
121.         // switch (double_n) {   
122.         // case 0.0:   
123.         // System.out.println("double可以用于switch语句");   
124.         // break;   
125.         // }   
126.   
127.         // Double类   
128.         Double double_m = 0.0;   
129.         // 编译错误，Double类型不能用于switch语句   
130.         // switch (double_m) {   
131.         // case 0.0:   
132.         // System.out.println("Double类可以用于switch语句");   
133.         // System.out.println();   
134.         // break;   
135.         // }   
136.   
137.         // boolean   
138.         boolean bool_b = true;   
139.         // 编译错误，boolean型不能用于switch语句   
140.         // switch (bool_b) {   
141.         // case true:   
142.         // System.out.println("boolean可以用于switch语句");   
143.         // break;   
144.         // }   
145.   
146.         // Boolean类   
147.         Boolean bool_l = true;   
148.         // 编译错误，Boolean类型不能用于switch语句   
149.         // switch (bool_l) {   
150.         // case true:   
151.         // System.out.println("Boolean类可以用于switch语句");   
152.         // System.out.println();   
153.         // break;   
154.         // }   
155.   
156.         // String对象   
157.         String string_s = "Z";   
158.         // 编译错误，long型不能用于switch语句   
159.         // switch (string_s) {   
160.         // case "Z":   
161.         // System.out.println("String可以用于switch语句");   
162.         // System.out.println();   
163.         // break;   
164.         // }   
165.   
166.         // enum（枚举类型，Java5.0以上版本可用）   
167.         switch (MathTest.enum_e.A) {   
168.         case A:   
169.             System.out.println("enum可以用于switch语句-A");   
170.             break;   
171.         case B:   
172.             System.out.println("enum可以用于switch语句-B");   
173.             break;   
174.         }   
175.     }   
176. }  

运行结果如下： 

1. byte可以用于switch语句
2. Byte类可以用于switch语句
4. char可以用于switch语句
5. Character类可以用于switch语句
7. short可以用于switch语句
8. Short类可以用于switch语句
10. int可以用于switch语句
11. Integer类可以用于switch语句
13. enum可以用于switch语句-A

结果已经出来了，我们来总结一下： 

1. byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持）都可以用于switch语句。
2. long、float、double、boolean四种基本类型以及它们的包装类（在Java所有版本中）都不能用于switch语句。
3. enum类型，即枚举类型可以用于switch语句，但是要在Java5.0（1.5）版本以上才支持。
4. 所有类型的对象（包括String类，但在Java5.0/1.5以上版本中，该项要排除byte、char、short、int四种基本类型对应的包装类）都不能用于switch语句。