2.1 数据类型
Java语言定义了八种基本数据类型，包括短整型（short）、整型（int）、长整型（long）、字节型（byte）、单精度浮点型（float）、双精度浮点型（double）、布尔型（boolean）、字符型（char）。这八种基本数据类型又可以分为以下四组。
· 整型：包括短整型（short）、整型（int）、长整型（long）、字节型（byte）。这些都是有符号的整数值。
· 浮点型：包括单精度浮点型（float）和双精度浮点型（double）。通常是在对小数精度有要求时使用，如数学计算。
· 字符型：只包括字符型（char）。代表数字或字母等字符集的符号。
· 布尔型：只包括布尔型（boolean）。有两种值“真/假”，在逻辑判断时使用。
2.1.1 整型
Java语言一共包含短整型（short）、整型（int）、长整型（long）、字节型（byte）四种整数类型。整数类型可以使用十进制、八进制、十六进制来表示，分别使用关键字short、int、long、byte进行定义。这四个整型变量的长度和值范围如表2.1所示。
表2.1 整型的长度和表示范围
这些整数类型不依赖于操作系统，在任何平台上都有相同的长度和属性。Java语言用十进制、八进制、十六进制表示整型时，采用如下所示的表示方法。
· 8表示十进制数据。
· 088表示八进制，首位以0开始。
· 0xABAC表示十六进制数据，首位以0x开始。
Java语言的整型常量默认为int型。若要声明long型常量，则可以后加“l”或“L”。下面通过一个实际程序说明整型变量的使用。首先在程序中定义多个变量，然后再输出这些变量。程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 // 代码实现
2 public class Sample2_1
3 {
4 public static void main(String[] args)
5 {
6 //定义一个名为a的整型变量，把值20赋予变量a
7 int a = 20;
8 //定义一个名为x的整型变量，把值-10赋予变量x
9 int x = -10;
10 //定义一个名为b的长整型变量，把值-100赋予变量b
11 long b = -100L;
12 //定义一个名为l的长整型变量，把值50赋予变量l
13 long l = 50l;
14 //定义一个名为c的短整型变量，把值50赋予变量c
15 short c = 50;
16 //定义一个名为y的短整型变量，把值-1赋予变量y
17 short y = -1;
18 //定义一个名为d的字节型变量，把值4赋予变量d
19 byte d = 4;
20 //定义一个名为z的字节型变量，把值0赋予变量z
21 byte z = 0;
22 //输出这些变量的值
23 System.out.println("a的值为：" + a);
24 System.out.println("x的值为：" + x);
25 System.out.println("b的值为：" + b);
26 System.out.println("l的值为：" + l);
27 System.out.println("c的值为：" + c);
28 System.out.println("y的值为：" + y);
29 System.out.println("d的值为：" + d);
30 System.out.println("z的值为：" + z);
31 }
32 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_1.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_1.java
（4）输入下面的命令，运行这个程序。
java Sample2_1
（5）程序的运行结果如图2-1所示。
图2-1 Sample2_1的编译运行结果
在定义变量时，要注意长整型的常量一般在后面使用“L”结尾。因为小写的字母“l”跟数字“1”很类似，容易混淆。非法整型变量定义的示例代码如下所示。
a = 20;
下面的代码里语句结尾应该用英文的“;”而不是中文的“;”。
long b = -100；
在使用这些整型类型时，一定要注意不可以超过其取值范围；否则，就会产生“溢出”，从而存取到其他不可预料的值。
int型变量的最大值为2147 483647，最小值为−2147 483648。接下来通过例子来说明当把2147 483647再加上1，把−2147 483648减1时会产生“溢出”的情况。程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 // 代码实现
2 public class Sample2_2
3 {
4 public static void main(String[] args)
5 {
6 //定义一个整型变量i
7 int i;
8 //定义一个整型变量k
9 int k;
10 //定义一个整型变量a
11 int a;
12 //定义一个整型变量d
13 int d;
14 //定义整型变量i，把整型变量的最大值2147 483647赋给变量i
15 i = 2147483647;
16 //定义整型变量k，把整型变量的最小值−2147 483648赋给变量k
17 k = -2147483648;
18 //把变量i的值加1，结果赋给变量a
19 a = i + 1;
20 //把变量k的值减1，结果赋给变量d
21 d = k -1;
22 //输出变量a的值
23 System.out.println(a);
24 //输出变量d的值
25 System.out.println(d);
26 }
27 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_2.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_2.java
（4）输入下面的命令，运行这个程序。
java Sample2_2
（5）程序的运行结果如图2-2所示。
图2-2 Sample2_2的编译运行结果
运行程序得到i+1的结果是−2147 483648，而不是期望得到的2147 483648。k-1的结果是2147 483647，也不是期望得到的−2147 483649。这是因为i+1和k-1的值超出了int型的边界值，发生了“溢出”。
在程序开发中要注意尽量避免这种情况的出现。产生这种错误后，程序能正常编译不报错，但执行结果是不符合要求的，这种错误很难排查。
当整型类型表示不了很大的整数时，就需要用长度为64位的长整型。尤其对于程序中需要计算很大的数值时，长整型就表现得非常有用了。
例如，计算10光年是多少米就需要用到长整型来表示距离。程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 //代码实现
2 public class Sample2_3
3 {
4 public static void main(String[] args)
5 {
6 //定义一个整型变量表示光速
7 int lightSpeed;
8 //定义一个整型变量表示秒数
9 long seconds;
10 //定义一个长整型变量表示光传播的距离
11 long dis;
12 //光速
13 lightSpeed = 300000000;
14 //计算10年的秒数
15 seconds = 10 * 365 * 24 * 60 * 60;
16 //计算10光年的距离
17 dis = lightSpeed * seconds;
18 System.out.println("十光年大约为"+ dis + "米");
19 }
20 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_3.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_3.java
（4）输入下面的命令，运行这个程序。
java Sample2_3
（5）程序的运行结果如图2-3所示。
图2-3 Sample2_3的编译运行结果
运算结果已经超过了int型的最大值2147 483647，需要用长整型来表示。
2.1.2 浮点型
浮点型包括单精度浮点型（float）和双精度浮点型（double）两种类型。浮点型使用关键字float、double声明。浮点型也是平台无关性的，在任何操作系统上都有相同的长度和取值范围，如表2.2所示。
表2.2 浮点型的长度及取值范围
在数字后带有字母F或f（float）、D或d（double），或者一个数字包括小数点或指数部分则该数字为浮点类型。如果某个浮点值没有使用float关键字定义为float类型，则系统默认其类型为double型。
Java浮点类型常量有两种表示形式：十进制数形式和科学计数法形式。其中十进制数形式必须含有小数点，例如2.13、34.0；科学计数法形式，例如3.54e2、2.7E2、514E2。具体例子如下所示。
· 2.56。一个浮点值，系统默认其为double型。
· 5.14E18。使用科学计数法表示浮点数，系统默认其为double型。
· 1.245F。一个float类型的浮点值。
· 1.356E+240D。使用科学计数法表示一个大的double类型浮点数。
接下来通过一个程序来说明浮点型的使用方法。在该程序中，首先定义了一些浮点变量，然后对其进行赋值，输出这些变量的值。程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 //代码实现
2 public class Sample2_4
3 {
4 public static void main(String[] args)
5 {
6 //定义一个名为a的单精度变量
7 float a;
8 //定义一个名为b的单精度变量
9 float b;
10 //定义一个名为c的双精度变量
11 double c;
12 //定义一个名为d的双精度变量
13 double d;
14 //把值20.1赋予变量a
15 a = 20.1f;
16 //把值-10.13455赋予变量b
17 b = -10.13455f;
18 //把值-100.64656赋予变量c
19 c = -100.64656;
20 //把值3.27赋予变量d
21 d = 3.27;
22 //输出这些变量的值
23 System.out.println("a的值为：" + a);
24 System.out.println("b的值为：" + b);
25 System.out.println("c的值为：" + c);
26 System.out.println("d的值为：" + d);
27 }
28 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_4.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_4.java
（4）输入下面的命令，运行这个程序。
java Sample2_4
（5）程序的运行结果如图2-4所示。
图2-4 Sample2_4的编译运行结果
定义单精度浮点数时，不能写成类似float a = 20.1这种形式，需要在值后面加上“f”或“F”，因为小数常量默认为double类型。把长度为8位的double型常量赋给一个长度为4位的float变量显然是错误的。在实际的操作中，尤其是数学计算或需要经过多次计算才能得出结果，并且对结果的精度要求比较高的情况下，通常使用双精度型。
例如，计算一个角度为60°、半径为12.15cm扇形的面积。计算的结果就需要使用双精度浮点型来表示。程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 //代码实现
2 public class Sample2_5
3 {
4 public static void main(String[] args)
5 {
6 //定义一个双精度浮点变量pi，表示圆周率
7 double pi;
8 //定义一个双精度浮点变量r，表示半径
9 double r;
10 //定义一个双精度浮点变量squ，表示面积
11 double squ;
12 //把值3.141593赋给变量pi
13 pi = 3.141593;
14 //把值12.15赋给变量r
15 r = 12.15;
16 //计算面积，把计算的结果赋给变量squ
17 squ = pi * r * r * 60/360;
18 //输出面积
19 System.out.println(squ);
20 }
21 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_5.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_5.java
（4）输入下面的命令，运行这个程序。
java Sample2_5
（5）程序的运行结果如图2-5所示。
图2-5 Sample2_5的编译运行结果
2.1.3 字符型
字符型（char）可表示通常意义上的单个字符。Java字符采用Unicode编码。Unicode是一种字符编码方式，可以跨语言、跨平台进行文本转换。每个字符占两个字节。Java语言里char的表示范围为0～65536，包含了ASCII码（一种字符编码方式，表示范围为0～127）。下面的程序演示了char字符类型的使用。程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 // 代码实现
2 public class Sample2_6
3 {
4 public static void main(String[] args)
5 {
6 //定义一个字符型变量c1
7 char c1;
8 //定义一个字符型变量c2
9 char c2;
10 //把值66赋给变量c1
11 c1 = 66;
12 //把值'z'赋给变量c2
13 c2 = 'z';
14 System.out.println("输出c1和c2：");
15 System.out.print(c1 + " " + c2);
16 }
17 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_6.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_6.java
（4）输入下面的命令，运行这个程序。
java Sample2_6
（5）程序的运行结果如图2-6所示。
图2-6 Sample2_6的编译运行结果
可以看到程序中把值66赋给了c1，输出的时候c1却变成了“B”。这是因为值66在Unicode编码中代表了“B”，需要注意的是大写的字母B和小写的字母b值是不一样的。
因为字符所代表的值都是整数，所以可以对字符进行相加操作。还可以对字符常量进行增量操作。通过运算后就会得出另外的一个字符。示例程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 // 代码实现
2 public class Sample2_7
3 {
4 public static void main(String[] args)
5 {
6 //定义一个字符型变量c1
7 char c1;
8 //把值'm'赋给变量c1
9 c1 = 'm';
10 System.out.println("c1的值为：" + c1);
11 //自增运算，表示把c1+1
12 c1++;
13 System.out.println("c1+1后为：" + c1);
14 }
15 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_7.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_7.java
（4）输入下面的命令，运行这个程序。
java Sample2_7
（5）程序的运行结果如图2-7所示。
图2-7 Sample2_7的编译运行结果
该程序中字符“m”对应的Unicode编码值为109，加1后就变为110，110对应Unicode编码里的字符为“n”。
2.1.4 布尔型
布尔型是Java里用来表示逻辑值的数据类型。其值只能是真或假这两个值其中的一个。它是所有关系运算的返回类型。示例程序的编写方法和步骤如下所示。
（1）新建一个文本文档，用记事本程序打开该文档并输入下面的程序。
1 // 代码实现
2 public class Sample2_8
3 {
4 public static void main(String[] args)
5 {
6 //定义一个布尔型变量a
7 boolean a
8 //定义一个布尔型变量b
9 boolean b;
10 //把值true赋给变量a
11 a = true;
12 //把值false赋给变量b
13 b = false;
14 //输出
15 System.out.println("a is " + a);
16 System.out.println("b is " + b);
17 }
18 }
（2）单击“文件”|“保存”命令，保存这个文件。并把文件重命名为Sample2_8.java。
（3）打开命令提示符窗口，然后输入下面的命令并按“Enter”键编译程序。
javac Sample2_8.java
（4）输入下面的命令，运行这个程序。
java Sample2_8
（5）程序的运行结果如图2-8所示。
图2-8 Sample2_8的编译运行结果