基本类型(内置类型)

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

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

对于基本类型 void 以及它的包装类 java.lang.Void,我们都无法直接进行操作。
基本类型可以分为三类,字符类型 char,布尔类型 boolean 以及数值类型byte、short、int、long、float、double。
数值类型又可以分为整数类型 byte、short、int、long 和浮点数类型 float、double。
JAVA 中的数值类型不存在无符号的,它们的取值范围是固定的,不会随着机器硬件环境或者操作系统的改变而改变。
对于数值类型的基本类型的取值范围,我们无需强制去记忆,因为它们的值都已经以常量的形式定义在对应的包装类中了。
请看下面的例子:
Java 代码
public class PrimitiveTypeTest {
	public static void main(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 虚拟机(Java Virtual Machine)可以完成基本类型和它们对应包装类之间的自动转换。 因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类, 但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。 另外,所有基本类型(包括 void)的包装类都使用了 final 修饰,因此我们无法继承它们扩展新的类,也无法重写它们的任何方法。 各种数值类型之间的赋值与转换遵循什么规律呢?我们来看下面这个例子: Java 代码
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 代码
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 代码
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 代码
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. 4. int_int == Integer_Integer 结果是:true 5. Integer_Integer == int_int 结果是:true 6. 7. boolean_boolean == boolean_Boolean 结果是:true 8. Boolean_Boolean == Boolean_boolean 结果是:false 9. 10. boolean_boolean == Boolean_Boolean 结果是:true 11. Boolean_Boolean == boolean_boolean 结果是:true 为了便于查看,上例中变量命名没有采用规范的方式,而是采用了“变量类型”+“_”+“初始化值类型”的方式。 Math.round()方法 java.lang.Math 类里有两个 round()方法,它们的定义如下: Java 代码
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 代码
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 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,负数运算结果为整数部分。 但是上面的结论仍然不是很好记忆。我们来看看 round()方法的内部实现会给我们带来什么启发?我们来看这两个方法内部的代码: Java 代码
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 代码
public class MathTest {
	// 枚举类型,Java5.0 以上版本可用
	static enum enum_e {
		A, B
	}

	public static void main(String[] args) {
		// byte
		byte 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;
		}
		// char
		char 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;
		}
		// short
		short short_n = 0;
		switch (short_n) {
		case 0:
			System.out.println("short 可以用于 switch 语句");
			break;
		}
		// Short
		Short short_m = 0;
		// 需要 Java5.0(1.5)以上版本支持
		switch (short_m) {
		case 0:
			System.out.println("Short 类可以用于 switch 语句");
			System.out.println();
			break;
		}
		// int
		int 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;
		}
		// long
		long 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;
		// }
		// float
		float 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;
		// }
		// double
		double 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;
		// }
		// boolean
		boolean 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. 4. char 可以用于 switch 语句 5. Character 类可以用于 switch 语句 6. 7. short 可以用于 switch 语句 8. Short 类可以用于 switch 语句 9. 10. int 可以用于 switch 语句 11. Integer 类可以用于 switch 语句 12. 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 语句。



联系我们 | 友情链接