JAVA面试题解惑系列八聊聊基本类型内置类型.docx

JAVA面试题解惑系列八聊聊基本类型内置类型.docx

《JAVA面试题解惑系列八聊聊基本类型内置类型.docx》由会员分享，可在线阅读，更多相关《JAVA面试题解惑系列八聊聊基本类型内置类型.docx（34页珍藏版）》请在冰豆网上搜索。

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

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.        // 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.  

10.        // short  

11.        System.out.println（"基本类型：

short 二进制位数：

" + Short.SIZE）;  

12.        System.out.println（"包装类：

java.lang.Short"）;  

13.        System.out.println（"最小值：

Short.MIN_VALUE=" + Short.MIN_VALUE）;  

14.        System.out.println（"最大值：

Short.MAX_VALUE=" + Short.MAX_VALUE）;  

15.        System.out.println（）;  

16.  

17.        // int  

18.        System.out.println（"基本类型：

int 二进制位数：

" + Integer.SIZE）;  

19.        System.out.println（"包装类：

java.lang.Integer"）;  

20.        System.out.println（"最小值：

Integer.MIN_VALUE=" + Integer.MIN_VALUE）;  

21.        System.out.println（"最大值：

Integer.MAX_VALUE=" + Integer.MAX_VALUE）;  

22.        System.out.println（）;  

23.  

24.        // long  

25.        System.out.println（"基本类型：

long 二进制位数：

" + Long.SIZE）;  

26.        System.out.println（"包装类：

java.lang.Long"）;  

27.        System.out.println（"最小值：

Long.MIN_VALUE=" + Long.MIN_VALUE）;  

28.        System.out.println（"最大值：

Long.MAX_VALUE=" + Long.MAX_VALUE）;  

29.        System.out.println（）;  

30.  

31.        // float  

32.        System.out.println（"基本类型：

float 二进制位数：

" + Float.SIZE）;  

33.        System.out.println（"包装类：

java.lang.Float"）;  

34.        System.out.println（"最小值：

Float.MIN_VALUE=" + Float.MIN_VALUE）;  

35.        System.out.println（"最大值：

Float.MAX_VALUE=" + Float.MAX_VALUE）;  

36.        System.out.println（）;  

37.  

38.        // double  

39.        System.out.println（"基本类型：

double 二进制位数：

" + Double.SIZE）;  

40.        System.out.println（"包装类：

java.lang.Double"）;  

41.        System.out.println（"最小值：

Double.MIN_VALUE=" + Double.MIN_VALUE）;  

42.        System.out.println（"最大值：

Double.MAX_VALUE=" + Double.MAX_VALUE）;  

43.        System.out.println（）;  

44.  

45.        // char  

46.        System.out.println（"基本类型：

char 二进制位数：

" + Character.SIZE）;  

47.        System.out.println（"包装类：

java.lang.Character"）;  

48.        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  

49.        System.out.println（"最小值：

Character.MIN_VALUE="  

50.                + （int） Character.MIN_VALUE）;  

51.        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  

52.        System.out.println（"最大值：

Character.MAX_VALUE="  

53.                + （int） Character.MAX_VALUE）;  

54.    }  

55.}  

publicclassPrimitiveTypeTest{

publicstaticvoidmain（String[]args）{

//byte

System.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（）;

//short

System.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（）;

//int

System.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（）;

//long

System.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（）;

//float

System.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（）;

//double

System.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（）;

//char

System.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.

6.基本类型：

short二进制位数：

16

7.包装类：

java.lang.Short

8.最小值：

Short.MIN_VALUE=-32768

9.最大值：

Short.MAX_VALUE=32767

10.

11.基本类型：

int二进制位数：

32

12.包装类：

java.lang.Integer

13.最小值：

Integer.MIN_VALUE=-2147483648

14.最大值：

Integer.MAX_VALUE=2147483647

15.

16.基本类型：

long二进制位数：

64

17.包装类：

java.lang.Long

18.最小值：

Long.MIN_VALUE=-9223372036854775808

19.最大值：

Long.MAX_VALUE=9223372036854775807

20.

21.基本类型：

float二进制位数：

32

22.包装类：

java.lang.Float

23.最小值：

Float.MIN_VALUE=1.4E-45

24.最大值：

Float.MAX_VALUE=3.4028235E38

25.

26.基本类型：

double二进制位数：

64

27.包装类：

java.lang.Double

28.最小值：

Double.MIN_VALUE=4.9E-324

29.最大值：

Double.MAX_VALUE=1.7976931348623157E308

30.

31.基本类型：

char二进制位数：

16

32.包装类：

java.lang.Character

33.最小值：

Character.MIN_VALUE=0

34.最大值：

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虚拟机（JavaVirtualMachine）可以完成基本类型和它们对应包装类之间的自动转换。

因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。

另外，所有基本类型（包括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.  

10.        // 给short类型变量赋值时，数字后无需后缀标识  

11.        short short_a = 1;  

12.        // 编译器会做范围检查，如果赋予的值超出了范围就会报错  

13.        // short short_b = 70000;  

14.        // 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围  

15.        // byte short_c = 1L;  

16.  

17.        // 给short类型变量赋值时，数字后无需后缀标识  

18.        int int_a = 1;  

19.        // 编译器会做范围检查，如果赋予的值超出了范围就会报错  

20.        // int int_b = 2200000000;  

21.        // 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围  

22.        // int int_c = 1L;  

23.  

24.        // 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识  

25.        long long_a = 1;  

26.        // 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识  

27.        long long_b = 2200000000L;  

28.        // 编译器会做范围检查，如果赋予的值超出了范围就会报错  

29.        // long long_c = 9300000000000000000L;  

30.  

31.        // 可以把一个int型值直接赋值给float型变量  

32.        float float_a = 1;  

33.        // 可以把一个long型值直接赋值给float型变量  

34.        float float_b = 1L;  

35.        // 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量  

36.        // float float_c = 1.0;  

37.        // float型数值需要有一个F（不区分大小写）后缀标识  

38.        float float_d = 1.0F;  

39.        // 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围  

40.        // float float_e = 1.0D;  

41.        // 编译器会做范围检查，如果赋予的值超出了范围就会报错  

42.        // float float_f = 3.5000000E38F;  

43.  

44.        // 可以把一个int型值直接赋值给double型变量  

45.        double double_a = 1;  

46.        // 可以把一个long型值直接赋值给double型变量  

47.        double double_b = 1L;  

48.        // 可以把一个float型值直接赋值给double型变量  

49.        double double_c = 1F;  

50.        // 不带后缀标识的浮点数默认为double类型的，可以直接赋值  

51.        double double_d = 1.0;  

52.        // 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的  

53.        double double_e = 1.0D;  

54.        // 编译器会做范围检查，如果赋予的值超出了范围就会报错  

55.        // double double_f = 1.8000000000000000E308D;  

56.  

57.        // 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围  

58.        // byte byte_d = 1.0D;  

59.        // 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围  

60.        // short short_d = 1.0D;  

61.        // 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围  

62.        // int int_d = 1.0D;  

63.        // 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围  

64.        // long long_d = 1.0D;  

65.  

66.        // 可以用字符初始化一个char型变量  

67.        char char_a = 'a';  

68.        // 也可以用一个int型数值初始化char型变量  

69.        char char_b = 1;  

70.        // 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围  

71.        // char char_c = 1L;  

72.        // 把一个float型值赋值给一个char类型变量