Java程序设计（Java9版）：第2章 数据类型与运算符（Data types and Operators）

第2章 数据类型与运算符（Data types and Operators）

I think everybody in this country should learn how to program a computer because it teaches you how to think. —Steve Jobs

学习要求： 掌握Java标识符与注释 掌握Java语言8种基本数据类型 理解变量 掌握基本运算 掌握运算优先级

2.1 标识符

标识符，标识的符号，就是用来表示类名、变量名、方法名、数组名文件名等名称的符号。特别强调，Java语言与C语言一样，标识符是区分大写的。 Java标识符规则：Java中的类名、变量名、方法名等标识符由数字、字母、下划线、$组成，不能以数字开头，不能使用Java关键字，更不能有空格。 在定义标识符时，建议遵守以下“潜规则”： 1、尽量做到“见名知义”，增加程序可读性。比如age表示年龄、sum表示求和等等； 2、类名首字母大写，变量名、方法名首字母小写，常量名大写； 3、避免出现“外形相似”易混淆的字符，如： 0（数字）、O（大写字母）、o(小写字母)； 1（数字）、I（大写字母）、l(L的小写字母)； 比如：x0(数字)与xO（大写字母），11(数字十一)与1l(后一个字符是小写L)，容易产生误读。

Java关键字是一类系统预先定义好的标识符，也称为保留字。用户程序中不能自定义与关键字相同的标识符。Java关键字有如下50个：abstract、assert、boolean、break 、byte、case、catch、char、class、 continue、default、do、double、else、enum、extends、false、final、finally、float、for、if、implements、import、instanceof、int、interface、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、true、try、void、volatile、while。其中，enum是Java 5新引进的。读者认识这些关键字即可，无需死记硬背。此外，goto和const也被系统保留，用户程序不能使用。 　　

我们熟悉的ASCII编码的字符占1个字节存储空间，最多可用表示256（28）个不同的字符，ASCII编码集包含了10个数字和52个大小写英文字母。Java语言使用Unicode编码，一个字符占2个字节存储空间，所以最多可以表示65536（216）个字符。Unicode字符集可以表示迄今为止人类语言的字符集，包括汉字集、希腊字母等等。显然一个汉字也是Java中的一个字符，汉字也可以表示一切合法标识符，比如变量名、方法名等。

2.2 注释

中国程序员写的代码往往有一个明显的缺陷，就是注释太少，甚至没有注释。给代码注释是一个良好的编程习惯，增加程序可读性，利于代码维护。软件编码规范建议“可读性第一，效率第二”，程序中的注释要占到代码总量的20%以上。

2.2.1 单行和多行注释

编译器在编译Java源程序时，会忽略注释内容。C语言的注释是以“/”开头，以“/”结束，可以注释一到多行；C++引入单行注释“//”，即是一行中从“//”开始后面的内容为注释。 Java继承了C语言的多行注释和C++的单行注释，使用上相同。在第1章的HelloWord.java代码中已经使用了单行注释和多行注释 。

2.2.2 文档注释

此外Java语言还具有一种更为实用的注释，称为文档注释，以符号“/*”开始，以符号“/”结束的注释即是文档注释，文档注释会被文档工具读取。这里还用不到文档注释，我们将在方法定义章节讲解并使用文档注释。

2.3 基本数据类型

C语言是一种强类型语言，即是每个数据、变量和表达式在编译时就确定其数据类型，所以变量必须先声明再使用。强类型语言可以在程序编译时进行必要的数据类型语法检查，尽量减少程序错误。在C语言基础上发展而来的C++、Java、C#等编程语言也属于强类型语言。

如图2.1所示，Java语言有8种基本数据类型，分为4类：逻辑型、字符型、整数型、小数型。

下面是SUN公司对Java8种基本数据类型的定义

2.3.1 整数型

C语言中整型数据所占内存空间由具体的编译器来决定，比如int型数据在TC2中占2个字节空间而在VC++环境中占4个字节的空间。数据所在存储空间没有统一标准，这给C语言程序的可移植性带来一定的困难。 Java数据类型克服了这一不足，所有基本数据类型所在存储空间有唯一的标准，为程序移植带来方便。Java的整数型数据有4种，都是有符号整数，Java不提供无符号整数类型。具体参数如表2.1所示。

表2.1 四种整数型

Java中整数常量，比如“1”，默认数据类型是十进制的int型。与C语言一样，八进制数以0开头，十六进制数以0x或0X开头。一般编程语言的整数是不提供二进制数形式的，最新的Java 7有了突破，整型类型数据可以用二进制数形式来表示了，在二进制数值前加0b或0B即可。 一个整数常量后带有L或者l，则表示long型数据。在特殊情况下，我们会遇到超过long型范围的整数，C++通过long long类型来解决，Java中专门提供了一个类，后面详述。此外，4种整数类型都是有一定范围的，如果数值较大，则可能出现数据溢出。 例1：测试整数常量的八进制、十六进制和二进制三种形式，以及整数溢出问题。

[root@centos ~]# jshell
|  Welcome to JShell -- Version 9.0.1
|  For an introduction type: /help intro

jshell> int x=010  //八进制
x ==> 8

jshell> System.out.println(x)  //输出变量值
8

jshell> int y=0x10   //十六进制
y ==> 16

jshell> int i=0b11  //二进制
i ==> 3

jshell> byte max=127  //byte最大值
max ==> 127

jshell> System.out.println(++max)  //数据溢出
-128

从运行结果可以发现，对于byte型最大值127，自加1后结果溢出，溢出值为byte的最小值-128。 对于其他的3种整数类型也有对应结果。

提示： 在Jshell中，不需要使用分号来终止语句。 工具将为你插入缺少的分号。

2.3.2 小数型

小数也称为实数。在小学初中时，我们就学习过小数和科学计数法。比如-11000可以记作-1.1×104 ，0.000011记作1.1×10-5 。在计算机中，不方便表示上标指数（Exponent），可以将科学计数法写成E形式。比如-1.1×104 = -1.1E4，1.1×10-5=1.1E-5，其中E表示指数（Exponent），后面的数字表示指数值。 在计算机系统的发展过程中，曾经提出过多种方法表示小数。最为典型的就是定点数和浮点数。定点数的小数点固定在实数所有数字中间的某个位置，比如99元人民币就可以使用2位固定的小数表达：￥99.00。 定点数简单但是形式过于僵硬，不利于表示特别大的数或者特别小的数。后来，计算机系统采纳了浮点数表达方式。浮点数就是利用科学计数法来表达实数，即用一个尾数、一个指数和一个表示正负的符号来表达小数。比如-11000科学计数法可以表达为-1.1×104 = -1.1E4，其中-为符号位，1.1为尾数（有效数字），4为指数。浮点数利用指数达到了浮动小数点的效果，从而可以灵活地表达更大范围的实数。 C语言中可以使用单精度float和双精度double来表示浮点数，Java语言同样具体这两种类型，其长度与具体的机器无关，采用统一的科学计数法表示小数。 1、float：单精度，长度4个字节，第高位符号位，接下来8位为指数，低23位为尾数； 2、double：双精度，长度8个字节，最高位符号位，接下11位为指数，低52位为尾数； 一个实数常量的默认类型是double，无特殊要求时建议选择double类型；对于float型小数常量，需要在小数后加f或F。 例2：美国人的身高。 许多美国人固执地使用英制计量单位，比如美国人习惯用英尺英寸表示自己的身高。如果一个美国人告诉你他5英尺7英寸，那么他身高是多少米？ 已知：1英尺=12英寸=0.3048米。

jshell> int foot=5  //英尺
foot ==> 5

jshell> int inch=7  //英
inch ==> 7

jshell> double height=(foot+inch/12.0)*0.3048
height ==> 1.7018

小数和整数在计算机中存储是不同的。整数有确定的值，而小数的值是近似值，比如三分之一在计算机中无法精确表示，极少情况下会发现有限确定的小数在计算机中表示精度错误。

例3：测试小数精度问题。

jshell> System.out.println(0.01+0.01)
0.02

jshell> System.out.println(0.01+0.05)
0.060000000000000005

发现double型常量0.05与0.01的和竟然不是0.06，这就是小数精度问题的一个特例。

2.3.3 Java 7数值分隔符

Java7允许在数值常量中添加下划线。 例4：测试数值常量分隔符。

jshell> long x=1000_0011
x ==> 10000011

jshell> double y=10_000_123.000_100_1
y ==> 1.00001230001001E7

jshell> int b=0B1000_0000
b ==> 128

2.3.4 字符型

在Windows平台下，汉字的编码有多种。比如中国大陆使用国标GBK编码，而中国台湾中国香港使用的是BIG-5编码，也就是说同一个汉字编码可能不一样，大陆这边直接发送一个“你好”到中国台湾，中国台湾那边直接接收后很可能是乱码，因为两地使用的汉字编码不同。这就需要所有文字的统一编码Unicode。Unicode编码使用两个字节（16位）表示1个字符，所以Unicode编码可以表示由65536个字符构成的字符集。Unicode字符集包含了西方拉丁字母、汉字以及亚洲其他国家字符在内的世界上所有书面语言字符集。

Java语言使用Unicode字符集，char型数据使用Unicode编码，即是一个字符占2个字节的存储空间，最高位不是符号位，取值范围0~65535。比如’a’字符的Unicode码等于97。与C语言一样，Java语言使用关键字char表示字符型，字符常量使用一对单引号（”）括起来。

Java继承了C语言中的字符常量的三种表示：一般式，直接通过字符来表示，比如’a’；第二种是转义字符，如表2.2所示，Java中转义字符的语义与C语言中的转义字符相同；第三种，使用数值来表示，Java使用Unicode编码，所以Unicode值来表示字符，格式是\uXXXX，其中XXXX代表一个十六进制的整数，比如前256个字符（’\u0000’ ~ ‘\u00FF’）和ASCII码中的字符完全吻合。从这个意义上看，Java是对C语言的推广。

例5：测试char类型。

jshell> char ch='A'
ch ==> 'A'

jshell> char sex='男'
sex ==> '男'

2.3.5 逻辑型

逻辑型(boolean)，也就是布尔型，用于表示逻辑上的“真”与“假”。Java中的逻辑型值只有true和false，不能用0和1代替，这是与C语言的区别。true和false是逻辑常量(小写)，是Java关键字。逻辑型boolean占内存空间大小取决于JVM，可能以1位也可能是一个字节。boolean型值或变量主要用于程序的流程控制，在后面的程序中会看到。

2.3.6 基本类型的转换

与C语言一致，默认情况下基本数据类型（无逻辑型）可用自动向高的数据类型转换，比如char到int、byte到short、short到int、int到long、int到float、float到double。在Java语言中也有这样的类型自动转换，此外基本数据类型可以转换为字符串类型。 而高类型向低类型转换，需要通过强制转换：(类型名)转换数值，比如(int)3.14。

例6：测试基本数据类型的自动转换问题。

jshell> byte b=127
b ==> 127

jshell> b+1
$7 ==> 128

jshell> char ch='a'
ch ==> 'a'

jshell> int x=ch
x ==> 97

jshell> long i=100
i ==> 100

jshell> float f=1.0
|  Error:
|  incompatible types: possible lossy conversion from double to float
|  float f=1.0;
|          ^-^

jshell> float f=1.0f
f ==> 1.0

jshell> float f=i+1.0f
f ==> 101.0

jshell> double d=f
d ==> 101.0

jshell> "0"+1
$14 ==> "01"

jshell> 1l+11
$15 ==> 12

jshell> 

程序说明：1）变量b是byte型，在“b+1”表达式中，1是int型，b的值自动转换为int型。其次，b+1计算结果128被保存到临时变量$7。；2）当字符串”0”与1进行+运算时，int型的1自动转换为字符串“1”，+运算则表示字符串连接运行，不是数值相加；3）“System.out.println(1l+11);”是一道面试题，写出执行结果：第一个数是long型的1，后面带上l（L的小写）；第二个数是十一（11）；所以输出结果是12。

2.4 变量

变量是程序设计中一个重要的概念。Java是强类型语言，变量必须先声明再使用。方法内定义的变量，只能在本方法中使用，相当于局部变量，先赋值再使用；方法外的变量，类似于C语言的全局变量，如果没有赋值则具有默认值。Java使用Unicode编码，所以变量名和变量值都可以使用汉字。 常量是一类特殊的变量，使用关键字final定义的变量即是常量，常量名大写并且定义时赋值，因为常量值是不发生改变的。

2.5基本运算

Java中的运算符和表达式与C语言基本一致，包括赋值运算、算术运算、比较运算、逻辑运算、三目运算、自运算、位运算、类型判定等运算。运算符与运算量（数据，变量，方法等）有限次组合就是表达式。

2.5.1算术运算

算术运算包括加(+)、减(-)、乘(*)、除(/)和取模(%)运算，结合方向是从左向右。乘除和取模运算优先级高于加减。取模运算a%b的结果是a除以b的余数，余数的符号与被除数a的符号相同，比如-10%3等于-1，6%(-4)等于2。Java语言还可以对小数进行模运算，比如1.6%1.1等于0.5。读者可以自行测试。 此外，加(+)运算还可以表示字符串连接操作，前面程序已经演示过。 用数字、变量、算术运行符以及括号有限次组合的有效表达式就是算术表达式，比如：

int x=2;
double y=5.0;
y=(1+x)* y - 1.2;

(1+x)* y - 1.2就是一个算术表达式。 当两个不同类型的数据在进行算术运算时，需要特别注意结果类型，低类型会转化为高类型数据，请参考2.3.5小节内容。

例7：解析整数的各位上的数字。编写程序，针对一个四位整数（1000至9999），分解出其各位、十位、百位和千位上的数字；四位数对10取模得到的余数即是个位数，同样截取前三位数，再对10取模即可得到十位数，以此类推即可得出百位和千位数。

jshell> int n=1234
n ==> 1234

jshell> int b1,b2,b3,b4
b1 ==> 0
b2 ==> 0
b3 ==> 0
b4 ==> 0

jshell> b1=n%10; n=n/10
b1 ==> 4
n ==> 123

jshell> b2=n%10; n=n/10
b2 ==> 3
n ==> 12

jshell> b3=n%10; n=n/10;
b3 ==> 2
n ==> 1

jshell> b4=n%10;
b4 ==> 1

jshell> System.out.println(b1+","+b2+","+b3+","+b4);
4,3,2,1

2.5.2赋值运算

赋值运算符使用“=”表示，赋值运算是为变量指定值，运算方向从右向左运算。赋值运算要求两边数据类型必须匹配，或者可以自动转换，否则编译不通过。赋值运算不会改变结果的数据类型。注意：不要将赋值运算符“=”与比较运算符“= =”混淆，这也是初学者容易犯的出错。 在C语言中，赋值运算a=a+b可以简写成自反赋值形式：a+=b，并且通过编译系统自反赋值形式可以编译成高质量的目标代码。同样Java语言也提供了自反运算符，自反运算符还有“-=”、“*=”、“/=”和“%=”4种形式。

例8：测试赋值运算。

jshell> byte b=127
b ==> 127

jshell> b+1
$44 ==> 128

jshell> b+=1
$45 ==> -128

b是byte型，b+=1数据溢出，值为-128，复合赋值运算不改变结果的数据类型的规则；而b+1的值却是128，因为1是int型，b转换成int型，b+1的结果就是int型。

2.5.3自运算

自运算包括自加运算(++)和自减运算(–)，只能作用于变量，++表示递增1，–表示递减1。++和–可以在变量前，称为前缀方式，也可以在变量后，称为后缀方式。单独进行自运算时，前缀和后缀没有区别，其结果都是自加1或自减1；当自运算++或–出现在表达式中时，前缀方式表示“先取值再自算”，后缀方式表示“先自算再取值”。 例9：自加运算

jshell> int i=1,j=1,x,y;
i ==> 1
j ==> 1
x ==> 0
y ==> 0

jshell> x=i++
x ==> 1

jshell> y=++j
y ==> 2

jshell>

x=i++，先取出i的值1赋值给x，然后i自加1。此句执行完，i值为2，x值为1。 y=++j，j先自加1，值为2；然后再赋值给y。此句执行完，j值为2，y值为2。

例10：一个经典的自加运算。

jshell> int i=5,j=5,m,n;
i ==> 5
j ==> 5
m ==> 0
n ==> 0

jshell> m=(i++)+(i++)+(i++);
m ==> 18

jshell> n=(++j)+(++j)+(++j);  
n ==> 21

jshell> System.out.println("i="+i+",j="+j);
i=8,j=8

可见：++在前，先加再取值；++在后，先取值再加。

小结：实现变量i增1有三种形式：自加i++、自反i+=1、赋值i=i+1。严格意思上讲，i++形式的效率最高，i+=1形式次之，i=i+1形式最低。但是现代程序编译器已经很智能了，做好了优化工作，三者效率差别不是特别明显。

2.5.4比较运算

比较运算包括等于(= =)、不等于(!=)、大于(>)、小于(<)、大于等于(>=)、小于等于(<=)，运算结果是一个boolean型值。其中，等于(= =)和不等于(!=)的优先级低于其他四个比较运算符，且算术运算符的优先级高于比较运算符。比如：10>20-11等价于10>(20-11)，结果是逻辑值true。比较运算符的结合方向是从左向右结合。

2.5.5逻辑运算

逻辑运算包括逻辑与(&&)、逻辑或(||)、逻辑非(!)，参与逻辑运算的数据必须是逻辑型，运算结果也是逻辑型数据。对于逻辑与运算，只有当&&两边条件同时为true时结果才为true；如果&&左边条件为false，则右边条件不再计算，结果直接为false。对于逻辑或运算，只要||两边条件有一个为true结果就为true；如果||左边条件为true,则右边条件不再计算，结果直接为true。 在程序中比较运算和逻辑运算结合起来使用，可以满足复杂的条件判定要求。比如表示变量i不属于区间[0,10)，可以写成!( i>=0 && i<10)，或者写成i<0||i>=10。运算优先级：逻辑或(||) < 逻辑与(&&) < 逻辑非(!) < 比较运算。

例11：闰年判定问题。 分析：如果年份能被400整除，则是闰年；如果年份能被4整除，而不能被100整除，也是闰年。第一个条件可以写成year%4= =0 && year%100!=0 ，第二个条件写成year%400==0，则闰年的条件就是year%4= =0 && year%100!=0 || year%400==0。 编写程序LeapYear来测试一下2012年是否闰年，代码如下。

jshell> int year=2020;
year ==> 2020

jshell> System.out.println(year%4==0&&year%100!=0 || year%400==0);
true

如果不确定&&与||的优先级，可以使用小括号()，闰年判定条件可以写成：(year%4==0&&year%100!=0) || year%400==0。

2.5.6三目运算

三目运算也称为条件运算，语法格式：

条件 ? 值1 : 值2

执行过程是：若“条件”为true，则返回“值1”，否则返回“值2”。 例12：三目运算的用法

jshell> int x=1,y=1,z=5,max;
x ==> 1
y ==> 1
z ==> 5
max ==> 0

jshell> max=x<y?x++:++y;  //返回++y,只计算++y
max ==> 2

jshell> System.out.println(x+" "+y);
1 2

jshell> max=x>y?x:y;
max ==> 2

jshell> max=x>(y=y>z?y:z)?x:y;
max ==> 5

可见，用三目运算符可以很方便地求解两数或三个数的最大值问题。

2.5.7位运算

Java中的位运算继承于C语言，在软件开发中，直接使用位运算已经很少见了。基本概念了解一下，在面试中可能涉及到位运算的基本概念。位运算只能作用于整型数据。整型数据在内存中以二进制形式存储的，比如一个整数在内存中占用4个字节的空间，最高位是符号位，0表示整数，1表示负数。负数采用补码形式存储，负数的补码等于其原码取反再加1，比如-8的补码是： 11111111 11111111 11111111 11111000 关于补码的知识，读者可以去查阅相关资料，这里就不多介绍了。 Java支持7个位运算符，如表2.3所示。

例13：测试位运算,程序说明请参见注释。

jshell> int i=0b00000010;
i ==> 2

jshell> int j=0b00000011;
j ==> 3

jshell> i|j
$71 ==> 3

jshell> i&j
$72 ==> 2

jshell> i^j
$73 ==> 1

jshell> ~i
$74 ==> -3

jshell> i<<2
$75 ==> 8

jshell> i>>1
$76 ==> 1

jshell> j>>>1
$77 ==> 1

从Java 7版本开始，整型变量的值使用二进制形式，更适合进行位运算操作。在整数没有溢出的情况下，左移动一位相当于乘以2，右移1位相当于除以2。位移运算效率要比乘法运算效率高的多。

2.5.8 运算优先级

运算优先级决定了表示式执行的先后顺序，Java中所有的运算优先级如表2.4所示。在实际软件开发中，不需要死记硬背这些运算优先级，优先级不清楚的地方可以使用小括号，同时也提高了程序可读性。比如x<y&&z>10可以写成(x<y) && (z>10)形式。

表2.4 Java所有运算符优先级

表中按照优先级高低顺序排放，即是优先级为1的级别最高，优先级为14级别的级别最低。

例14：测试自加运算、比较运算和逻辑运算的优先级。

jshell>  int x=3,y=2,z=5;
x ==> 3
y ==> 2
z ==> 5

jshell> System.out.println( x>y&&y>z || y<z);
true

jshell> System.out.println( --x>y++&&x++>z || x>=y);
false

jshell> System.out.println(x+","+y);
2,3

jshell> 

程序说明：对于--x>y++&&x++>z || x>=y，因为&&高于||，先计算--x>y++&&x++>z； 对于--x>y++&&x++>z，--x>y++的值为(2>2)false，所有&&右边的x++>z不再计算，整个&&表达式值为false；也就是||左边为false，再计算右端；右端也是false，最后输出结果false。