八聊聊基本类型内置类型.docx
《八聊聊基本类型内置类型.docx》由会员分享，可在线阅读，更多相关《八聊聊基本类型内置类型.docx（14页珍藏版）》请在冰豆网上搜索。
八聊聊基本类型内置类型
基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。
它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。
基本类型共有八种，它们分别都有相对应的包装类。
关于它们的详细信息请看下表：
基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。
数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。
JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。
实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类java.lang.Void，不过我们无法直接对它们进行操作。
对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。
请看下面的例子：
Java代码
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代码
publicclassPrimitiveTypeTest{
publicstaticvoidmain（String[]args）{
//给byte类型变量赋值时，数字后无需后缀标识
bytebyte_a=1;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//bytebyte_b=1000;
//把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
//bytebyte_c=1L;
//给short类型变量赋值时，数字后无需后缀标识
shortshort_a=1;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//shortshort_b=70000;
//把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围
//byteshort_c=1L;
//给short类型变量赋值时，数字后无需后缀标识
intint_a=1;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//intint_b=2200000000;
//把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围
//intint_c=1L;
//可以把一个int型值直接赋值给long型变量，数字后无需后缀标识
longlong_a=1;
//如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识
longlong_b=2200000000L;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//longlong_c=9300000000000000000L;
//可以把一个int型值直接赋值给float型变量
floatfloat_a=1;
//可以把一个long型值直接赋值给float型变量
floatfloat_b=1L;
//没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量
//floatfloat_c=1.0;
//float型数值需要有一个F（不区分大小写）后缀标识
floatfloat_d=1.0F;
//把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围
//floatfloat_e=1.0D;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//floatfloat_f=3.5000000E38F;
//可以把一个int型值直接赋值给double型变量
doubledouble_a=1;
//可以把一个long型值直接赋值给double型变量
doubledouble_b=1L;
//可以把一个float型值直接赋值给double型变量
doubledouble_c=1F;
//不带后缀标识的浮点数默认为double类型的，可以直接赋值
doubledouble_d=1.0;
//也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的
doubledouble_e=1.0D;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//doubledouble_f=1.8000000000000000E308D;
//把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
//bytebyte_d=1.0D;
//把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围
//shortshort_d=1.0D;
//把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围
//intint_d=1.0D;
//把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围
//longlong_d=1.0D;
//可以用字符初始化一个char型变量
charchar_a='a';
//也可以用一个int型数值初始化char型变量
charchar_b=1;
//把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
//charchar_c=1L;
//把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
//charchar_d=1.0F;
//把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
//charchar_e=1.0D;
//编译器会做范围检查，如果赋予的值超出了范围就会报错
//charchar_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代码
publicclassPrimitiveTypeTest{
publicstaticvoidmain（String[]args）{
inta=123456;
shortb=（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类型。
当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时，遵循如下规则：
1、运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型，然后再执行运算，且运算结果与运算符右边数值类型相同。
了解了这些，我们就能解答下面这个常考的面试题了。
请看：
shorts1=1;s1=s1+1;有什么错？
shorts1=1;s1+=1;有什么错？
乍一看，觉得它们都应该没有错误，可以正常运行。
我们来写个例子试试：
Java代码
publicclassPrimitiveTypeTest{
publicstaticvoidmain（String[]args）{
shorts1=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，所以不会报错。
前面讲过了，对基本类型执行强制类型转换可能得出错误的结果，因此在使用+=、-=、*=、/=、%=等运算符时，要多加注意。
Math.round（）方法
java.lang.Math类里有两个round（）方法，它们的定义如下：
Java代码
publicstaticintround（floata）{
//othercode
}
publicstaticlonground（doublea）{
//othercode
}
它们的返回值都是整数，且都采用四舍五入法。
运算规则如下：
1、如果参数为正数，且小数点后第一位>=5，运算结果为参数的整数部分+1。
2、如果参数为负数，且小数点后第一位>5，运算结果为参数的整数部分-1。
3、如果参数为正数，且小数点后第一位<5；或者参数为负数，且小数点后第一位<=5，运算结果为参数的整数部分。
我们可以通过下面的例子来验证：
Java代码
publicclassMathTest{
publicstaticvoidmain（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
6、正数：
Math.round（11.46）=11
7、负数：
Math.round（-11.46）=-11
8、
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代码
publicclassMathTest{
//枚举类型，Java5.0以上版本可用
stat
升级会员 