- 浏览: 81030 次
- 性别:
- 来自: 成都
最新评论
-
cfczdws:
唉,还有好多要学~~
css 文档流 父级对象 同级对象 -
chinalitianwu:
很有帮助 对于我这样的菜鸟来说
ServletContext与ApplicationContext -
gaoddhan:
讲的不错
hashcode 和equal -
bestree007:
execute()不是回调函数吗?
回调函数 -
talin2010:
真的很详细
JSP/Servlet编码设置详解
转自:http://zangweiren.iteye.com/blog/219369
基本类型,或者叫做内置类型,是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型,因此面试题中也总少不了它们的身影,在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。
基本类型共有九种,它们分别都有相对应的包装类。关于它们的详细信息请看下表:
[img]http://zangweiren.iteye.com/upload/picture/pic/18450/8071c6c2-7cfb-3783-829a-a6abb3ae55e5.jpg [/img]
对于基本类型void以及它的包装类java.lang.Void,我们都无法直接进行操作。基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。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);
}
}
运行结果:
基本类型:byte 二进制位数:8
包装类:java.lang.Byte
最小值:Byte.MIN_VALUE=-128
最大值:Byte.MAX_VALUE=127
基本类型:short 二进制位数:16
包装类:java.lang.Short
最小值:Short.MIN_VALUE=-32768
最大值:Short.MAX_VALUE=32767
基本类型:int 二进制位数:32
包装类:java.lang.Integer
最小值:Integer.MIN_VALUE=-2147483648
最大值:Integer.MAX_VALUE=2147483647
基本类型:long 二进制位数:64
包装类:java.lang.Long
最小值:Long.MIN_VALUE=-9223372036854775808
最大值:Long.MAX_VALUE=9223372036854775807
基本类型:float 二进制位数:32
包装类:java.lang.Float
最小值:Float.MIN_VALUE=1.4E-45
最大值:Float.MAX_VALUE=3.4028235E38
基本类型:double 二进制位数:64
包装类:java.lang.Double
最小值:Double.MIN_VALUE=4.9E-324
最大值:Double.MAX_VALUE=1.7976931348623157E308
基本类型:char 二进制位数:16
包装类:java.lang.Character
最小值:Character.MIN_VALUE=0
最大值: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修饰,因此我们无法继承它们扩展新的类,也无法重写它们的任何方法。
各种数值类型之间的赋值与转换遵循什么规律呢?我们来看下面这个例子:
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;
}
}
从上面的例子中我们可以得出如下几条结论:
未带有字符后缀标识的整数默认为int类型;未带有字符后缀标识的浮点数默认为double类型。
如果一个整数的值超出了int类型能够表示的范围,则必须增加后缀“L”(不区分大小写,建议用大写,因为小写的L与阿拉伯数字1很容易混淆),表示为long型。
带有“F”(不区分大小写)后缀的整数和浮点数都是float类型的;带有“D”(不区分大小写)后缀的整数和浮点数都是double类型的。
编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查,如果超出了它们的取值范围就会报错。
int型值可以赋给所有数值类型的变量;long型值可以赋给long、float、double类型的变量;float型值可以赋给float、double类型的变量;double型值只能赋给double类型变量。
下图显示了几种基本类型之间的默认逻辑转换关系:
图中的实线表示无精度损失的转换,而虚线则表示这样的转换可能会损失一定的精度。如果我们想把一个能表示更大范围或者更高精度的类型,转换为一个范围更小或者精度更低的类型时,就需要使用强制类型转换(Cast)了。不过我们要尽量避免这种用法,因为它常常引发错误。请看下面的例子,如果不运行代码,你能预测它的结果吗?
public class PrimitiveTypeTest {
public static void main(String[] args) {
int a = 123456;
short b = (short) a;
// b的值会是什么呢?
System.out.println(b);
}
}
运行结果:
-7616
运算符对基本类型的影响
当使用+、-、*、/、%运算符对基本类型进行运算时,遵循如下规则:
只要两个操作数中有一个是double类型的,另一个将会被转换成double类型,并且结果也是double类型;
否则,只要两个操作数中有一个是float类型的,另一个将会被转换成float类型,并且结果也是float类型;
否则,只要两个操作数中有一个是long类型的,另一个将会被转换成long类型,并且结果也是long类型;
否则,两个操作数(包括byte、short、int、char)都将会被转换成int类型,并且结果也是int类型。
当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时,遵循如下规则:
运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型,然后再执行运算,且运算结果与运算符左边数值类型相同。
了解了这些,我们就能解答下面这个常考的面试题了。请看:
引用
short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错?
乍一看,觉得它们都应该没有错误,可以正常运行。我们来写个例子试试:
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,所以不会报错。前面讲过了,对基本类型执行强制类型转换可能得出错误的结果,因此在使用+=、-=、*=、/=、%=等运算符时,要多加注意。
当使用“==”运算符在基本类型和其包装类对象之间比较时,遵循如下规则:
只要两个操作数中有一个是基本类型,就是比较它们的数值是否相等。
否则,就是判断这两个对象的内存地址是否相等,即是否是同一个对象。
下面的测试例子则验证了以上的规则:
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));
}
}
运行结果:
int_int == int_Integer结果是:true
Integer_Integer == Integer_int结果是:false
int_int == Integer_Integer结果是:true
Integer_Integer == int_int结果是:true
boolean_boolean == boolean_Boolean结果是:true
Boolean_Boolean == Boolean_boolean结果是:false
boolean_boolean == Boolean_Boolean结果是:true
Boolean_Boolean == boolean_boolean结果是:true
为了便于查看,上例中变量命名没有采用规范的方式,而是采用了“变量类型”+“_”+“初始化值类型”的方式。
Math.round()方法
java.lang.Math类里有两个round()方法,它们的定义如下:
public static int round(float a) {
//other code
}
public static long round(double a) {
//other code
}
它们的返回值都是整数,且都采用四舍五入法。运算规则如下:
如果参数为正数,且小数点后第一位>=5,运算结果为参数的整数部分+1。
如果参数为负数,且小数点后第一位>5,运算结果为参数的整数部分-1。
如果参数为正数,且小数点后第一位<5;或者参数为负数,且小数点后第一位<=5,运算结果为参数的整数部分。
我们可以通过下面的例子来验证:
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));
}
}
运行结果:
小数点后第一位=5
正数:Math.round(11.5)=12
负数:Math.round(-11.5)=-11
小数点后第一位<5
正数:Math.round(11.46)=11
负数:Math.round(-11.46)=-11
小数点后第一位>5
正数:Math.round(11.68)=12
负数:Math.round(-11.68)=-12
根据上面例子的运行结果,我们还可以按照如下方式总结,或许更加容易记忆:
参数的小数点后第一位<5,运算结果为参数整数部分。
参数的小数点后第一位>5,运算结果为参数整数部分绝对值+1,符号(即正负)不变。
参数的小数点后第一位=5,正数运算结果为整数部分+1,负数运算结果为整数部分。
但是上面的结论仍然不是很好记忆。我们来看看round()方法的内部实现会给我们带来什么启发?我们来看这两个方法内部的代码:
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语句的判断呢?我们做个测试就知道了:
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;
}
}
}
运行结果如下:
byte可以用于switch语句
Byte类可以用于switch语句
char可以用于switch语句
Character类可以用于switch语句
short可以用于switch语句
Short类可以用于switch语句
int可以用于switch语句
Integer类可以用于switch语句
enum可以用于switch语句-A
结果已经出来了,我们来总结一下:
byte、char、short、int四种基本类型以及它们的包装类(需要Java5.0/1.5以上版本支持)都可以用于switch语句。
long、float、double、boolean四种基本类型以及它们的包装类(在Java所有版本中)都不能用于switch语句。
enum类型,即枚举类型可以用于switch语句,但是要在Java5.0(1.5)版本以上才支持。
所有类型的对象(包括String类,但在Java5.0/1.5以上版本中,该项要排除byte、char、short、int四种基本类型对应的包装类)都不能用于switch语句。
基本类型,或者叫做内置类型,是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型,因此面试题中也总少不了它们的身影,在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。
基本类型共有九种,它们分别都有相对应的包装类。关于它们的详细信息请看下表:
[img]http://zangweiren.iteye.com/upload/picture/pic/18450/8071c6c2-7cfb-3783-829a-a6abb3ae55e5.jpg [/img]
对于基本类型void以及它的包装类java.lang.Void,我们都无法直接进行操作。基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。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);
}
}
运行结果:
基本类型:byte 二进制位数:8
包装类:java.lang.Byte
最小值:Byte.MIN_VALUE=-128
最大值:Byte.MAX_VALUE=127
基本类型:short 二进制位数:16
包装类:java.lang.Short
最小值:Short.MIN_VALUE=-32768
最大值:Short.MAX_VALUE=32767
基本类型:int 二进制位数:32
包装类:java.lang.Integer
最小值:Integer.MIN_VALUE=-2147483648
最大值:Integer.MAX_VALUE=2147483647
基本类型:long 二进制位数:64
包装类:java.lang.Long
最小值:Long.MIN_VALUE=-9223372036854775808
最大值:Long.MAX_VALUE=9223372036854775807
基本类型:float 二进制位数:32
包装类:java.lang.Float
最小值:Float.MIN_VALUE=1.4E-45
最大值:Float.MAX_VALUE=3.4028235E38
基本类型:double 二进制位数:64
包装类:java.lang.Double
最小值:Double.MIN_VALUE=4.9E-324
最大值:Double.MAX_VALUE=1.7976931348623157E308
基本类型:char 二进制位数:16
包装类:java.lang.Character
最小值:Character.MIN_VALUE=0
最大值: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修饰,因此我们无法继承它们扩展新的类,也无法重写它们的任何方法。
各种数值类型之间的赋值与转换遵循什么规律呢?我们来看下面这个例子:
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;
}
}
从上面的例子中我们可以得出如下几条结论:
未带有字符后缀标识的整数默认为int类型;未带有字符后缀标识的浮点数默认为double类型。
如果一个整数的值超出了int类型能够表示的范围,则必须增加后缀“L”(不区分大小写,建议用大写,因为小写的L与阿拉伯数字1很容易混淆),表示为long型。
带有“F”(不区分大小写)后缀的整数和浮点数都是float类型的;带有“D”(不区分大小写)后缀的整数和浮点数都是double类型的。
编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查,如果超出了它们的取值范围就会报错。
int型值可以赋给所有数值类型的变量;long型值可以赋给long、float、double类型的变量;float型值可以赋给float、double类型的变量;double型值只能赋给double类型变量。
下图显示了几种基本类型之间的默认逻辑转换关系:
图中的实线表示无精度损失的转换,而虚线则表示这样的转换可能会损失一定的精度。如果我们想把一个能表示更大范围或者更高精度的类型,转换为一个范围更小或者精度更低的类型时,就需要使用强制类型转换(Cast)了。不过我们要尽量避免这种用法,因为它常常引发错误。请看下面的例子,如果不运行代码,你能预测它的结果吗?
public class PrimitiveTypeTest {
public static void main(String[] args) {
int a = 123456;
short b = (short) a;
// b的值会是什么呢?
System.out.println(b);
}
}
运行结果:
-7616
运算符对基本类型的影响
当使用+、-、*、/、%运算符对基本类型进行运算时,遵循如下规则:
只要两个操作数中有一个是double类型的,另一个将会被转换成double类型,并且结果也是double类型;
否则,只要两个操作数中有一个是float类型的,另一个将会被转换成float类型,并且结果也是float类型;
否则,只要两个操作数中有一个是long类型的,另一个将会被转换成long类型,并且结果也是long类型;
否则,两个操作数(包括byte、short、int、char)都将会被转换成int类型,并且结果也是int类型。
当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时,遵循如下规则:
运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型,然后再执行运算,且运算结果与运算符左边数值类型相同。
了解了这些,我们就能解答下面这个常考的面试题了。请看:
引用
short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错?
乍一看,觉得它们都应该没有错误,可以正常运行。我们来写个例子试试:
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,所以不会报错。前面讲过了,对基本类型执行强制类型转换可能得出错误的结果,因此在使用+=、-=、*=、/=、%=等运算符时,要多加注意。
当使用“==”运算符在基本类型和其包装类对象之间比较时,遵循如下规则:
只要两个操作数中有一个是基本类型,就是比较它们的数值是否相等。
否则,就是判断这两个对象的内存地址是否相等,即是否是同一个对象。
下面的测试例子则验证了以上的规则:
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));
}
}
运行结果:
int_int == int_Integer结果是:true
Integer_Integer == Integer_int结果是:false
int_int == Integer_Integer结果是:true
Integer_Integer == int_int结果是:true
boolean_boolean == boolean_Boolean结果是:true
Boolean_Boolean == Boolean_boolean结果是:false
boolean_boolean == Boolean_Boolean结果是:true
Boolean_Boolean == boolean_boolean结果是:true
为了便于查看,上例中变量命名没有采用规范的方式,而是采用了“变量类型”+“_”+“初始化值类型”的方式。
Math.round()方法
java.lang.Math类里有两个round()方法,它们的定义如下:
public static int round(float a) {
//other code
}
public static long round(double a) {
//other code
}
它们的返回值都是整数,且都采用四舍五入法。运算规则如下:
如果参数为正数,且小数点后第一位>=5,运算结果为参数的整数部分+1。
如果参数为负数,且小数点后第一位>5,运算结果为参数的整数部分-1。
如果参数为正数,且小数点后第一位<5;或者参数为负数,且小数点后第一位<=5,运算结果为参数的整数部分。
我们可以通过下面的例子来验证:
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));
}
}
运行结果:
小数点后第一位=5
正数:Math.round(11.5)=12
负数:Math.round(-11.5)=-11
小数点后第一位<5
正数:Math.round(11.46)=11
负数:Math.round(-11.46)=-11
小数点后第一位>5
正数:Math.round(11.68)=12
负数:Math.round(-11.68)=-12
根据上面例子的运行结果,我们还可以按照如下方式总结,或许更加容易记忆:
参数的小数点后第一位<5,运算结果为参数整数部分。
参数的小数点后第一位>5,运算结果为参数整数部分绝对值+1,符号(即正负)不变。
参数的小数点后第一位=5,正数运算结果为整数部分+1,负数运算结果为整数部分。
但是上面的结论仍然不是很好记忆。我们来看看round()方法的内部实现会给我们带来什么启发?我们来看这两个方法内部的代码:
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语句的判断呢?我们做个测试就知道了:
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;
}
}
}
运行结果如下:
byte可以用于switch语句
Byte类可以用于switch语句
char可以用于switch语句
Character类可以用于switch语句
short可以用于switch语句
Short类可以用于switch语句
int可以用于switch语句
Integer类可以用于switch语句
enum可以用于switch语句-A
结果已经出来了,我们来总结一下:
byte、char、short、int四种基本类型以及它们的包装类(需要Java5.0/1.5以上版本支持)都可以用于switch语句。
long、float、double、boolean四种基本类型以及它们的包装类(在Java所有版本中)都不能用于switch语句。
enum类型,即枚举类型可以用于switch语句,但是要在Java5.0(1.5)版本以上才支持。
所有类型的对象(包括String类,但在Java5.0/1.5以上版本中,该项要排除byte、char、short、int四种基本类型对应的包装类)都不能用于switch语句。
发表评论
-
java浅克隆和深克隆的定义
2011-02-27 17:42 1150转自: http://wxg6203.iteye.co ... -
Java 异常类别
2010-07-15 21:34 893java中的所有异常都继承java.lang.Throwabl ... -
回调函数
2010-05-17 11:14 1120转自: http://summerbell.itey ... -
Java 反射
2010-04-20 16:01 1162转自:http://summernight.iteye.com ... -
深入探讨类加载器
2010-04-20 11:33 751转自:http://www.ibm.com/developer ... -
Java内部类可见性
2010-04-20 10:27 1073转自:http://zhangjunhd.blog.51cto ... -
Hashtable和HashMap的区别
2010-04-20 10:14 1285转自:http://edu.codepub.com/2009/ ... -
hashcode 和equal
2010-04-20 10:10 1265转自:http://lawrenst.iteye.com/bl ... -
运算符
2010-04-20 09:42 985转自:http://zangweiren.itey ... -
多线程
2010-04-20 09:40 874转自:http://zangweiren.iteye.com/ ... -
继承、多态、重载和重写
2010-04-20 09:37 982转自:http://zangweiren.itey ... -
日期和时间的处理
2010-04-19 22:54 810转自:http://zangweiren.iteye.com/ ... -
String杂谈
2010-04-19 18:51 744转自:http://zangweiren.iteye.com/ ... -
传了值还是传了引用
2010-04-19 18:40 639转自:http://zangweiren.iteye.com/ ... -
final finally和 finalize的区别
2010-04-19 18:32 990转自:http://zangweiren.iteye.com/ ... -
到底创建了几个String对象
2010-04-19 18:15 739转自:http://zangweiren.iteye.com/ ... -
类的初始化顺序
2010-04-19 17:42 448转自: http://zangweiren.iteye.com ... -
path,classpath,java_home设置详解
2010-04-19 10:31 3594转自于: http://blog.csdn.net/yinyu ...
相关推荐
在C#.NET编程环境中,基本类型是语言支持的原始数据类型,它们是构建程序的基础。这些类型具有固定的大小和预定义的行为,可以直接在代码中使用,而无需引用任何特定的库。C#.NET中的基本类型包括数值类型、布尔类型...
### Java中的基本类型与String类型详解 在Java编程语言中,数据类型分为两大类:基本类型(primitive types)和引用类型。基本类型直接存储值,而引用类型则存储指向对象的引用。本文将深入探讨Java中的基本类型...
在JavaScript编程中,理解基本类型和引用类型的区别非常重要,因为这关系到变量的存储、操作以及内存管理等核心概念。在给定的内容中,首先介绍了JavaScript中的基本数据类型和引用数据类型的定义、区别和联系,并...
将任意基本类型转换为二进制字符串的C++代码...
char short int long float double 转换成byte数组
59.java基本类型的参数传递.zip59.java基本类型的参数传递.zip59.java基本类型的参数传递.zip59.java基本类型的参数传递.zip59.java基本类型的参数传递.zip59.java基本类型的参数传递.zip59.java基本类型的参数传递....
5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型(2).zip5.java基本类型...
本文将深入探讨C#的基本类型及其在实际编程中的运用。 C#中的基本类型分为值类型和引用类型。值类型包括简单类型(如整型、浮点型、布尔型、字符型等)、枚举类型和结构类型。引用类型主要包括类、接口、数组和委托...
### Java基本类型封装详解 #### 一、基本概念与背景 在Java中,存在两种数据类型:基本数据类型和引用数据类型。基本数据类型包括`byte`、`short`、`int`、`long`、`float`、`double`、`char`以及`boolean`。这些...
C#操作Redis的5种基本类型汇总 以下是C#操作Redis的5种基本类型的知识点总结: 一、String类型 * 简介:String是Redis最基本的类型,可以理解成与Memcached一样的类型,一个key对应一个value。String类型是二进制...
数字图像处理:实验一数字图像文件基本类型的转换.ppt
### Java基本类型数据 #### 一、概述 Java是一种广泛使用的面向对象的编程语言,它在设计时就考虑到了安全性、可移植性和易用性。Java语言中的数据类型分为两大类:基本数据类型(primitive data types)和引用...
在前端开发中,理解基本类型和引用类型的概念至关重要,因为它们决定了变量如何存储、操作以及如何相互作用。让我们深入探讨这两种类型。 首先,基本类型包括Undefined、Null、Boolean、Number和String。这些类型在...
Java语言中的基本类型是编程的基础,它们不像类那样需要实例化,而是可以直接使用。Java共有九种基本类型,包括字符型(char),布尔型(boolean),以及五种数值类型(byte, short, int, long, float, double)。这些类型...
3.7_多行字符串|理解什么是写代码与Python的基本类型|Python3.8入门_&_进阶_&_原生爬虫实战完全解读
Java语言的基础知识中,类是核心概念之一,而类中的基本类型则是构建程序的基本元素。基本类型不依赖于对象,它们直接存储值,是Java内存管理的最小单位。本节主要探讨了Java中的八种基本类型及其特性。 首先,布尔...
第2章至第7章从抽象数据类型的角度,分别讨论线性表、栈、队列、串、数组、广义表、树和二叉树以及图等基本类型的数据结构及其应用;第8章综合介绍操作系统和编译程序中涉及的动态存储管理的基本技术;第9章至第11章...
Java中的基本类型是编程语言的核心组成部分,它们是不依赖于对象的原始数据类型。Java提供了九种基本类型,包括字符型(char),布尔型(boolean),以及五种数值类型(byte, short, int, long, float, double)。这些类型...
标题提到的“将字节数组转换为各种基本类型”涉及到的是字节数组与C#的基本数据类型之间的转换,如整型(int)、浮点型(float)、双精度型(double)等。下面将详细介绍这一主题,以及如何在C#中进行这些转换。 1....
在Java编程语言中,基本类型(Primitive Types)是程序设计的基础,它们不像类那样需要实例化,而是直接使用。Java的基本类型共有九种,包括两种字符类型、一种布尔类型和六种数值类型。这些类型在Java中有着至关...