基本类型，或者叫做内置类型，是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. // byte
  4. System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
  5. System.out.println("包装类：java.lang.Byte");
  6. System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
  7. System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
  8. System.out.println();
  9. // short
  10. System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
  11. System.out.println("包装类：java.lang.Short");
  12. System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
  13. System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
  14. System.out.println();
  15. // int
  16. System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
  17. System.out.println("包装类：java.lang.Integer");
  18. System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
  19. System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
  20. System.out.println();
  21. // long
  22. System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
  23. System.out.println("包装类：java.lang.Long");
  24. System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
  25. System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
  26. System.out.println();
  27. // float
  28. System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
  29. System.out.println("包装类：java.lang.Float");
  30. System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
  31. System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
  32. System.out.println();
  33. // double
  34. System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
  35. System.out.println("包装类：java.lang.Double");
  36. System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
  37. System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
  38. System.out.println();
  39. // char
  40. System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
  41. System.out.println("包装类：java.lang.Character");
  42. // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
  43. System.out.println("最小值：Character.MIN_VALUE="
  44. + (int) Character.MIN_VALUE);
  45. // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
  46. System.out.println("最大值：Character.MAX_VALUE="
  47. + (int) Character.MAX_VALUE);
  48. }
  49. }
public class PrimitiveTypeTest {public static void main(String[] args) {// byteSystem.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);System.out.println("包装类：java.lang.Byte");System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);System.out.println();// shortSystem.out.println("基本类型：short 二进制位数：" + Short.SIZE);System.out.println("包装类：java.lang.Short");System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);System.out.println();// intSystem.out.println("基本类型：int 二进制位数：" + Integer.SIZE);System.out.println("包装类：java.lang.Integer");System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);System.out.println();// longSystem.out.println("基本类型：long 二进制位数：" + Long.SIZE);System.out.println("包装类：java.lang.Long");System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);System.out.println();// floatSystem.out.println("基本类型：float 二进制位数：" + Float.SIZE);System.out.println("包装类：java.lang.Float");System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);System.out.println();// doubleSystem.out.println("基本类型：double 二进制位数：" + Double.SIZE);System.out.println("包装类：java.lang.Double");System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);System.out.println();// charSystem.out.println("基本类型：char 二进制位数：" + Character.SIZE);System.out.println("包装类：java.lang.Character");// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台System.out.println("最小值：Character.MIN_VALUE="+ (int) Character.MIN_VALUE);// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台System.out.println("最大值：Character.MAX_VALUE="+ (int) Character.MAX_VALUE);}
}

运行结果：

  1. 基本类型：byte 二进制位数：8
  2. 包装类：java.lang.Byte
  3. 最小值：Byte.MIN_VALUE=-128
  4. 最大值：Byte.MAX_VALUE=127
  5. 基本类型：short 二进制位数：16
  6. 包装类：java.lang.Short
  7. 最小值：Short.MIN_VALUE=-32768
  8. 最大值：Short.MAX_VALUE=32767
  9. 基本类型：int 二进制位数：32
  10. 包装类：java.lang.Integer
  11. 最小值：Integer.MIN_VALUE=-2147483648
  12. 最大值：Integer.MAX_VALUE=2147483647
  13. 基本类型：long 二进制位数：64
  14. 包装类：java.lang.Long
  15. 最小值：Long.MIN_VALUE=-9223372036854775808
  16. 最大值：Long.MAX_VALUE=9223372036854775807
  17. 基本类型：float 二进制位数：32
  18. 包装类：java.lang.Float
  19. 最小值：Float.MIN_VALUE=1.4E-45
  20. 最大值：Float.MAX_VALUE=3.4028235E38
  21. 基本类型：double 二进制位数：64
  22. 包装类：java.lang.Double
  23. 最小值：Double.MIN_VALUE=4.9E-324
  24. 最大值：Double.MAX_VALUE=1.7976931348623157E308
  25. 基本类型：char 二进制位数：16
  26. 包装类：java.lang.Character
  27. 最小值：Character.MIN_VALUE=0
  28. 最大值：Character.MAX_VALUE=65535

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。

大家将运行结果与上表信息仔细比较就会发现float、double两种类型的最小值与Float.MIN_VALUE、Double.MIN_VALUE的值并不相同，这是为什么呢？实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是float和double类型所能表示的最小正数。也就是说存在这样一种情况，0到±Float.MIN_VALUE之间的值float类型无法表示，0到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0（1.5）开始，JAVA虚拟机（Java Virtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

各种数值类型之间的赋值与转换遵循什么规律呢？我们来看下面这个例子：

Java代码
  1. public class PrimitiveTypeTest {
  2. public static void main(String[] args) {
  3. // 给byte类型变量赋值时，数字后无需后缀标识
  4. byte byte_a = 1;
  5. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  6. // byte byte_b = 1000;
  7. // 把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
  8. // byte byte_c = 1L;
  9. // 给short类型变量赋值时，数字后无需后缀标识
  10. short short_a = 1;
  11. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  12. // short short_b = 70000;
  13. // 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围
  14. // byte short_c = 1L;
  15. // 给short类型变量赋值时，数字后无需后缀标识
  16. int int_a = 1;
  17. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  18. // int int_b = 2200000000;
  19. // 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围
  20. // int int_c = 1L;
  21. // 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识
  22. long long_a = 1;
  23. // 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识
  24. long long_b = 2200000000L;
  25. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  26. // long long_c = 9300000000000000000L;
  27. // 可以把一个int型值直接赋值给float型变量
  28. float float_a = 1;
  29. // 可以把一个long型值直接赋值给float型变量
  30. float float_b = 1L;
  31. // 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量
  32. // float float_c = 1.0;
  33. // float型数值需要有一个F（不区分大小写）后缀标识
  34. float float_d = 1.0F;
  35. // 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围
  36. // float float_e = 1.0D;
  37. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  38. // float float_f = 3.5000000E38F;
  39. // 可以把一个int型值直接赋值给double型变量
  40. double double_a = 1;
  41. // 可以把一个long型值直接赋值给double型变量
  42. double double_b = 1L;
  43. // 可以把一个float型值直接赋值给double型变量
  44. double double_c = 1F;
  45. // 不带后缀标识的浮点数默认为double类型的，可以直接赋值
  46. double double_d = 1.0;
  47. // 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的
  48. double double_e = 1.0D;
  49. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  50. // double double_f = 1.8000000000000000E308D;
  51. // 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
  52. // byte byte_d = 1.0D;
  53. // 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围
  54. // short short_d = 1.0D;
  55. // 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围
  56. // int int_d = 1.0D;
  57. // 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围
  58. // long long_d = 1.0D;
  59. // 可以用字符初始化一个char型变量
  60. char char_a = 'a';
  61. // 也可以用一个int型数值初始化char型变量
  62. char char_b = 1;
  63. // 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
  64. // char char_c = 1L;
  65. // 把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
  66. // char char_d = 1.0F;
  67. // 把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
  68. // char char_e = 1.0D;
  69. // 编译器会做范围检查，如果赋予的值超出了范围就会报错
  70. // char char_f = 70000;
  71. }
  72. }
public class PrimitiveTypeTest {public static void main(String[] args) {// 给byte类型变量赋值时，数字后无需后缀标识byte byte_a = 1;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// byte byte_b = 1000;// 把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围// byte byte_c = 1L;// 给short类型变量赋值时，数字后无需后缀标识short short_a = 1;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// short short_b = 70000;// 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围// byte short_c = 1L;// 给short类型变量赋值时，数字后无需后缀标识int int_a = 1;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// int int_b = 2200000000;// 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围// int int_c = 1L;// 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识long long_a = 1;// 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识long long_b = 2200000000L;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// long long_c = 9300000000000000000L;// 可以把一个int型值直接赋值给float型变量float float_a = 1;// 可以把一个long型值直接赋值给float型变量float float_b = 1L;// 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量// float float_c = 1.0;// float型数值需要有一个F（不区分大小写）后缀标识float float_d = 1.0F;// 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围// float float_e = 1.0D;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// float float_f = 3.5000000E38F;// 可以把一个int型值直接赋值给double型变量double double_a = 1;// 可以把一个long型值直接赋值给double型变量double double_b = 1L;// 可以把一个float型值直接赋值给double型变量double double_c = 1F;// 不带后缀标识的浮点数默认为double类型的，可以直接赋值double double_d = 1.0;// 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的double double_e = 1.0D;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// double double_f = 1.8000000000000000E308D;// 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围// byte byte_d = 1.0D;// 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围// short short_d = 1.0D;// 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围// int int_d = 1.0D;// 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围// long long_d = 1.0D;// 可以用字符初始化一个char型变量char char_a = 'a';// 也可以用一个int型数值初始化char型变量char char_b = 1;// 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围// char char_c = 1L;// 把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围// char char_d = 1.0F;// 把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围// char char_e = 1.0D;// 编译器会做范围检查，如果赋予的值超出了范围就会报错// char char_f = 70000;}
}

从上面的例子中我们可以得出如下几条结论：

  1. 未带有字符后缀标识的整数默认为int类型；未带有字符后缀标识的浮点数默认为double类型。
  2. 如果一个整数的值超出了int类型能够表示的范围，则必须增加后缀“L”（不区分大小写，建议用大写，因为小写的L与阿拉伯数字1很容易混淆），表示为long型。
  3. 带有“F”（不区分大小写）后缀的整数和浮点数都是float类型的；带有“D”（不区分大小写）后缀的整数和浮点数都是double类型的。
  4. 编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查，如果超出了它们的取值范围就会报错。
  5. int型值可以赋给所有数值类型的变量；long型值可以赋给long、float、double类型的变量；float型值可以赋给float、double类型的变量；double型值只能赋给double类型变量。

下图显示了几种基本类型之间的默认逻辑转换关系：

图中的实线表示无精度损失的转换，而虚线则表示这样的转换可能会损失一定的精度。如果我们想把一个能表示更大范围或者更高精度的类型，转换为一个范围更小或者精度更低的类型时，就需要使用强制类型转换（Cast）了。不过我们要尽量避免这种用法，因为它常常引发错误。请看下面的例子，如果不运行代码，你能预测它的结果吗？

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. }
public class PrimitiveTypeTest {public static void main(String[] args) {int a = 123456;short b = (short) a;// b的值会是什么呢？System.out.println(b);}
}

运行结果：

  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 class PrimitiveTypeTest {
  2. public static void main(String[] args) {
  3. short s1 = 1;
  4. // 这一行代码会报编译错误
  5. // s1 = s1 + 1;
  6. // 这一行代码没有报错
  7. s1 = 1 + 1;
  8. // 这一行代码也没有报错
  9. s1 += 1;
  10. }
  11. }
public class PrimitiveTypeTest {public static void main(String[] args) {short s1 = 1;// 这一行代码会报编译错误// s1 = s1 + 1;// 这一行代码没有报错s1 = 1 + 1;// 这一行代码也没有报错s1 += 1;}
}

从例子中我们可以看出结果了。利用上面列举的规律，也很容易解释。在s1=s1+1;中，s1+1运算的结果是int型，把它赋值给一个short型变量s1，所以会报错；而在s1+=1;中，由于是s1是short类型的，所以1首先被强制转换为short型，然后再参与运算，并且结果也是short类型的，因此不会报错。那么，s1=1+1;为什么不报错呢？这是因为1+1是个编译时可以确定的常量，“+”运算在编译时就被执行了，而不是在程序执行的时候，这个语句的效果等同于s1=2，所以不会报错。前面讲过了，对基本类型执行强制类型转换可能得出错误的结果，因此在使用+=、-=、*=、/=、%=等运算符时，要多加注意。

当使用“==”运算符在基本类型和其包装类对象之间比较时，遵循如下规则：

  1. 只要两个操作数中有一个是基本类型，就是比较它们的数值是否相等。
  2. 否则，就是判断这两个对象的内存地址是否相等，即是否是同一个对象。

下面的测试例子则验证了以上的规则：

Java代码
  1. public class EqualsTest {
  2. public static void main(String[] args) {
  3. // int类型用int类型初始化
  4. int int_int = 0;
  5. // int类型用Integer类型初始化
  6. int int_Integer = new Integer(0);
  7. // Integer类型用Integer类型初始化
  8. Integer Integer_Integer = new Integer(0);
  9. // Integer类型用int类型初始化
  10. Integer Integer_int = 0;
  11. System.out.println("int_int == int_Integer结果是："
  12. + (int_int == int_Integer));
  13. System.out.println("Integer_Integer == Integer_int结果是："
  14. + (Integer_Integer == Integer_int));
  15. System.out.println();
  16. System.out.println("int_int == Integer_Integer结果是："
  17. + (int_int == Integer_Integer));
  18. System.out.println("Integer_Integer == int_int结果是："
  19. + (Integer_Integer == int_int));
  20. System.out.println();
  21. // boolean类型用boolean类型初始化
  22. boolean boolean_boolean = true;
  23. // boolean类型用Boolean类型初始化
  24. boolean boolean_Boolean = new Boolean(true);
  25. // Boolean类型用Boolean类型初始化
  26. Boolean Boolean_Boolean = new Boolean(true);
  27. // Boolean类型用boolean类型初始化
  28. Boolean Boolean_boolean = true;
  29. System.out.println("boolean_boolean == boolean_Boolean结果是："
  30. + (boolean_boolean == boolean_Boolean));
  31. System.out.println("Boolean_Boolean == Boolean_boolean结果是："
  32. + (Boolean_Boolean == Boolean_boolean));
  33. System.out.println();
  34. System.out.println("boolean_boolean == Boolean_Boolean结果是："
  35. + (boolean_boolean == Boolean_Boolean));
  36. System.out.println("Boolean_Boolean == boolean_boolean结果是："
  37. + (Boolean_Boolean == boolean_boolean));
  38. }
  39. }
public class EqualsTest {public static void main(String[] args) {// int类型用int类型初始化int int_int = 0;// int类型用Integer类型初始化int int_Integer = new Integer(0);// Integer类型用Integer类型初始化Integer Integer_Integer = new Integer(0);// Integer类型用int类型初始化Integer Integer_int = 0;System.out.println("int_int == int_Integer结果是："+ (int_int == int_Integer));System.out.println("Integer_Integer == Integer_int结果是："+ (Integer_Integer == Integer_int));System.out.println();System.out.println("int_int == Integer_Integer结果是："+ (int_int == Integer_Integer));System.out.println("Integer_Integer == int_int结果是："+ (Integer_Integer == int_int));System.out.println();// boolean类型用boolean类型初始化boolean boolean_boolean = true;// boolean类型用Boolean类型初始化boolean boolean_Boolean = new Boolean(true);// Boolean类型用Boolean类型初始化Boolean Boolean_Boolean = new Boolean(true);// Boolean类型用boolean类型初始化Boolean Boolean_boolean = true;System.out.println("boolean_boolean == boolean_Boolean结果是："+ (boolean_boolean == boolean_Boolean));System.out.println("Boolean_Boolean == Boolean_boolean结果是："+ (Boolean_Boolean == Boolean_boolean));System.out.println();System.out.println("boolean_boolean == Boolean_Boolean结果是："+ (boolean_boolean == Boolean_Boolean));System.out.println("Boolean_Boolean == boolean_boolean结果是："+ (Boolean_Boolean == boolean_boolean));}
}

运行结果：

  1. int_int == int_Integer结果是：true
  2. Integer_Integer == Integer_int结果是：false
  3. int_int == Integer_Integer结果是：true
  4. Integer_Integer == int_int结果是：true
  5. boolean_boolean == boolean_Boolean结果是：true
  6. Boolean_Boolean == Boolean_boolean结果是：false
  7. boolean_boolean == Boolean_Boolean结果是：true
  8. Boolean_Boolean == boolean_boolean结果是：true

为了便于查看，上例中变量命名没有采用规范的方式，而是采用了“变量类型”+“_”+“初始化值类型”的方式。

Math.round()方法

java.lang.Math类里有两个round()方法，它们的定义如下：

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

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

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

运行结果：

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

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

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

但是上面的结论仍然不是很好记忆。我们来看看round()方法的内部实现会给我们带来什么启发？我们来看这两个方法内部的代码：

Java代码
  1. public static int round(float a) {
  2. return (int)floor(a + 0.5f);
  3. }
  4. public static long round(double a) {
  5. return (long)floor(a + 0.5d);
  6. }
public static int round(float a) {return (int)floor(a + 0.5f);
}
public static long round(double a) {return (long)floor(a + 0.5d);
}

看来它们都是将参数值+0.5后交与floor()进行运算，然后取返回值。那么floor()方法的作用又是什么呢？它是取一个小于等于参数值的最大整数。比如经过floor()方法运算后，如果参数是10.2则返回10，13返回13，-20.82返回-21，-16返回-16等等。既然是这样，我们就可以用一句话来概括round()方法的运算效果了：

  • Math类的round()方法的运算结果是一个<=(参数值+0.5)的最大整数。

switch语句

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

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

运行结果如下：

  1. byte可以用于switch语句
  2. Byte类可以用于switch语句
  3. char可以用于switch语句
  4. Character类可以用于switch语句
  5. short可以用于switch语句
  6. Short类可以用于switch语句
  7. int可以用于switch语句
  8. Integer类可以用于switch语句
  9. 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语句。

转载于:https://blog.51cto.com/zangweiren/94388

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

  1. JAVA面试题解惑系列（十）——话说多线程

    JAVA面试题解惑系列(十)--话说多线程 关键字: java 面试题 多线程 thread 线程池 synchronized 死锁 作者:臧圩人(zangweiren) 网址:http://zang ...

  2. 读《臧圩人的Java面试题解惑系列》

    原文:http://zangweiren.javaeye.com/blog/208122 读了臧圩人的Java面试题解惑系列第一章:类的初始化顺序 总结: 1,(静态变量.静态初始化块)>(变量 ...

  3. 学习臧圩人Java面试题解惑系列总结

    以下内容为学习臧圩人 系列文章的简单总结: 1.类的初始化顺序 没有继承关系:静态变量.静态初始化块->变量.初始化块->构造器. 涉及继承关系:父类静态变量.父类静态初始化块->子 ...

  4. JAVA面试题解惑系列（四）——final、finally和finalize的区别

    final.finally和finalize的区别是什么? 这是一道再经典不过的面试题了,我们在各个公司的面试题中几乎都能看到它的身影.final.finally和finalize虽然长得像孪生三兄弟 ...

  5. 臧圩人：java面试题解惑系列（一）——类的初始化顺序学习笔记

    1.对于静态变量.静态初始化块.变量.初始化块.构造器,它们的初始化顺序依次是 (静态变量.静态初始化块)>(变量.初始化块)>构造器 2. 父类--静态变量 父类--静态初始化块 子类- ...

  6. java 百分比相加_2019年Java面试题基础系列228道（5），快看看哪些你还不会？

    2019年Java面试题基础系列228道 Java面试题(一) 第一篇更新1~20题的答案解析 第二篇更新21~50题答案解析 第三篇更新51~95题答案解析 Java面试题(二) 第四篇更新1~20 ...

  7. JAVA面试常考系列八

    转载自 JAVA面试常考系列八 题目一 JDBC是什么? JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系 ...

  8. Java面试题基础系列

    Java面试题基础系列 1.面向对象的特征有哪些方面? 面向对象的特征主要有以下几个方面:抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面.抽象只关注对象有哪些属性和 ...

  9. 2022年Java面试题基础系列228道（1），快看看哪些你还不会？

    Java面试题(一) 1.面向对象的特征有哪些方面? 2.访问修饰符 public,private,protected,以及不写(默认)时的区别? 3.String 是最基本的数据类型吗? 4.flo ...

最新文章

  1. asp利用dictionary创建二维数组
  2. 【直播课】6小时教你熟知Anchor free理论基础，掌握项目实战技巧
  3. rabbitmq的启动命令和springboot整合使用rabbitmq
  4. EntityFramework附加实体
  5. 合并区间—leetcode56
  6. linux开发亿连手机互联,亿连手机互联车载版下载-亿连手机互联车机版v6.6.1 安卓版-腾牛安卓网...
  7. 在Sping Boot logback的使用
  8. C语言数组及相关函数
  9. 工厂模式 java_JAVA设计模式之工厂模式(简单工厂模式+工厂方法模式)
  10. 5G 浪潮来袭！程序员在风口中有何机遇？
  11. 在线手机号码提取工具
  12. java 解析xml报文解析_开源分布式中间件 DBLE Server.xml 配置解析
  13. matlab绘制二元一次函数图像_二元一次函数曲线拟合的Matlab实现.pdf
  14. 分享一款手机最强Python编程神器，用手机运行Python。天秀！
  15. 计算N阶行列式的详细讲解(C语言)(降阶法)(函数递归)
  16. python+fastapi+jinja2+mongodb，突然感觉整个人一下就轻松了，python学习之路
  17. IFC学习相关资料加强版 致敬黑夜的骑士
  18. 自然语言处理技术之词嵌入方法-2
  19. 数据分析实战之超市零售分析(附python代码)
  20. ZooKeeper源码分析之完整网络通信流程（一）

热门文章

  1. 关于12306——传统信息化系统面向互联网应用的挑战
  2. 实战揭露360和QQ医生系统漏洞检测真相！
  3. Appium v1.17.1-1报错：pkg: /data/local/tmp/appium_cache/8d4156e508daae39c3f4815552e22e311432ff1f.apk
  4. 讲真，java学习是有些困难，但迎难而上正是男儿本色（附学习资料） ！
  5. 完美更新安装TensorFlow-gpu
  6. Linaro ubuntu for arndale octa烧写步骤
  7. 计算机网络面试《葵花宝典》
  8. android 小米手机打不开摄像头,小米手机相机故障无法连接到相机怎么办【故障解决】...
  9. Nuist集训队作业：深度优先搜索（回溯算法）
  10. Nuist ACM集训队寒假训练计划