基本类型，或者叫做内置类型，是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中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：
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修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。
各种数值类型之间的赋值与转换遵循什么规律呢？我们来看下面这个例子：
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;
}
}
从上面的例子中我们可以得出如下几条结论：
未带有字符后缀标识的整数默认为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）了。不过我们要尽量避免这种用法，因为它常常引发错误。请看下面的例子，如果不运行代码，你能预测它的结果吗？
Java代码
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;有什么错？
乍一看，觉得它们都应该没有错误，可以正常运行。我们来写个例子试试：
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，所以不会报错。前面讲过了，对基本类型执行强制类型转换可能得出错误的结果，因此在使用+=、-=、*=、/=、%=等运算符时，要多加注意。
当使用“==”运算符在基本类型和其包装类对象之间比较时，遵循如下规则：
只要两个操作数中有一个是基本类型，就是比较它们的数值是否相等。
否则，就是判断这两个对象的内存地址是否相等，即是否是同一个对象。
下面的测试例子则验证了以上的规则：
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));
}
}
运行结果：
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()方法，它们的定义如下：
Java代码
public static int round(float a) {
//other code
}
public static long round(double a) {
//other code
}
它们的返回值都是整数，且都采用四舍五入法。运算规则如下：
如果参数为正数，且小数点后第一位>=5，运算结果为参数的整数部分+1。
如果参数为负数，且小数点后第一位>5，运算结果为参数的整数部分-1。
如果参数为正数，且小数点后第一位<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));
}
}
运行结果：
小数点后第一位=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()方法的内部实现会给我们带来什么启发？我们来看这两个方法内部的代码：
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;
}
}
}
运行结果如下：
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语句。
转载：
作者：臧圩人（zangweiren）
网址：http://zangweiren.iteye.com
分享到：
发表评论
相关推荐
将解释这个字节码并基本上运行程序。 强类型：声明为某种类型的变量只能分配给它相同类型的值 好处 平台无关（一次编写，随处运行） C 语言启发式语法 自动内存管理：在垃圾收集器的帮助下完成 广泛的内置运行时库 ...
C#学习笔记(2)【大 中 小】【打印】【加入收藏】【关闭】 【收藏到新浪ViVi】【收藏到365KEY】 浏览字号:日期：2004-07-11 人气：8092 出处： write by cash(天下第七) 2002.01.20 版权所有，翻录不究 cashcao@...
链接在观看它的行动特征查看每个神奇宝贝的基本信息根据地区和类型过滤神奇宝贝按 ID/名称对 Pokémon 进行排序按名字/ID搜索神奇宝贝暗模式切换滚动到顶部延迟加载图片响应式设计快照演示 gif内置React材质界面精灵...
这是2003年得一个作品，陆续做了基本得功能，当初做这个只是一时性起，帮朋友讲解树型得数据结构，并写了个简单得例子，但后来还是作成一个软件。该程序功能已经实现，并且可以正常使用，但是‘最爱’收藏夹还有一些...
会员鲜花功能 收藏夹功能 积分等级 模块功能 Modoer系统以模块为基础组成 可以Modoer为平台开发安装模块 高级数据调用 利用内置的函数和SQL调用方式调用数据 可设置每个调用的模板和空数据的模板 调用数据可设置缓存...
1 美工采用了css风格设计内置7种皮肤（由青创网络提供） 2 添加了收藏功能 3 添加了相关关键字 4 优化分页结构 5 总后台添加了管理类型分类 6 总后台添加了网站基本设置
博客的兴起，让更多的人在网络上，建起了展示自己的空间，同时更多的人愿意在网络上，分享个人的心情日记，个人收藏，这些都是普通的博客内容。 本次论文的目的制作网络日记本，我们要实现网络日记本的增加、删除、...
1.4.我的收藏：会员可以选择某件喜爱的进行收藏，方便下次登录时直接购买。 1.5.我的积分：会员购物时可以累积一定积分(积分管理员后台设定)，一定的积分可以兑换相关商品或奖品。 1.6.我的订单：用于查看会员自己...
·标签系统支持用户自定义，您可以自己定义标签，当然系统内置的多达数百个的标签基本上可以胜任所有的工作。·专业智能化的模版编辑环境，支持代码染色，标签库，可以让插入标签的工作变得简单而直接。·成熟的模版...
·标签系统支持用户自定义，您可以自己定义标签，当然系统内置的多达数百个的标签基本上可以胜任所有的工作。 ·专业智能化的模版编辑环境，支持代码染色，标签库，可以让插入标签的工作变得简单而直接。 ·成熟的...
0.5秒极速启动，将查词与翻译融合，提供便捷、简单、准确的查词及翻译服务，专注提升用户查词体验，重新设计单词释义的排版，用户可定制释义类型，调整释义显示顺序，重新设计每日一句界面，增加点赞及评论功能，...
查找/搜索校友信息，导出校友信息，网站标签，站内消息、等上百项基本校友录操作。 最重要的是，我们秉承软件既是服务的理念，提供全程技术保障和售后服务。 【系统安装】 1) 所有文件上传所有文件至您的...
115 <br>0192 如何获取“我的文档”系统文件夹路径 115 <br>0193 如何获取应用程序当前执行的路径 116 <br>0194 如何获取当前操作系统的信息 116 <br>0195 如何实现基本数据类型随意转换 116...
Demo名称：基本地图功能 文件名： MapViewBaseDemoViewController.mm 简介：创建一张百度地图并管理地图的生命周期 详述： （1）创建一张最简单的百度地图； （2）管理地图的生命周期，具体请参看代码部分的相关...
【查找与替换】 增强型EXCEL内置查找与替换功能。可以按设置搜索任何字符串（包括*或?符以及公式中包含的某字符)，也可以将搜索结果写入到一新的工作表中以备查。 【工具箱选项】 集成工具箱的基本选项设置。基本...
【查找与替换】 增强型EXCEL内置查找与替换功能。可以按设置搜索任何字符串（包括*或?符以及公式中包含的某字符)，也可以将搜索结果写入到一新的工作表中以备查。 【工具箱选项】 集成工具箱的基本选项设置。基本...
PHP内置了许多已定义的变量。你也可以用define函数定义你自己的常量，比如define("CONSTANT","value")。 2.6 运算符 PHP具有C,C++和Java中的通常见到的运算符。这些运算符的优先权也是一致的。赋值同样使用"="。 ...
网站基本信息配置、顶部菜单、首页FLASH展示管理、滚动公告管理、列表公告管理、热点推荐、广告设置、在线客服、友情链接、留言反馈、帮助信息、缺货登记、管理投票等…… [网域服装网店网站模板下载服装网站源码...
分类： C++ GUI Programming with Qt 4 2007-05-29 21:52 8228人阅读 评论(3) 收藏 举报 要在绘图设备（paint device，一般是一个控件）上开始绘制，我们只要创建一个QPainter，把绘图设备指针传给QPainter对象。...