Microsoft Word - 第3章.doc

Transcription

1 第 3 章 Java 中的基本数据类型和运算符 在前面两章中, 我们对 Java 有了一个初步的认识, 并且准备好了我们的开发利器 Eclipse 下面回顾一下前两章学到的东西 我们知道 JDK 是 Java 世界的基础, 并且在计算机上成功安装和配置了 JDK; 我们编写了第一个 Java 程序 虽然我们对这个程序并不了解, 但是知道了一个 Java 程序 大概长得什么样 ; 我们了解了编写一个 Java 程序的过程 编写源代码 编译源代码 运行程序, 并且在源代码出错的时候, 需要找到错误 ; 我们将 Eclipse 安装到计算机上, 并且学会了在 Eclipse 中创建项目, 使用 Eclipse 提供的各种工具编写 编译并运行程序 其实前面两章的内容是为本书以后的章节做准备 从本章开始将系统地学习 Java 语言 本章中首先将介绍 Java 语言的基本数据类型和变量名 让我们开始本章的学习 3.1 Java 中的基本数据类型 我们知道, 编写程序是离不开处理数据的 计算机中的一个文本文件 一个图片等都是由数据组成的 如果想在程序中处理这些文件, 就必须要把这些文件中的数据变成编程语言可以表示的数据类型 这些编程语言直接支持的数据类型就是基本数据类型 基本数据类型是编程语言所支持的最底层的数据类型 程序中所有的数据归根究底都是由基本数据类型构成的 基本数据类型就好像一门编程语言中的 基本微粒, 它是各种编程语言都有的一个概念 下面对 Java 语言的基本数据类型进行介绍 基本数据类型 编程语言中的数据原子 编写 Java 程序, 其实就是使用 Java 处理数据 在 Java 的世界中, 虽然数据类型千变万化, 有字符串 图片 文件 声音数据和视频数据等, 但是构成所有 Java 数据类型的基础数据, 只有为数不多的几种 我们称这几种基础数据为 Java 基本数据类型 虽然这个世界丰富多彩, 但是化学告诉我们, 这个世界上所有的物体都是由一百多种原子通过不同的组织方式构成的 在 Java 这个丰富多彩的世界中, 基本数据类型可以说就担当了原子这个角色 通过它们的组合, 可以构建出丰富的数据类型 它们就是组成数据的 数据原子 学习 Java 语言, 了解 Java 的基本数据类型是第一步

2 第 1 篇 Java 语言基本语法 Java 中的基本数据类型介绍 值和值域 ( 取值范围 ) 是 Java 基本数据类型的两个最重要的属性 可以将 Java 基本数据类型与数学中学习过的数字类型 ( 如自然数, 整数, 有理数, 无理数等 ) 做一个类比, 用来帮助理解基本数据类型 一个自然数是有自己的值的, 如 5; 自然数也有自己的值域, 就是 大于 0 的所有整数 而基本数据类型与数学中的数字类型有一个很不一样的地方就是 : 编程语言中的数据类型的值域是有限的 也就是说, 在编程语言中, 不可能有一种数据类型可以表示所有的自然数 其实这个也很好理解 即使是在现实中, 我们也不可能处理所有自然数 例如, 一个苹果包含的水分子数是一个自然数, 但是这个自然数会是一个天文数字 同样的道理, 程序是运行在内存中的, 内存大小有限制, 不可能表示一个无穷大的数 说了这么多, 现在来揭开 Java 基本数据类型的面纱 Java 中共有 8 种基本数据类型, 分别是 byte short int long float double char 和 boolean 这些用来表示类型的单词都是 Java 中的关键字 ( 中文又有翻译为 保留字, 英文是 key word) 其中,byte short int long 可以认为是用来表示整数的, 它们之间的区别就是值域不同 float double 是用来近似表示无法用 byte short int long 表示的有理数或无理数的, 区别也仅仅是值域不同 char 是用来表示一个字符的 例如, 第 1 章中的程序在控制台输出的 Hello World, 在 Java 的最底层其实就是用多个 char 来表示的 boolean 是用来表示 真 和 假 两个值的, 这个是逻辑上经常用的 基本数据类型值域 节中了解了基本数据类型的概念, 并且知道了 Java 中共有 8 种数据类型 下面对每种数据类型做一个简单的介绍 1.byte 类型 byte 类型是用来表示整数的 byte 的值域是 [ 128,127] 也就是说, 一个 byte 的值必须是整数, 且不能小于 128, 不能大于 short 类型 short 类型也是用来表示整数的 short 的值域是 [ 32768,32767] 3.int 类型 int 类型是 Java 语言中最常用的用来表示整数的类型 int 类型的值域是 [ , ] 相比起前面的 byte 和 short 类型,int 类型的值域对于表示现实中的绝大多数整数都已经足够了 所以除非有特殊的需求, 在 Java 程序中一般使用 int 类型的值来表示一个整数 40

3 第 3 章 Java 中的基本数据类型和运算符 4.long 类型 long 类型也是用来表示整数的, 它的值域是 [ , ] 对于一些 int 所不能表示的整数值, 需要使用 long 类型 5.float 类型 float 类型是用来近似表示有理数或无理数的, 在编程语言中称之为浮点数 [1.4E-45, E38] 是使用科学计数法来表示的浮点数的值域 我们在关心 float 类型的值域的同时, 也应该关心 float 类型的精度 其实 float 的值域是完全没必要去记住的, 关于浮点数的精度, 可以通过阅读下面一段文字对它有个初步的了解 现在我们应该把精力放在 Java 语法上, 对于 float 类型, 可以先认为它就是用来表达一个有理数的就可以了, 只是有时候会有无伤大雅的小小误差 说明 : 关于浮点数类型的精度, 是一个复杂的话题 在计算机系统中, 整数和浮点数的存储是完全不同的 整数的值是确定的,1 就是 1 而浮点数的值则是近似的, 对于 1.1 这个有理数, 计算机只能够 近似地 将它表示出来而不能完全精确地表示出来 其实在编程语言中, 对于浮点数来说, 精度和值域同样重要 这里没必要去深究为什么在计算机中不使用精确的方式表达一个有理数 其实关于有理数在计算机中的表达是一个非常大的话题, 这里不可能展开论述 总之, 想在计算机中绝对精确地表达一个小数是不可能的 所以计算机只能够近似地表达一个小数 其实计算机表达一个有理数虽然不是 绝对精确, 但是其实是 足够精确 的, 我们不用担心银行的计算机系统会少算或者多算一分钱 6.double 类型 double 类型也是用来表示浮点数的, 它与 float 的区别就是它的精度更高, 误差更小 在 Java 中,double 是最经常用的表示浮点数的数据类型 double 的值域是 [4.9E-324, E308], 同样我们没有必要记住这个值域, 只要知道 double 的值域足够大, 而且 double 在表示浮点数的时候误差比 float 要小就可以了 7.char 类型 char 类型在 Java 中是用来表示一个字符的 这里说的字符既包括英文字符, 也包括汉字及其他语言中的字符 所以 char 类型的值域就是所有字符 8.boolean 类型 boolean 类型是用来表示逻辑值 true 和 false 的 boolean 类型的值只能是 true 或者 false true 和 false 两个单词都是 Java 中的关键字, 专门用来表示这两个值的 可以认为 true 就是 1,false 就是 0,boolean 类型就是一个只能取 1 或者 0 的数据类型 这里介绍的是 Java 中和数字相关的几个数据类型, 还有一点需要知道的就是它们的精度 首先浮点数的精度大于整数类型的精度, 其次精度是根据它们的值域排列的, 它们的 41

4 第 1 篇 Java 语言基本语法 精度从小到大排列就是 :byte short int long float 和 double Java 基本数据类型的概念接受起来还是很容易的, 可以说它们和我们数学中的数字类型的区别就是它们有一个英文名字, 而且它们只能表示某个范围内的数字 下面就要开始介绍 Java 中的运算符, 并且开始使用这些基本数据类型了 Java 中表示数字的类型的精度从小到大依次是 :byte short int long float 和 double 3.2 Java 运算符 本节中将讲述 Java 中另一个最基本的东西 Java 运算符 在使用 Java 运算符的时候需要用到上面介绍的 Java 基本数据类型, 同时了解变量的概念 变量的概念 首先, 为了使用 Java 运算符, 必须先引入变量 (Variable) 的概念 变量就是程序中使用的数据, 可以将变量用于运算 变量有 3 个属性 变量名 (Variable Name) 变量类型 (Variable Type) 和变量的值 (Variable Value) 也许现在我们还是觉得变量这个概念不够具体 现在回顾一下数学中做应用题的过程, 让我们看看应用题中的 变量 下面给出一个最简单的应用题 A 和 B 相距 10 米,A 以 5 米每秒的速度向 B 移动, 请问 A 到达 B 需要几秒? 解 : 设 A 到达 B 需要 secondneeded 秒, 则 : 5 secondneeded = 10; 解得 secondneeded = 2 这个应用题的解答过程也许不是很规范, 从程序的角度看, 这里 设 A 到达 B 需要 secondneeded 秒 一句其实就是声明了一个变量, 叫做 secondneeded 在 5 secondneeded = 10 一句中, 通过 secondneeded 这个名字使用了这个变量 对于这个应用题,secondNeeded 可以是任何数值 但是 Java 作为一门编程语言, 需要严谨地定义一个变量 这里说的严谨, 就是对 secondneeded 这个变量可以取的值进行约束, 也就是规定 secondneeded 这个变量的变量类型 下面给出一个创建 int 变量的代码, 以直观地看一看 Java 中如何创建一个变量 int secondneeded; 上面的这一行程序就创建了一个变量, 变量的类型是 int, 变量的名字就是 secondneeded Java 中的变量就是变量名 变量类型和变量的值三者的结合体 其中变量名字很好理解, 这里就不多做解释了 ; 变量类型用来规定这个变量的所属类型, 在给出的例子中,secondNeeded 的变量类型就是 int, 这意味着 secondneeded 这个变量的值必须在 int 类型的值域内 ( 在 节中已给出了 int 类型的值域 ); 变量值就是一个变量实际的值, 在这里没有给变量 secondneeded 赋值, 关于变量赋值, 会在后面的章节中给出 在数学中, 我们为了计算, 通常要先假设几个数值, 如 x y 和 z, 这其实就是在数学中创建变量的方式 因为数学是抽象的, 在演算本上可以随便写而不必关心它们是什么类 42

5 第 3 章 Java 中的基本数据类型和运算符 型的数, 所以 x 可以是整数, 可以是无理数 但是计算机是现实中的机器, 必须在创建一个变量的同时告诉计算机这个数是什么类型的, 计算机才能够处理它 可以把 Java 中的变量理解为是一个从演算本上撕下来的小纸条, 给这个小纸条一个名字或者编号 ( 变量名 ), 以便在使用的时候能够找到它 ; 可以在这个纸条上记录一个值 ( 变量值 ), 也可以修改这个值 ; 同时要记得这个小纸条有个类别 ( 数据类型 ), 所以我们在上面只能够记录这个类别中规定的数字 ( 值域内的数字 ) 变量就是数据的载体, 在程序中就是通过创建一个变量来使用基本数据类型的 数据类型可以说是一个抽象的规定, 而一个变量则是符合这个规定的 可以使用的具体 理解它后, 变量其实是一个很简单的概念 插曲 :Java 中的语句 我们发现, 无论是在第 1 章中的 HelloWorld 程序里, 还是在 节中的创建一个变量的代码中, 方法里每一行代码似乎都是以分号 (;) 结束的 像这样以分号结束的一行或多行代码, 称之为 Java 中的语句 也就是说, 可以把 Java 中的分号理解成为汉语中的句号, 它们都是代表一句话的结束 只不过是在汉语中, 可以相对灵活地使用句号, 而在 Java 中, 却要严格遵守 Java 语法来使用分号 同样地, 我们现在接触到的都是一些很简单的语句, 所以基本上每个语句都只有一行 但是在以后的学习中会接触到 Java 中复杂的语句, 它们有时候需要由多行代码组成, 所以不要下意识地以为一行代码就是一个语句 不仅仅是只有分号才能代表 Java 中的一行语句 例如在第 4 章中会接触到流程控制语句, 它们是以一个 Java 语法结构组成的 它内部可以包含多个以分号结束的 Java 语句 就好像语文中的排比句一样, 每一个排比句都可以说是由多个单独的句子组合成的 现在只要知道有更复杂的语句就好了, 等在后面学习到的时候, 会对它们有更清楚的认识 语句的概念现在理解起来还是很简单的 在 Java 中, 可以认为语句就是程序的组成单位 程序代码都是由一个个的语句组成的 Java 中, 分号可以代表一行语句的结束 以分号为结束的语句是 Java 中最简单的语句 Java 中还有复杂的语句, 它们是由 Java 语法定义的一个语法结构 根据 Java 对应的语法规定, 其中可能包含多个由分号组成的 Java 简单语句 定义一个变量和变量名的规范 我们首先来看一下 Java 中创建一个变量的基本语法 : 数据类型 + 空格 + 合法的变量名 这里空格可以有多个, 但是至少有一个 以下代码定义了一个变量 : int secondneeded 上面的代码定义了一个整型变量 secondneeded 其中,int 表示该变量的数据类型是整型,secondNeeded 是变量的名字 在这里首先需要注意的就是 变量名 变量名必须是 Java 中一个合法的标识符 (identifier) 什么是标识符呢?Java 语言语法对标识符有明确的规定 下面给出标识符的 43

6 44 第 1 篇 Java 语言基本语法 规范 标识符必须以英文字母 ( 包括大写和小写 ) 或下划线 (_) 开头 标识符除开头之外的字符, 允许使用英文字母 ( 包括大写和小写 ) 下划线 (_) 和数字 其余字符都不可以使用 标识符区分大小写 也就是 a 和 A 是两个不同的变量名 标识符不能是 Java 中的关键字 标识符不能重名 标识符不仅仅可以用来做变量名, 还可以用来做类名和方法名 创建一个变量之后, 就可以通过这个变量的名字使用这个变量了 下面给出 Java 中的关键字列表, 请看表 3-1 表 3-1 Java 中的关键字 abstract continue for new switch assert default if package synchronized boolean do goto private this break double implements protected throw byte else import public throws case enum instanceof return transient catch extends int short try char final interface static void class finally long strictfp volatile const float native super while 在表 3-1 中列出的所有名字都是 Java 中的关键字, 所以不能被用作变量名 这里给出几个合法的变量名 : _ ( 没错, 一个下划线在 Java 中也是一个合法的变量名 ) _secondneeded secondneeded second1needed2 ( 数字可以出现在变量名除开头之外的任何地方 ) intvalue(int 是关键字, 不能做变量名, 但是它可以出现在变量名中 ),Int(int 是关键字, 但是 Int 不是, 所以是一个正确的变量名 ) 然后再给出几个错误的变量名 :1second( 数字不能出现在变量名开头 ),true(true 是 Java 中的关键字 ) Java 中的关键字都有其语法意义, 所以当误用它们做变量名的时候, 错误信息可能会不一样 下面举一个例子 public class VariableNameKeyWord { // 使用关键字做变量名的例程 // main 方法 int package; // 注意, 这里会是一个编译错误 package 是 Java 中的关键字 编译上面的例程, 会得到下面的错误信息 >javac VariableNameKeyWord.java VariableName.java:4: 不是语句 int package; VariableName.java:4: 需要 ';' int package; 2 错误 对于 变量名不能重名 这个规则, 现在先记住 : 在一个方法内变量名是不允许重复的 如果两个变量的变量名重复,Java 平台将无法通过变量名唯一地确定一个变量了 下面的例程中使用了重复的变量名

7 第 3 章 Java 中的基本数据类型和运算符 public class DuplicatedVariableName { int secondneeded; int secondneeded; 上面的代码中, 因为在 main() 方法中声明的两个变量重名了, 都叫做 secondneeded, 所以在通过 javac 命令在命令行对其进行编译的时候, 会得到如下错误 DuplicatedVariableName.java:5: 已在 main(java.lang.string[]) 中定义 secondneeded int secondneeded; ^ 1 错误 对于别的变量重名的情况, 因为涉及 Java 中的其他内容, 在以后的章节中再做介绍 建议 : 变量名是用来方便理解一个变量含义的, 例如将一个变量命名为 secondneeded, 就是因为想用它来保存 从 A 到 B 所需要的时间 本节中介绍的变量命名规则只是 Java 语法中的硬性规则, 在实际中给变量一个有意义的名字是一个好习惯, 这会让程序读起来更容易 提示 : 本节中介绍的是 Java 的语法, 需要记住 同时还有两个我们不用去关心的限制 : 变量的个数和变量名的长度 一个程序中的变量个数是有限制的, 同样, 一个变量名的长度也有限制 但是这两个值都足够大, 大到无法举例, 所以只要知道有这个限制就好了, 不用去关心这个限制具体是多少 至今笔者编写过的程序也从来没突破过这个限制 Java 中的基本运算符和表达式 现在我们知道了如何在 Java 中创建一个变量, 并对 Java 中的 8 种基本数据类型有了一个简要的了解 下面看一下什么是 Java 中的运算符, 并通过运算符来对 Java 中的变量进行运算 首先介绍一下运算符的概念 运算符就是对 Java 变量进行运算操作的符号 本节中将介绍如下几个最常用的运算符 : 赋值运算符 (=) 加法运算符(+) 减法运算符( ) 乘法运算符 (*) 除法运算符(/) 括号运算符(()) 余数运算符(%) 以及多个逻辑运算符 这里的算数运算符的意义和使用方法与小学数学中学到的基本一样, 对于逻辑运算符我们可能会有些陌生, 在 节中将专门讲解 这里有必要了解一下表达式的概念 编程中的表达式的概念与数学中接触的表达式的概念是相似的 例如, 在数学中称 a+b 是一个表达式 同样在 Java 中, 也是将一串使用变量和运算符连接起来的计算叫做表达式 了解了表达式的概念, 下面开始对 Java 中常用的运算符逐个介绍 1. 赋值运算符 (=) 赋值运算符是用来给变量赋值的, 以给一个 int 变量赋值为例, 学习赋值操作符 下 45

8 第 1 篇 Java 语言基本语法 面需要请出在第 1 章中见过面的老朋友 System.out.println() 第 1 章中, 我们用它来将一串字符输出到控制台, 其实它的功能很强大, 不仅仅可以输出一串字符, 对于我们本章中的所有 Java 基本数据类型的变量, 都可以用它来将变量值输出到控制台 例如下面的例程 public class PrintInt { int a; // 创建一个变量 a = 5; // 给变量赋值 System.out.println(a); 注意 : 这里我们发现这个例程中出现了中文字符 它们是注释, 注释是帮助理解程序的, 是对程序的说明 可以看到, 每句中文前面都有两个斜杠 //, 这是 Java 语法 在程序的任何地方都可以使用 // + 任意说明性文字 来对程序进行解释 这里需要注意的是, 注释的内容是两个反斜杠后面的所有内容, 直至换行 注释的内容在编译过程中将不会被编译器处理 首先创建一个 int 变量, 叫做 a 然后通过赋值操作符将 5 赋值给这个 a 变量 5 是 int 类型允许的一个变量值, 所以赋值成功 然后使用 System.out.println(a); 将变量的值输出到控制台 在控制台 ( 命令行窗口或者 Eclipse 的 Console 视图 ) 中将会看到变量 a 的值 注意 :Java 中, 操作符的左右两边都是可以有 0 个到多个空格的, 空格没有任何语法意义, 唯一的作用就是让程序看起来更美观 例如 a = 5;, 等号两边就各有一个空格 把空格去掉, 程序一样是正确的, 但是变量类型和变量名之间至少有一个空格 关于 Java 中的空格, 要注意在例程中的使用, 本章中不再叙述 5 正如我们所想的那样, 变量 a 的值变为了 5 如果尝试将一个不合法的值赋值给一个变量, 那么在编译的时候将得到一个错误 例如,int 的值域中不包含小数, 下面的赋值语句试图将一个小数赋值给一个 int 的变量, 所以是一个错误的语句 int a; a=5.5; 上面的代码创建了一个 int 变量 a, 并将一个小数赋值给 a 如果一个程序中包含上面的一段代码, 那么在编译这个程序的时候, 就会在控制台看到如下错误 : DuplicatedVariableName.java:4: 错误 : 不兼容的类型 : 从 double 转换到 int 可能会有损失 1 个错误 a=5.5; ^ 只要是 = 右边的值是 = 左边变量的变量类型所允许的值, 那么赋值操作就是可以进行的 同样可以用赋值操作符对 double 类型的变量进行赋值, 请看下面的代码 : double b; 46

9 第 3 章 Java 中的基本数据类型和运算符 b=5; 上面的代码创建了一个 double 类型的变量 b, 并将 5 赋值给变量 b 需要注意的是, 在使用一个变量之前, 必须给一个变量赋值 这虽然是一个很好理解的要求, 但是很多时候有可能会忽略 如果在上面的例程中将 b = 5; 去掉, 并换为 System.out.println(b); 语句, 那么在编译程序的时候会得到如下错误 : DuplicatedVariableName.java:5: 错误 : 可能尚未初始化变量 b System.out.println(b); ^ 1 个错误 这个错误的意思就是 在使用变量 b 之前, 没有给变量 b 赋值 ( 也就是所谓的未初始化变量 b) Java 语法允许在定义一个变量的时候就给它赋值, 而且在定义变量时给变量赋值也是一个很好的习惯 例如在创建一个整数变量或者一个浮点数变量的时候, 一个不错的选择就是给它们赋值为 0 int a=0; double b=0; boolean c = false; 上面的 3 行程序就是在创建出一个变量的同时给变量赋值 这是一个很实用的 Java 语法, 可以让程序更简洁更不易出错 可能让我们看着不习惯的就是最后一行, 之前介绍过, boolean 类型的值域就是 true 和 false true 和 false 是 Java 中的保留字, 最后一行中, 就是创建了一个 boolean 类型的变量 c, 然后将 false 值赋给 c 赋值运算符要求其右面的值在左面变量类型的值域中 使用一个变量前需要通过赋值操作符对其进行赋值 这里我们也许注意到了, 在 main() 方法中, 每行程序的结束都有一个 ;, 没错, 这就是 Java 的语法, 每行程序的结束都要伴随着一个半角状态下的分号, 就好像我们每句话结束要有一个句号一样 Java 语法规定, 一行 Java 程序的结束需要伴随一个分号 ; 2. 四则运算符 四则运算符包括加法运算符 (+) 减法运算符( ) 乘法运算符(*) 和除法运算符 (/) 除了乘法运算符和除法运算符在书写上和数学中有些不同之外, 这 4 个运算符都是一样的 四则运算符可以用在 Java 中的整数和浮点数上 下面来看一个简单的例程 public class SimpleCount { public static void main(string[] args){ int a = 1;// 创建 a b 和 c 三个变量, 并分别赋值 int b = 2; int c = 0; c = a+b; // 将 a 加 b 的运算结果赋值给 c System.out.println(c); // 输出变量 c 的值 在上面创建了 a 和 b 两个变量, 然后创建了 c 变量, 最后将表达式 a+b 的运算结果赋值给 c 运行这个程序可以看到如下输出 SimpleCount 源码 47

10 第 1 篇 Java 语言基本语法 3 这跟我们想要的结果是一样的 这里,Java 语法允许在一行代码中创建 a 和 b 两个变量, 并给它们赋值 同时可以将创建 c 和给 c 赋值这两个操作变为一行 请看下面的代码 : int a = 1, b = 2; int c = a+b; 这里面第一行使用逗号 (,) 将连续的两个变量创建隔开 同时, 不仅仅可以使用一个值给 c 赋值, 也可以使用表达式给变量赋值 同样也可以在第一行就完成所有工作, 请看下面的代码 : int a = 1, b = 2, c=a+b; 这里需要注意的是, 因为在给 c 赋值的时候使用到了 a 和 b, 所以, 在顺序上 c 变量必须放在 a 和 b 的后面 我们可以尝试在上面的例程使用这些语句 建议 : 笔者个人认为这种语法并不值得推荐, 因为这会让程序读起来很费力 笔者推荐一行只创建一个变量, 并且在创建的时候给变量赋值 如果不知道变量的值, 可以给变量赋 0 值 当然每个人有自己的习惯, 我们在自己的学习过程中会慢慢养成自己的编程习惯 与数学中一样,Java 中的四则运算符号也有优先级, 乘法和除法的优先级比加法减法的高, 这个就不再论述了 3. 括号运算符 在表达式中, 括号运算符 () 是用来改变运算优先级的 这个与数学中接触的括号运算符一样, 是用来改变运算符默认的运算顺序的 在这里需要注意的是, 在 Java 中, 小括号在不同的地方有不同的作用, 例如前面遇到的 main() 方法后面就有一个小括号, 这里的小括号不是运算符, 而是 Java 语法, 这会在以后的章节中做介绍 在表达式中, 我们可以嵌套多个小括号, 而不能像数学中那样使用中括号 大括号 中括号 大括号在 Java 中有另外的语义 下面通过一个例程来看一下小括号的作用 public class BracketsTest { // main() 方法 int a = 1; // 创建 3 个变量, 并给它们赋值 int b = 3; int c = 0; c = ((a+5) * 3) - b; // 使用括号改变运算顺序 System.out.println(c); 这个程序的运行结果如下 : 15 BracketsTest 源码 48

11 第 3 章 Java 中的基本数据类型和运算符 在上面这段程序 main() 方法中的第 4 行, 使用了两个小括号的嵌套 其实外面那层括号是没必要的, 但是这在 Java 语法中是被允许的 可以在没必要使用小括号的地方使用小括号, 目的是为了让运算顺序更清晰, 甚至可以连续使用两个括号 例如上面程序的第 4 行, 可以写成如下形式 : c = (((a+1)) * 3) b; 我们使用两个小括号将 a+1 括起来, 这个在 Java 语法中也是被允许的 使用小括号的时候只有一点需要牢记 : 小括号一定要左右匹配 当发现括号不匹配引起语法错误的时候, 可以借助前面介绍过的 Eclipse 源代码编辑器提供的括号匹配功能进行排错 4. 余数运算符余数运算符是一个百分号 (%), 用来计算除法中的余数 例如 5%3 的值就是 2, 因为 5/3 的余数为 2 余数运算符的优先级与乘法和除法相同, 这里就不再给出例程了 Java 中的布尔运算符 在本文中所讲的布尔运算符主要指计算结果为 boolean 类型的运算符 Java 中常用的布尔运算符有如下几个 : 相等 (==) 不等(!=) 大于(>) 小于(<) 大于或等于 (>=) 小于或等于(<=) 与(&&) 或( ) 非(!) 前面介绍的运算符都是对数字进行运算的, 运算的结果也是数字 下面我们将接触到布尔运算符, 布尔运算符的结果是 boolean 类型的值, 也就是 true 或者 false 可以将一个算术表达式的值赋值给一个合适的数字变量, 同样也可以把一个 boolean 表达式的值赋值给一个 boolean 变量 布尔运算符的优先级比四则运算符低 除了取反运算符 (!) 之外, 不同的布尔运算符之间的优先级是相同的 布尔运算符的结果就是 true 或者 false 可以将布尔运算符的值赋给一个 boolean 变量 布尔运算符的优先级低于所有四则运算符 下面将布尔运算符分成两类, 分别对每个运算符的运算规则做一个介绍 1. 值对比相关的布尔运算符 关系运算符 关系运算符有 ==!= > < >= 和 <= 这些关系运算符是用来比较两个值的 下面分别对这些关系运算符的运算规则进行介绍 说明 : 关于关系运算符, 在这里需要解释一下 关系运算符都是两元操作符, 也就是说这个操作符需要有两个操作数 ( 例如乘法操作符也是两元操作符, 乘号的左边和右边分别要有一个操作数 ), 关系运算符号左边和右边的变量类型必须有比较的可能 例如, 可以让 Java 判断一个 int 变量的值是不是大于一个 double 变量的值,int 和 double 都是数字, 可以用来比较, 但是不能让 Java 去判断一个 int 变量的值是不是大于一个 boolean 变量的值 在我们接触到的基本类型中, 两个类型相同的变量都可以用来比较 49

12 第 1 篇 Java 语言基本语法 与数值有关的类型 (byte short int long float double char) 的变量也可以相互对比,boolean 类型的变量只能与 boolean 类型变量进行相等和不等比较, 不能进行大小比较 这里不好理解的就是 char 类型, 为什么 char 类型也可以和数字类型比较呢? 这个在以后的章节中再做介绍 (1) 相等运算符 (==): 相等运算符是两个连续的等号 它是用来判断左右两边的值是否相等的, 如果相等, 则运算结果为 true, 否则运算结果就是 false, 例如下面的例程 public class EqualOperator { boolean test = false; // 创建一个 boolean 变量 test, 并且赋值 false int a = 5; int b = 5; test = a==b; // 将表达式 a == b 的值赋给 test System.out.println(test); 程序第一行中, 创建了一个 boolean 类型的变量 test, 同时给它赋值为 false 最后一行中, 使用表达式 a==b 来判断 int 变量 a 和 int 变量 b 是否相等, 然后将这个表达式的值赋值给 boolean 变量 test 这里需要记住的就是, 所有 boolean 表达式的运算结果或者是 true, 或者是 false 在上个例子中, 因为 a 和 b 的值都是 5, 所以 a == b 的运算结果就是 true 运行例程, 控制台输出如下内容 : true 输出结果与我们的预想的一样 我们看下面一段代码 EqualOperator 源码 boolean test = false; int a = 5; int b = 5; test = a+b == b+a; // 创建一个 boolean 变量 test, 并且赋值 false // 将表达式的值赋给 test,boolean 表达式的优先级最低 开始三行的代码都是好理解的, 最后一行看起来可能有点别扭, 最后的一行代码的意思就是 : 首先计算 a+b 的值, 然后计算 b+a 的值, 最后使用 == 判断两个值是否相等, 并将这个判断的结果赋值给 boolean 变量 test 其实这个表达式等价于 test = ((a+b) == (b+a)) 可以使用小括号将运算分割开来, 这样看起来就比较容易了 可以将这段代码写到例程中运行一下, 看看输出结果是不是预想的那样 技巧 : 虽然 test = ((a+b) == (b+a)) 中小括号并没有改变运算顺序, 但是却让程序看起来更容易理解 boolean 运算式有时候会很长, 使用小括号将不同的运算单元分割开是一个好习惯 (2) 不等运算符 (!=): 和相等运算符正好相反, 不等运算符在两个值不相等的时候返回 true, 在两个值相等的时候返回 false 现在来看下面的例程 50

13 第 3 章 Java 中的基本数据类型和运算符 public class UnequalOperator { boolean test = false; // 创建一个 boolean 变量 test, 并且赋值 false int a = 5; int b = 5; test = (a!=b); // 将表达式的值赋给 test System.out.println(test); UnequalOperator 源码 因为 a 和 b 的值相当, 所以 a!=b 的运算结果就是 false, 也就是 test 的值是 false 运行下面的程序, 在控制台看到如下输出 : false 程序运行的结果与分析的结果是一样的 (3) 大于运算符 (>) 和小于运算符 (<): 大于运算符在左边的值大于右边的值时, 运算结果是 true, 反之则是 false 而小于运算符(<) 则正好相反 例如下面的例程 : public class BiggerOperator { // main() 方法 public static void main(string[] args){ int a = 5; // 创建两个变量 int b = 1; boolean bigger = (a > b); // 计算 a>b 的值, 并将结果赋值给 boolean 变量 bigger System.out.println(bigger); a 的值为 5,b 的值为 1, 所以 a > b 的值为 true 运行这个例程, 程序输出如下结果 : true 小于运算符在这里就不再举例了, 它与大于运算符的用法是相同的 可以通过修改上面的例程来使用一下小于运算符 (4) 大于或等于运算符 (>=) 和小于或等于运算符 (<=): 大于等于运算符 (>=) 在操作符左边的值大于或者等于右边的值时, 运算结果是 true, 反之就是 false 小于等于运算符 (<=) 则在操作符左边的值小于或者等于右边的值时, 运算结果是 true, 反之就是 false 通过下面的例子来看一下大于或等于运算符的使用 : public class BiggerOrEqualOperator { boolean test = false; // 创建一个 boolean 变量 test, 并且赋值 false int a = 5; int b = 5; test = (a>=b); // 将表达式的值赋给 test System.out.println(test); 因为 a 的值与 b 相等, 所以 a>=b 的值就是 true 运行程序, 结果如下 : 51

14 第 1 篇 Java 语言基本语法 52 true 这个结果就是我们预想的结果 关于小于等于运算符就不再介绍了, 可以通过修改上面的例程来使用这个运算符 2. 求 boolean 类型数据关系的布尔运算符 逻辑运算符 Java 中的逻辑运算符有 && 和! 前面介绍的操作符中, 除了相等操作符 (==) 和赋值操作符 (=) 之外, 都不可以用来操作 boolean 变量 下面将介绍只能用来操作 boolean 变量的操作符 它们的运算结果也是 boolean 值 与运算符 (&&): & 应该读作 and 它是一个二元操作符, 它在两个 boolean 变量的值都是 true 的时候, 运算结果是 true, 其余的情况下运算结果是 false 例如下面这个例程 public class AndOperator { // main() 方法 boolean a = true; // 创建 4 个 boolean 变量 boolean b = false; boolean c = true; boolean value = false; value = a && b; // 计算 a && b 的值, 并将结果赋值给 value System.out.println(value); value = a && c; // 计算 a && c 的值, 并将结果赋值给 value System.out.println(value); 现在看 value = a && b; 一行, 其中 a 的值是 true,b 的值是 false, 根据 && 的运算规则,a&&b 的计算结果应该是 false 然后看 value = a && c; 一行, 其中 a 和 c 的值都是 true, 根据 && 的运算规则,a&&c 的运算结果应该是 true 运行程序, 输出结果如下 : false true 这个结果与设想的一样 可以这样记忆 && 运算符的运算规则 : 当两个 boolean 值都是 true 的时候, 运算结果为 true, 如果其中一个为 false, 则运算结果为 false 或运算符 ( ): ( 读作 or ) 也是一个二元操作符, 它的两个操作数也必须都是 boolean 变量 它的运算规则是 : 当两个 boolean 变量都是 false 的时候, 运算结果为 false; 当有一个 boolean 变量的值为 true 的时候, 运算结果为 true 它和&& 操作符有相似的地方, 可以用来对比记忆 通过下面的例程来看一下这个操作符的使用 public class OrOperator { boolean a = false; // 创建 4 个 boolean 变量 boolean b = false; boolean c = true; boolean value = false; value = a b; // 计算 a b 的值, 并将结果赋值给 value System.out.println(value); value = a c; // 计算 a c 的值, 并将结果赋值给 value System.out.println(value);

15 第 3 章 Java 中的基本数据类型和运算符 在 value = a b; 一行中,a 的值和 b 的值都是 false, 根据运算规则,a b 的运算结果应该是 false 然后看 value = a c; 一行,a 的值是 false,b 的值为 true, 根据运算规则,a c 的值应该是 true 运行一下程序, 输出如下 : false true 非运算符 (!): 非运算符只能用于 boolean 类型的变量 它是本章介绍过的所有运算符中唯一一个一元操作符 本章中介绍的其他操作符都要求在操作符左边和右边各有一个操作数 例如加法操作符, 它要对两个值进行相加, 所以必须有两个操作数 而取非运算符则只对一个 boolean 变量进行运算 我们知道 boolean 变量只有 true 和 false 两个值, 取反运算符的运算规则是 : 如果操作数的值为 true, 则运算结果为 false; 如果操作数的值为 false, 则运算结果为 true 取反运算符的使用方法是将唯一的一个操作数放在其右边 看下面的例程 public class Revert { boolean boolvalue = false; boolean revert = (!boolvalue); System.out.println(revert); // main() 方法 // 使用非运算符取反 其中 main() 方法的第 2 行中,!boolValue 就是使用了取反操作符 boolvalue 的值是 false, 根据! 的运算规则可以知道,!boolValue 的运算结果就是 true 那么变量 revert 的值就会是 true 运行一下程序, 输出的结果与推断的一样 true 取反运算符 (!) 是一个单元操作符, 使用时操作数放在它的右边 它只能用在 boolean 变量上 取反运算符的运算规则是 : 如果操作数的值为 true, 则运算结果为 false; 如果操作数的值为 false, 则运算结果为 true 位运算符 位运算符是专门针对内存中的二进制数据进行运算的一种运算符 Java 中的位运算符一共有 7 个, 分别是 : 按位与 (&) 按位或( ) 按位非(~) 按位异或(^) 左移位 (<<) 右移位(>>) 和无符号右移位 (>>>) 在这里的前四个运算又可叫做位逻辑运算符, 后面的三个叫做移位运算符 而这其中除了按位非运算是一元运算符, 其他的都是二元运算符 当然因为本书中很少谈及位运算 ( 初学者也只做了解即可 ), 只需要知道有这么个分类, 并做简单了解 如果想要了解位运算符的使用, 首先必须明白计算机中的数据存储方式 这里我们做一些简要的介绍 在计算机中, 无论什么数据或者命令都是用二进制数表示的 ( 其实是用电位高低来表示 ) 二进制数是类似于我们常用的数字, 不过不是 0~9 组成, 而是只有两 53

16 第 1 篇 Java 语言基本语法 个数字 0 和 1 组成 而其中每一个数字所占的位置称为位 ( 内存中都有一个实际的单元来存储这一个数字, 这才是真正的位 ), 在进行位逻辑运算时就会对比相同位置上的数字来计算 在进行与 (&) 运算时, 只有两个数字都是 1 的情况下才会得出 1 的结果, 否则, 为 0 而或( ) 运算则没有那么严格, 其值要求其中一个为 1 时结果就可为 1, 当两个比较的位置上的数字都为 0 时结果才会为 0 异或(^) 运算, 在其中表现得比较奇怪, 因为只有两个位上比较的数不一样的时候结果才会为 1, 只要一样了结果就为 0, 例如 1 和 1 或者是 0 和 0 比较的结果就为 0 按位非就是对一个数据中的所有位值的数字 取反, 也即将数据中的 0 改写为 1, 而将 1 改写为 0 对于其他的运算, 由于本书中很少涉及, 笔者就不再赘述 3.3 基本数据类型运算的难点 在 3.2 节中介绍了 Java 基本类型变量和 Java 中常用的操作符 现在我们大概觉得它们用起来和数学中的操作符基本上是一样的, 而且没有超出 小学数学 的水平 只不过小学的时候计算 3+5, 而在 Java 程序里面更多的是计算 a+b 下面本节中的内容将会学习到 Java 运算符中与传统数学中不一样的地方 强制类型转换 小数哪里去了 首先,Java 中处理变量与数学中不同的地方就是, 在数学中一个符号可以代表任何类型的数字, 而在 Java 中, 一个变量只能有一种类型 而 Java 中 byte short int long float 和 double 这 6 种类型都是用来表示数字的 有时会遇到想要将一个类型的数字变量值赋值给另一个类型的数字变量的情况, 这样就会有一个不同类型的值相互转换的问题 例如, 将一个 int 变量的值赋给一个 double 的变量会怎样呢? 反过来又会怎样呢? 前面介绍过 Java 数字类型的精度排列顺序 Java 中允许直接将一个低精度的值赋值给一个高精度的值, 就好像它们的类型是一样的 这个比较好理解, 将一个低精度的变量值赋值给高精度的变量就好像把一个小的东西放到一个更大的容器里, 这个肯定是放得下的 所以 Java 允许将一个 int 的变量值直接赋给一个 double 的变量 看下面这段程序 54 int intvalue = 5; double doublevalue = intvalue; 程序中创建了一个 int 变量 intvalue, 并给它赋值为 5, 然后又创建了一个 double 变量 doublevalue, 并将 intvalue 的值赋给 doublevalue 这里无须任何特殊的处理,Java 语法是允许这种把低精度的值赋给高精度变量的操作的 但是反过来则是不被 Java 允许的, 如下面这段程序 : double doublevalue = 9.5; int intvalue = 0; intvalue = doublevalue; 第 1 行中创建了一个叫做 doublevalue 的 double 类型变量, 第 2 行中创建了一个 int

17 第 3 章 Java 中的基本数据类型和运算符 变量叫做 intvalue, 第 3 行中我们尝试将 doublevalue 的值赋给 intvalue, 这个赋值操作是不符合 Java 语法的, 如果尝试编译这个程序, 会得到类似如下的错误 test.java:6: 错误 : 不兼容的类型 : 从 double 转换到 int 可能会有损失 intvalue = doublevalue; ^ 1 个错误 如何才能将一个 double 变量的值赋值给一个 int 的变量呢? 这里就需要用到 Java 中 强制类型转换 语法 首先看下面的程序 public class ForceConvert { // main() 方法 double doublevalue = 9.9; // 创建一个 double 变量和一个 int 变量 int intvalue = 0; intvalue = (int)doublevalue; // 强制类型转换 System.out.println(intValue); ForceConvert 源码可以看到,main() 方法第 3 行的赋值语句有些特别 这里就是使用了 Java 中的强制类型转换 Java 强制类型转换的语法是 ( + 目标类型 + ) + 想要转换的值 这里 (int)doublevalue 就是将一个 double 类型的变量 doublevalue 的值转换成 int 的值 例程中最后一行将 intvalue 输出到了控制台, 运行一下程序, 看看程序输出了什么 9 对于输出的结果我们也许会有些吃惊, 为什么不是 10 而是 9 呢?Java 中如果将一个浮点数强制类型转换为一个整数时,Java 是不会进行四舍五入操作的, 而是直接将浮点数的小数部分全部删除 也就是说, 如果将 0.9 通过 Java 强制类型转换成整数值, 那么将得到 0 如何才能得到四舍五入的整数值呢? 这需要编写程序来实现, 将例程修改如下 : public class ForceConvert { double doublevalue = 9.9; // 创建一个 double 变量和一个 int 变量 int intvalue = 0; intvalue = (int)(doublevalue + 0.5); // 此运算相当于四舍五入 System.out.println(intValue); 我们发现, 在强制类型转换之前, 首先计算了 doublevalue+0.5 的值 这样, 如果 doublevalue 的小数部分是大于等于 0.5 的, 加法运算的结果就会让 doublevalue 的整数部分加 1, 否则则不会, 然后再次对 doublevalue 进行强制类型转换为 int, 这时候得到的值就是四舍五入后的值了 其实编程的时候进行四舍五入就是对一个浮点数加上 0.5, 然后取其整数部分 运行这个修改后的程序, 会发现输出的值是我们想要的 10 同样地, 整数类型之间, 如果将一个高精度类型的值赋给一个低精度类型的变量, 也 55

18 第 1 篇 Java 语言基本语法 需要进行强制类型转换 请看下面的例程 public class ForceConvert2 { byte bytevalue = 0; // 创建一个 int 变量和一个 byte 变量 int intvalue = 9; bytevalue = (byte)intvalue; // 赋值前进行强制类型转换 System.out.println(byteValue); ForceConvert2 源码 程序运行结果如下 : 9 这里需要注意的是, 强制类型转换是有风险的, 因为 byte 的值域是 [ 128,127], 如果在上面的例程中,intValue 的值是 999, 则超出了 byte 的值域, 那么强制类型转换的结果是什么呢? 把上面的程序修改一下, 让 intvalue 的值是 999, 然后运行程序, 程序输出如下 : -25 我们惊讶地发现, 程序输出的值是 25! 一个正数, 竟然强制类型转换后是一个负数! 其中的原因涉及数字在计算机中的保存方式, 这里不去讲解这部分 在这里要知道的就是, 如果将一个高精度变量值转换为一个低精度值, 需要保证这个高精度变量的值没有超出低精度类型的值域 ( 例如上面的例子中, 就要确定 intvalue 这个变量的值没有超过 byte 类型的值域 ) 否则, 转换的结果就会是不期望的那样 例如知道 byte 是可以表示数字 9 的, 所以如果 intvalue 的值为 9, 则可以进行强制类型转换 但是,999 是 byte 类型所不能表示的, 如果 intvalue 的值为 999, 则最好不要进行强制类型转换, 因为结果可能让我们吃惊 对于 Java 中的数字类型,Java 中允许直接将一个低精度的值赋给高精度的变量 如果需要将一个高精度的值赋给低精度的变量, 需要对高精度的值进行强制类型转换 Java 中强制类型转换的语法是 : ( + 目标类型 + ) + 想要转换的值 在将一个高精度的值转换成低精度的值时, 需要确定这个高精度类型变量的值能够在低精度中表示, 否则, 结果可能是意料不到的 提示 : 在实际编程中, 我们最多的就是使用 int 和 double 来表示整数和浮点数, 除非有特殊的需要, 而较少用其他的数字类型 它们的值域要么太小 ( 如 byte 类型, 用的时候很容易就会让变量的值超出值域 ), 要么太大 ( 对于值域大的数据类型, 计算机处理起来需要更多的资源消耗 ) 而 int 和 double 两个类型是值域和开销的平衡点 在值域满足绝大多数情况的需求时, 计算机使用的绝大多数硬件开销也不会很大 类型的转换在运算中悄悄进行 节中介绍了数字类型的变量在赋值运算的时候遇到的类型问题 同样的问题也会

19 第 3 章 Java 中的基本数据类型和运算符 出现在对数字类型进行的运算中 前面的章节在介绍加法运算符时, 我们仅仅是使用两个 int 类型的变量进行加法操作 很可能我们需要将一个 int 类型的变量和一个 double 类型的变量相加 这时 Java 会怎样处理呢? 加法进行后的返回值是什么类型的呢? 其实在对两个不同类型的变量进行运算时,Java 会先将精度低的变量转换成精度高的变量 (Java 可以将高精度变量值转换成低精度值, 也可以反过来转换 ), 然后对两个同类型的变量进行运算, 最后返回的结果也是高精度的 看下面的程序 public class CountAndConvert { public static void main(string[] args){ double doublevalue = 9.9; // 创建一个 double 变量和一个 int 变量 int intvalue = 9; double result = doublevalue + intvalue; // int 类型变量被转换为 double 类型 System.out.println(result); CountAndConvert 源码在 main() 方法的第 3 行中, 将 double 的变量 doublevalue 和 int 的变量 intvalue 进行相加 这时候,Java 发现加法的两个操作数类型为 double 和 int, 是不一样的,Java 首先找到精度低的类型变量, 也就是 intvalue, 然后将它的值转换为精度高的类型, 在这里也就是 double 然后 Java 就会将两个 double 的变量值进行相加 加法执行的结果也是 double 类型的数据 如果在这里将 result 的变量类型改为 int, 则会有前面小节中看到的错误, 因为无法直接将一个 double 的值赋给一个 int 的变量 运行这个例程, 结果输出如下 : 18.9 我们发现, 结果确实是 double 的, 因为它包含小数部分 小提示 : 前面介绍说浮点数无法精确地表示一个变量, 但不用去担心浮点数的精度, 因为它是 足够精确的 这里我们看到,double 类型仿佛精确地表示了想要的结果 其实这里,double 类型足够精确, 而不是完全精确 Java 程序准确地给出了 18.9 这个结果, 在我们看来并没有一丝一毫的误差 同样地, 对于其他运算符 ( * / 和 %),Java 也会进行相同的处理过程 运算结果的类型就是所有操作数中精度最高的那个 这里还有一点需要注意 如果直接写一个数字, 那么它是什么类型的呢? 例如下面这行程序, 它使用了数字 9 和 4 byte bytevalue = 9/4; 对于直接出现在程序中的数字, 如果是整数,Java 就会使用 int 类型变量来表示它, 如果是浮点数,Java 就会使用 double 类型来表示它 那么, 上面的运算结果岂不是一个 int 了吗? 为什么没有错误呢? 实际上, 在之前比较旧版本的 JDK 上, 这行程序是错误的 但是在使用的最新版本的 JDK 中,Java 会自动将运算的结果转换为我们想要的类型 例如上行程序中,Java 就会把运算类型转换为 byte 57

20 第 1 篇 Java 语言基本语法 这里需要注意的是,9 和 4 都是直接的数字, 而不是变量, 只有这个时候 Java 才会完成类型转换 如果是下面这段代码, 虽然意思是一样的, 但是在 Java 中就会是错误的 int intvalue = 9; byte bytevalue = intvalue/4; 这是因为 intvalue 是一个变量, 而不是一个直接的数字 好, 接下来看下面这个例程 public class AutoConvert { double doublevalue = 9/4; // 将两个 int 类型变量的除法运算值赋值给 double 变量 System.out.println(doubleValue); doublevalue 的值会是多少呢? 首先来分析 9/4 这个计算式 通过前面的介绍可以知道, 对于这种直接写在程序中的整数,Java 是使用 int 来计算的 那么,9/4 就是两个 int 值的除法, 它不会保留 AutoConvert 源码小数部分, 所以它的值就是 2 然后 Java 会将这个 2 转换为 double 类型并赋给 doublevalue 变量 那么 doublevalue 的值就应该是 2.0 ( 对于浮点数, 就算其小数部分是 0 也要加上, 以表示它是一个浮点数 ) 运行程序, 会发现程序输出跟推断的一样 2.0 当操作符的操作数有不同的精度时,Java 会将低精度的操作数转换为高精度的操作数, 然后进行运算 运算的结果也是高精度的值 对于直接出现在程序中的整数,Java 会当作 int 类型处理 ; 对于浮点数,Java 会当作 double 处理 强制类型转换最优先 强制类型转换的运算优先级是高于算数运算符的 如果把 节中 ForceConvert 例程修改为如下的样子 : public class ForceConvert { double doublevalue = 9.9; // 创建一个 int 变量和一个 double 变量 int intvalue = 0; intvalue = (int)doublevalue + 0.5; // 强制类型转换后再进行运算 System.out.println(intValue); 这里如果把 main() 方法中的第 3 行写成 intvalue = (int)doublevalue + 0.5;, 那么 Java 编译器会输出 可能损失精度 错误 为什么呢? 这是因为强制类型转换运算的优先级高于算数运算符, 所以表达式 (int)doublevalue 的运算顺序就是先把变量 doublevalue 强制类型转换成 int 类型, 然后再与 0.5 进行加法操作 0.5 是一个 double 变量, 那么就是 58

21 第 3 章 Java 中的基本数据类型和运算符 int 变量和 double 变量进行加法运算 根据上节中的介绍, 这个运算结果就是一个 double 的值 在这里, 因为 doublevalue 是一个变量而不是直接的数字, 所以 Java 不会对运算结果进行类型转换, 也就是说, intvalue = (int)doublevalue + 0.5; 其实是将一个 double 的值赋给一个 int 变量, 所以才会出错误 而如果使用 intvalue = (int)(doublevalue + 0.5);,Java 就会先计算小括号内的值, 也就是先计算 (doublevalue + 0.5), 然后再对运算结果进行强制类型转换, 这时候我们得到的结果就是 int 的值了, 所以不会出错 在使用强制类型转换的时候, 一个好习惯是将被转换的类型或者表达式用小括号括起来, 以避免出错 强制类型转换运算的优先级高于算数运算 使用强制类型运算的时候, 一个好习惯是将被转换的变量或者表达式用小括号括起来 这样可以有效地避免出错, 而且可以让程序更加易读 等号其实不简单 前面介绍过等号就是用来赋值的, 这个用法与我们从小学以来一直会的用法是一样的 但是在 Java 中, 等号还有更丰富的用法 首先看下面这个例程 public class ContinueAssign{ public static void main(string[] args){ int a = 0; // 创建一个 int 变量 a int b = (a = 5); // 给 a 赋值 5, 然后再把 a 赋值给 b System.out.println(a); System.out.println(b); int b = (a = 5); 看起来很别扭, 它是什么意思呢? 我们知道 Java 中 a+b 的返回结果是 a 和 b 两个数的和 a = 5 不仅仅完成了赋值操作, 它其实也会返回一个结果, 它的结果就是完成赋值操作后等号左边的变量值 在上面的例子中,a=5 的结果就是完成赋值操作后 a 的值, 也就是 5 这样就好理解了, 在上面的程序中, int b = (a = 5); 其实就等于下面两行程序 a=5; int b=a; 运行上面的程序, 程序输出如下 : 5 5 Java 的等号有了这个功能, 就可以连续地给变量赋值了 接下来看另一个例程 public class UseInAssign { public static void main(string[] args){ int a = 5; // 创建两个变量 int b = 6; b = a + b; // b 既用于计算, 也用于赋值 59

22 System.out.println(b); 第 1 篇 Java 语言基本语法 我们看到 b = a + b; 的时候也许会不理解 其实这一行程序的执行过程就是 :Java 首先根据变量名 a 得到这个变量的值, 然后根据变量名 b 得到这边变量的值, 然后进行加法运算, 最后将运算的结果赋值给 b 所以在将运算结果赋给 b 的时候,Java 平台已经利用 b 的值计算过加法了, 而无须担心这么使用会造成什么未知的结果 根据推断,b 最后的值应该是 a 的值 5 加上赋值前 b 的值 6, 也就是 11 运行这个程序, 得到的输出跟预想的一样 11 等号 (=) 除了会完成赋值操作以外, 也跟其他运算符一样, 会返回一个值 在等号左边的表达式中可以使用等号右边的变量 小心使用浮点数进行比较 前面介绍过, 浮点数其实是不可能完全精确地表示一个小数 也就是说, 判断两个浮点数是不是相等的时候, 很可能得不到想要的结果 我们觉得明明是两个以为相等的浮点数, 可能 Java 认为它们并不相等 其实在 Java 中, 因为浮点数不精确这个特点, 极少使用浮点数进行相等运算 (==) 当需要判断两个浮点数是不是相等的时候, 比较通常的做法是让两个浮点数相减, 如果它们的差足够小, 那么就认为两个浮点数是相等的 看下面的例程 public class CompareUsingSub { double a = 9 * / * ; // 浮点数运算 double b = 9 * / * ; // 当两个浮点数差小于一个我们规定的足够小的数, // 那么它们就可以看做是相等的 boolean equal = (a - b < ) && (b - a < ); System.out.println(equal); CompareUsingSub 源码 这里看表达式 (a b < ) && (b a< ), 它的意思就是如果 a 和 b 的差值小于 , 并且 b 和 a 的差值小于 ( 因为我们无法确定 a 和 b 哪个会更大一点, 所以我们需要两个判断 ) 的时候, 表达式的值就是 true, 否则就是 false 换句话说, 也就是 a 和 b 的差值的绝对值小于 , 表达式的值就是 true, 反之就是 false 这里, 如果表达式的值为 true, 就认为 a 和 b 两个浮点数足够接近, 可以认为是相等的了 运行上面的程序, 得到如下输出 : true 注意 : 浮点数没有绝对的相等, 只有近似的相等 Java 中只有整数才有绝对的相等 60

23 第 3 章 Java 中的基本数据类型和运算符 这里 只是一个假设值 在实际的程序中, 可以根据需要来确定这个精度应该是多少 例如如果 a 和 b 代表两种商品的价格 ( 元 ), 那么精度是 就足够了, 因为现实中商品的价格一般就是精确到 0.01 元, 如果两种商品的价格差小于 元, 我们就可以认为它们的价格是相等的 当然如果在别的场景下, 可能 这个精度还不够 在这个例程中, 直接使用相等运算符来对 a 和 b 两个 double 变量的值进行判断, 很可能也能够得到 true 值 事实上, 对 a 和 b 进行完全相同的运算后, 再通过相等运算符进行比较, 还是很可能得到 true 值的 但是在实际编程中, 为了严谨起见, 判断两个浮点数是不是相等时, 最好像例程中做的那样, 使用两个浮点数的差的绝对值与我们关心的精度进行比较得出 在这里还有一点需要注意的就是 && 的使用 前面介绍过,&& 在发现左边的值为 false 的时候就不会再去计算右边的值了 在这个例子中, 如果 (a b < ) 的值是 false, 那么 Java 将不会再去计算 (b a< ) 这样我们在(a b < ) 的值是 false 的情况下, 就少做了一次两个 double 变量的减法 (b a) 和一次两个 double 变量的比较运算 (b a 的值小于 ) 虽然在这里不会影响到结果, 但是在其他地方可能就有影响 提示 : 有些情况下, 在类似 A B 和 A&&B 这种表达式计算中,A 表达式的结果是 B 表达式进行运算的基础, 也就是说只有在 A 表达式是某一确定的情况下,B 表达式才能够进行计算 在这种情况下, 就必须使用 和 && 了 在后面章节的学习中会接触到这种情况 所以现在就应该养成使用 和 && 的好习惯 最好不要对浮点数进行相等比较 要用它们的差的绝对值与一个我们关心的精度进行比较, 来判断两个浮点数是否相等 编程中一般使用 和 && boolean 和 char 上面的章节中主要使用了 Java 基本类型中数字的相关类型 在本节中将对 boolean 和 char 各给出一个例程 1. 通过例程学习 boolean 类型变量 boolean 类型的变量是可以使用相等运算符的 看下面的例程 public class BooleanEqual { public static void main(string[] args){ boolean valuea = true; // 创建 3 个 boolean 变量 boolean valueb = true; boolean valuec = false; boolean value = (valuea == valueb); // boolean 类型变量的相等运算 System.out.println(value); value = (valuea == valuec); // boolean 类型变量的相等运算 System.out.println(value); BooleanEqual 源码 61

24 第 1 篇 Java 语言基本语法 首先将 valuea == valueb 的运算结果赋值给 value 变量, 然后将 value 的值输出到控制台, 因为 valuea 和 valueb 的值都是 true, 所以 valuea == valueb 的运算结果就是 true 这时候 value 的值就应该是 true, 那么控制台输出的第一行内容就应该是 true 紧接着我们又将 valuea == valuec 的运算结果赋值给 value, 因为 valuea 和 valueb 的值不相等, 所以 valuea == valuec 的运算结果应该为 false 那么 value 的值此时就应该是 false, 也就是控制台输出的第二行内容就是 false 运行一下程序, 输出结果与推断的一样 62 true false 好的, 接下来看一个 char 类型的使用 2. 通过例程学习 char 类型变量 本章中至此还都没有使用过 char 类型 char 类型的变量代表一个字符, 这个字符可以是英文字符, 也可以是中文字符 看下面的例程 : public class UsingChar { char chara; // 创建一个 char 变量 chara = 'A'; char charb = ' 人 '; // 给 char 变量赋值 System.out.println(charA); // 输出 char 变量的值 System.out.println(charB); char charc = ' 人 '; boolean equal = (charb == charc); // char 变量的比较 System.out.println(equal); UsingChar 源码 首先看 main() 方法的第一行 char chara;, 我们创建了一个叫做 chara 的 char 类型的变量 第 2 行中, chara = 'A'; 就是给这个 char 变量赋值 因为 char 是字符变量, 所以给它赋值也要使用字符 同时 Java 中表示一个字符时不能够直接写一个字符, 需要用一对单引号将这个字符括起来 给 char 变量赋值的语法就是 char 变量名 + = + ' + 一个字符 + ' 注意 : 在输入中文字符的时候, 记得输入完毕后将输入法切换到英文输入法再写程序, 否则很可能会使用中文里的分号 ; 前面介绍过, 非英文的字符出现在程序正文中是不符合 Java 语法的 在这里介绍一下 Java 中的单引号 在 Java 中, 单引号用来将一个字符括住, 表示一个字符 这句话听起来仿佛有点别扭 我们来理解一下 例如在上面的例子中, 如果不使用单引号, 而直接写 chara = A 则是将字符 A 赋值给 char 变量 chara 但是 Java 却无从知道等号右边的 A 是代表什么意思 :A 是代表一个变量呢 ( 当然, 在上面的例程中没有变量 A, 我们假设有 ), 还是代表一个字符 A 呢? 所以, 为了避免这种困惑,Java 语法中规定, 如果要表示一个字符, 必须用一对单引号将这个字符括起来

25 第 3 章 Java 中的基本数据类型和运算符 单引号之间的内容只能是一个字符 因为一个 char 类型的变量只 够放 下一个字符的 如果单引号里面有两个字符, 在 Java 中就是不符合语法的 好的, 现在我们知道了 Java 中字符的相关知识继续看上面的例程 第 3 行中, 将一个汉字字符 人 赋值给了 charb 变量 前面介绍过, 这在 Java 中是支持的 紧接着的两行, 使用 万能的 System.out.println 将 chara 和 charb 的内容输出到控制台上 这时候控制台上前两行内容应该是 A 和 人 然后继续看程序 下面一行中创建了一个 char 变量 charc, 值也是 人 然后使用 == 来判断 chara 和 charc 两个字符是否相等 将这个对比的结果赋值给 boolean 变量 equal, 然后将 equal 的值输出到控制台 因为 chara 和 charc 的值是相等的, 所以判断 equal 的值应该为 true, 也就是控制台会在输出 A 和 人 之后输出 true 运行例程, 控制台输出如下 : A 人 true 这跟我们的推断是一样的 用于 char 变量上最多的运算符就是赋值运算符 (=) 和相等判断运算符 (==) 其实, 还可以将 char 类型的变量当作是一个整数, 进行算术运算 不要吃惊, 在后面会讲解字符集编码, 到时候读者会很清楚 char 是什么, 也就知道为什么可以这么做了 但是在这里不要多想, 就把 char 类型当作是字符的代表, 不要尝试去猜测字符进行算术运算的意义 注意 : 如果有兴趣, 可以自己写几个字符相关的例程锻炼一下 先不要使用除了英文和中文之外的其他语种的字符, 例如日文字符 因为计算机的设置问题, 如果使用其他语种的字符很可能会造成源程序无法正确保存 在这里介绍一下和 System.out.println 功能相似的另一个语句 System.out.print 它与前者一样, 也可以将内容输出到控制台 System.out.println 在输出完内容后, 会输出回车换行符, 而 System.out.print 则不会 例如上面的例子, 如果将 System.out.println 替换为 System.out.print, 那么程序输出如下内容 A 人 true 提示 : 回车换行符在计算机中就是用来另起一行的 当在文本编辑器 ( 例如 Windows XP 的记事本 ) 中使用键盘上的 Enter 键时, 就是输出了一个回车换行符号 Java 中使用两个单引号将一个字符括起来, 表示一个 char 变量, 也就是一个字符 单引号之间只能有一个字符, 这是因为 char 变量只能存储一个字符 System.out.println 在输出内容后, 还会输出回车换行符 而 System.out.print 则只负责输出内容 不要使用还没有定义的变量 本节将介绍一个初学者经常犯的错误 首先看下面的例程 63

26 第 1 篇 Java 语言基本语法 public class UseAfterCreation { int a = 5; // 创建变量 a int b = a + c; // 错误!c 还没有创建出来 int c = 7; 当尝试编译这个程序的时候, 会得到如下错误提示 : UseAfterCreation.java:5: 错误 : 找不到符号 int b = a + c; ^ 符号 : 变量 c 位置 : 类 UseAfterCreation 1 个错误 UseAfterCreation 源码 编译器会提示一个错误 : 在 main() 方法的 int b = a + c; 中, 使用了还没有创建出来的变量 c 很简单的道理不是吗? 在使用一个变量的时候, 必须已经创建出来了, 虽然在 main() 方法的第 3 行中创建了 c 变量, 但是 Java 读一个方法里面的代码时, 是顺序地 一行行地读, 所以在它读到第 2 行, 发现程序使用了一个不认识的变量 c 的时候, 就会抛出错误, 而不会再继续向下读了 在这里, 可以尝试着去看一下编译器输出的错误提示 绝大多数情况下, 当编译器给出多个错误的时候, 第 1 个错误就是最直接的错误, 后面的错误可以不用去看 这里第 1 个错误提示内容如下 : UseAfterCreation.java:5: 找不到符号符号 : 变量 c 位置 : 类 UseAfterCreation int b = a + c; ^ 它代表什么意思呢? 首先 UseAfterCreation.java:5: 的意思是在 UseAfterCreation 中的第 5 行有错 错误是什么呢, 就是紧跟在后面的 找不到符号 我们去 UseAfterCreation 程序中, 从上到下数到第 5 行 ( 空行也算行数 ), 它的内容是 int b = a + c;, 这就是错误信息告诉我们的内容 其实到这里已经可以去排除错误了 但是 Java 编译器还给出了更详细的错误提示, 包括给出了错误所在的类 ( 位置 : 类 UseAfterCreation ), 给出了有错误的那行程序 (int b = a + c;), 甚至在下面的一行中使用一个 ^ 符号指出了上一行中哪个位置有错 Java 编译器如此精确地指出了出错的地方, 我们实在不应该找不出错误所在 分析到这里, 我们已经对排除这个错误的方法了然于胸了 只要把 int c = 7; 这一行挪到 int b = a + c; 这一行前面就好了 下面是修改后 main() 方法内的代码 int a = 5; int c = 7; int b = a + c; 技巧 : 编译器输出的错误提示或者 Eclipse 源代码编辑器的错误提示信息是很有用的, 要学会阅读这些错误信息排除程序中的错误 这也是本书中为什么在每次程序出错的时候都会给出错误输出的原因 初学者最经常做的事情就是一看到编译输出错误提示, 就垂头丧气 在这里大可 64

27 第 3 章 Java 中的基本数据类型和运算符不必, 没人能够刚开始写程序就不出错的 学会看错误信息是编程技术提高的一个表现 当我们慢慢学会看懂编译器输出的错误提示的时候, 会发现编译器真的是很 强大 它几乎每次都能准确地指出程序中的语法错误 我们只要学会 倾听它的声音, 那么排除程序中的错误将是一件轻松愉快的事情, 等发现编译错误就能够马上将它消灭的时候, 我们就不再是 Java 初学者了 Java 会自上而下顺序处理方法中的代码, 在使用一个变量的时候, 必须将这个变量在前面的代码中创建出来 String char 串起的项链 本节中来见一下我们在第 1 章的老朋友 String 1. 学习使用 String 类型 在第 1 章的时候使用 System.out.println("Hello World"); 向控制台输出了 Hello World 这一串字符 在 Java 中, 用双引号将一串字符括起来, 这就创建了一个字符串 不要把字符串跟 Java 中的字符弄混了, 字符是使用单引号的 字符串类型在 Java 中是使用 String 表示的 在这里,String 就好像本章中介绍的 int 一样, 是代表一个类型 看下面这个例程 public class HelloWorldPlus { public static void main(string[] args){ String sayhello = "Hello World"; // 创建一个字符串 System.out.println(sayHello); // 输出字符串 运行这个例程, 在控制台输出如下内容 : Hello World HelloWorldPlus 源码 这个结果跟第 1 章中的程序是一样的 在我们看来, 仿佛创建了一个 String 类型的 变量 sayhello, 然后给 sayhello 赋值, 再使用万能的 System.out.println 将 sayhello 的值输出到控制台 在这里我们牢记在心的是,String 与在本章中介绍的基本数据类型有本质的不同, 同样地,sayHello 也不是变量, 与 intvalue 之类的变量有本质不同 至于它们的区别是什么, 现在说出来只会让人更迷糊, 请读者朋友, 耐心等待 2.String 类型的 加法 运算下面尝试从另一个角度认识 String 在本章开篇就知道,Java 中的基本数据类型是 数据原子, 所有其他类型的数据都是由基本数据类型 组装 而成的 这里, 就可以认为 String 类型就是将一定数量的 char 类型变量组装起来后形成的一个新的类型 可以想象用线将 char 变量串成一个项链, 然后就得到了一个 String 这个类型带来的方便是不言而喻的, 如果不用 String, 那么想要向控制台输出 Hello World 将会是一件很繁琐的事情, 需要写 11 行 System.out.print 来分别输出 11 个字符 ( 注意, 空格也是一个字符 ) 65

28 第 1 篇 Java 语言基本语法 在这里介绍 String 的原因有两个, 首先就是体验一下 Java 中使用基本数据类型 组装 成的新类型 ; 其次是 String 这个类实在是太常用了, 有必要先接触一下 String 的基本使用方法 虽然我们对 String 的本质不了解, 但是这并不妨碍我们方便地使用它 看下面这个例程 public class UsingString { public static void main(string[] args){ String emptystr = ""; // String 的长度可以是 0 到足够大 String str1 = " 字符串中可以同时使用中文和 English"; // 字符串中可以中英文混合使用 String str2 = " "; // 对于字符串, 即使只包含一个字符, 也要用双引号 String plusstr = str1 + str2; // 字符串可以 相加 System.out.println(plusStr); UsingString 源码 在 main() 方法的第一行, 创建了一个空的字符串, 也就是两个双引号之间什么都没有 这在 Java 中是允许的 在使用一个 String 之前, 必须给一个 String 赋值, 就好像前面介绍的那样 这一点很好理解 不赋值怎么可以拿来使用呢? 但是在这里还要强调一下, 因为很多时候, 在写程序的时候会忽略这一点 对于数值类型, 一个好习惯是在创建出一个变量之后就给它赋值 0 对于 String, 如果不知道给它什么内容好, 那就给它个空字符串 ("") 吧! 第二行中创建的是一个同时含有中英文的字符串, 这在 Java 中是允许的, 也是常用的 然后在下一行中创建了一个只含有单个字符的字符串 这里需要注意的是, 即使只有单个字符, 但是因为它是一个字符串, 所以也要用双引号括起来 紧接着, 我们将 str1 和 str2 进行相加! 这个与算术中的相加不同 对于字符串的相加, 其运算规则是将两个字符串的内容拼接起来 而且加法是字符串唯一允许的运算, 是 Java 对字符串类型的 特殊照顾 其实可以通过其他相对 正统 但是稍微麻烦的办法来实现两个字符串的拼接 ( 利用现在学习的知识还不行 ) Java 之所以特许我们使用加号将两个字符拼接起来, 是因为 将两个字符串进行拼接 的这个功能实在是太常用了,Java 才辛苦自己, 让我们使用起来更方便 当 Java 遇到我们使用加号将两个字符串拼接起来时, 它会在背后将这个运算转换成 正统 的方式 之所以在这里解释这个问题, 就是为了再一次告诉自己 :String 不是基本类型 虽然它的用法看上去实在是像极了基本类型 好的, 那么根据字符串加法运算的规则, 可以推测出 plusstr 的内容应该是 str1 和 str2 内容的拼接, 也就是 字符串中可以使用中文 运行这个程序, 程序输出与我们的推断一致 字符串中可以使用中文 3.String 类型与基本类型的 加法 运算 下面接触一下 String 和基本变量之间的 加法 从上面的程序中可以知道,String 与 String 相加的结果就是将两个 String 拼接起来 String 与基本变量之间的相加也是一样 66

29 第 3 章 Java 中的基本数据类型和运算符 的 Java 会帮我们把基本变量转换成的字符拼接到字符串中 当字符串和基本变量进行相加的时候, 需要注意运算顺序 看下面的例程 public class StringAddPrimer { int a = 5; // 创建两个变量 int b = 7; String str1 = " 将数字的字符拼接到字符串中 :" + a; // 创建字符串 String str2 = a + b + " 加法是从左到右运算的 "; String str3 = " 加法是从左到右运算的 :" + a + b; String str4 = " 我们可以使用括号改变运算顺序 :" + (a + b); String str5 = " 我们可以使用空字符串将两个变量分开 " + a + "" + b; System.out.println(str1); // 输出字符串 System.out.println(str2); System.out.println(str3); System.out.println(str4); System.out.println(str5); 给 str1 赋值的语句展示了将字符串和 int 变量 a 相加 的运算 给 str2 赋值的语句展示了加法的运算顺序,Java 会首先计算 a + b 的值, 然后将这个值转换成字符串并拼接到后面的字符串中去 StringAddPrimer 源码给 str3 赋值的语句把 a + b 放到了后面, 结果就完全不一样了,Java 会首先将字符串与 a 相加, 相加的结果是一个字符串, 然后将这个字符串再与 b 相加, 想想 str3 的结果应该是什么呢? 给 str4 赋值的语句使用小括号提高了 a+b 的运算优先级,Java 会先计算 a + b 的值, 然后再将这个值转换成字符串与前面的字符串拼接 算算 str4 的结果应该是什么呢? 给 str5 赋值的语句貌似和 str2 一样, 只是多了一个空字符串 这个空字符串改变了运算结果 Java 首先将 a 转换成字符串, 然后将之与后面的空字符串拼接起来, 紧接着就是用这个结果 ( 字符串 ) 与后面 b 相加, 最后是与后面的结果相加 好了, 现在我们也许被这 5 个运算给弄得有点迷糊了, 运行程序, 输出如下结果 : 将数字的字符拼接到字符串中 :5 12 加法是从左到右运算的加法是从左到右运算的 :57 我们可以使用括号改变运算顺序 :12 我们可以使用空字符串将两个变量分开 57 结合前面的解释, 应该可以弄明白结果为什么是这样的 字符串与 boolean 变量的 加法 就是将 true 或者 false 拼接到字符串中, 与 char 变量的 加法 就是将这个字符串拼接到字符串中, 这里不再给出例程了 字符串 (String) 不是简单数据类型, 虽然它的用法看上去像极了基本数据类型 我们可以认为字符串是使用 char 类型组装出的类型 可以对 String 进行拼接 ( 加法 ) 操作, 完全是因为 Java 对字符串进行了 特殊处理 字符串必须用双引号括起来, 无论长度是 0, 是 1, 还是更长 字符串中可以包含任何字符 67

30 第 1 篇 Java 语言基本语法 使用字符串之前一定要给它赋值, 如果不知道赋什么值, 就给它赋值空字符串 ("") String 与基本变量之间的加法操作是将基本变量转换为字符串并拼接进去 注意 : 其实在这里介绍 String, 是因为 String 实在是太常用了, 以至于离开了 String, 我们的例程都很难编写 String 其实包含的内容很多 在这里依靠前面掌握的知识, 只需要知道 String 是一串字符就可以了, 别的属性不需要深究 还有切记的就是一定要给 String 赋值 转义符 看不见写得出 本章到这里就快结束了 本章的最后一小节中将趁热打铁介绍一下转义符 前面说过, char 类型变量可以代表任何一个字符 那么, 常用的换行字符 (NL) 它能表示吗? 答案当然是能 我们首先想到的是直接使用下面的代码将换行符赋值给一个 char 变量赋值 '; char newline = ' 首先我们自己就会觉得这么写很别扭 当尝试去编译含有这行的程序时,Java 编译器 果然会给出一个错误 这是因为 Java 无法分辨这个换行符是一行程序的结束还是一个 字符 为了美观, 更为了避免类似的困扰,Java 中使用转义符来表示换行符等一些特殊的字 符 转义符, 顾名思义, 就是将字符原来的意思转换掉 在 Java 中, \n 的意义被转换 成了换行符 也就是说,Java 编译器在遇到 \n 这两个字符的时候, 就会对它 转义, 把这两个字符当成是一个换行符 也就是说 \n 其实代表一个字符而不是两个字符 表 3-2 给出了 Java 中常用的转义符 表 3-2 转义符 转 义 符 代表的字符 转 义 符 代表的字符 \b 退格 \f 换页符 \t 制表符 \" 双引号 (") \n 换行符 \' 单引号 (') \r 回车符 \\ 反斜杠 (\) 在下面的例程中, 先来看一下转义符是如何使用的 public class ChangeMeaning { char charsinglequote = '\''; // 使用转义符给字符变量赋值单引号 char charnewline = '\n'; // 使用转义符给字符变量赋值换行符 char chardoublequotation = '"'; // 双引号不用转义符 System.out.print(charSingleQuote); // 输出这些字符 System.out.print(charNewLine); System.out.print(charDoubleQuotation); ChangeMeaning 源码 68

31 第 3 章 Java 中的基本数据类型和运算符 在上面的程序中,main() 方法的第一行创建了一个 char 变量, 然后使用单引号转义符 ( \' ) 给它赋值 没错, 在字符中表示单引号要使用转义符, 否则 Java 将分不清三个单引号在一起是什么意思 在这里, 虽然在两个单引号内写了两个字符 ( \' ), 但是因为这是转义符,Java 编译器在编译的时候会将这两个字符转换成对应的一个字符 除了转义符之外, 单引号之间只允许写一个字符 在下面一行中, 使用换行转义符 ( \n ) 给 char 变量赋值 接下来的一行, 将一个双引号字符 (") 赋值给一个 char 变量 在这里我们注意到, 虽然 Java 中双引号有转义符 ( \" ), 但是却没有使用 这是因为 Java 知道两个单引号括起来一个双引号 ('"') 就是一个双引号字符, 不会有歧义, 但是在这里也可以使用双引号的转义符, 而且, 为了增强程序的可阅读性, 建议使用转义符 在这里只是展示一下用法, 而不是推荐大家使用这种容易让人疑惑的方法来表示一个双引号字符 接下来, 使用 System.out.print 将 3 个字符输出到控制台 注意,System.out.print 是不会在输出完内容后换行的 运行程序, 在控制台会看到如下输出 : ' " 这里我们注意到, 程序首先向控制台输出了一个单引号 (charsinglequote 的值 ), 然后换了一行 (charnewline 的值 ), 最后输出了一个双引号 (chardoublequotation 的值 ) 下面看一下转义符在 String 中的使用 其实用法是一样的, 看下面的源程序 public class ChangeMeaningInString { String twolines = " 这是第一行字符串 \r\n 这是第二行字符串 "; // 在字符串中使用转义符换行 System.out.print(twoLines); 在上面的程序中, 在 main() 方法的第一行就创建了一个 String, ChangeMeaningInString 并且在里面使用了回车 ( \n ) 和换行 ( \r ) 两个转义符 源码虽然在前面的第一个例程中, 仅仅使用换行符就实现了换行功能 但是在计算机中, 为了换行, 一般需要同时使用回车换行两个字符, 这属于计算机应用方面的知识, 在这里不多讲解 运行程序, 控制台输出如下 : 这是第一行字符串这是第二行字符串 我们发现字符串按照预想的那样按照两行输出到了控制台上 注意 : 就好像我们在 char 变量中表示一个双引号字符不需要使用转义符一样, 在 String 中, 可以不使用单引号的转义符而直接写单引号, 但这并不是推荐的用法 转义符都是以反斜杠 ( \ ) 开头的, 这是转义符的标志 当 Java 编译器处理到一个反斜杠的时候, 它就会期待后面的字符可以和反斜杠一起组成一个合法的转义符, 否则 69

32 第 1 篇 Java 语言基本语法 将会报错 例如, 若在上面的程序中写下 \z,java 编译器就会输出如下错误信息 ChangeMeaningInString.java:4: 错误 : 非法转义符 String twolines = "\x 这是第一行字符串 \r\n 这是第二行字符串 "; ^ 1 个错误 可以看出, 错误提示告诉我们程序中出现了 非法转义字符 并且编译器输出的错误提示中还使用 ^ 将错误所在地标记给了我们, 就是 \x 出现的地方 如果想给一个字符赋值为反斜杠, 或者想在 String 中包含一个反斜杠字符, 那么就需要使用反斜杠的转义符 ( \\ ) 转义符是比较简单的 读者可以自己多写几个程序看看它们的作用 其实最常用的就是制表符 回车符和换行符的转义符 Java 为一些特殊字符提供了转义符 这些特殊字符有些不便书写在源程序中 ( 如换页符 退格等 ), 有些会造成 Java 源程序有歧义 ( 例如双引号 单引号反斜杠等 ) 虽然我们写了两个字符, 但是 Java 会将转义符转换成它所对应的字符, 所以最终还是一个字符 当字符或者字符串中出现反斜杠时, 就意味着要使用转义符 如果反斜杠和其后面的字符无法组成一个合法的转义符,Java 编译器将会给出 非法转义字符 错误 3.4 小结 : 基本数据类型 Java 中一切数据和运算的基础 本章中的两个主线就是 Java 基本数据类型和 Java 基本运算符 围绕这个主线, 我们学习了 Java 中的 8 种基本数据类型, 知道它们是 Java 中的数据原子 我们学会了使用运算符对它们进行运算 总的看来, 我们仿佛是在温习小学数学, 理解起来难度也不是很大 本章中我们接触了很多需要记忆的东西, 下面来回顾一下两个主线中的一些知识点 介绍了基本类型的值域 8 种基本类型都有自己的值域, 因为这些数据是保存在计算机里的, 不能像数学中那样有无限个值 每种基本变量的名字都是 Java 中的关键字 在 Java 中, 把有理数称为浮点数 浮点数在 Java 中是使用近似的值进行表达的 浮点数的这个性质影响了比较两个浮点数的方式 接触了变量的概念 变量的 3 个属性是变量名 变量值和变量类型 变量值受到变量类型的约束 其值不能够超过其类型的值域 变量名的命名规则是 Java 中的语法, 这个规则同时适用于后面将要介绍的方法名和类名 简言之,Java 中任何名字都要符合这个命名规则 命名的时候, 最好使用有意义的名字 给出了 Java 中数字类型的精度排序 这个排序有必要记下来 它和运算中类型自动转换相关 当两个基本类型变量进行运算时,Java 会把低精度的变量 精度升级 到与高精度变量相同, 然后再进行运算 同时它还和强制类型转换有关 逻辑运算符是之前可能没有接触过的, 可以多看看例程, 然后尝试写几个程序, 70

33 第 3 章 Java 中的基本数据类型和运算符 相信很快就能熟悉逻辑运算符 boolean 类型很简单, 它的值域也只有 true 和 false 而已 顺便提醒一下,true 和 false 也是 Java 中的关键字 介绍了 Java 中的强制类型转换 这是因为 Java 中有多种类型表示一个数字, 有时候需要进行不同类型变量之间的赋值和运算 需要在程序中显式地使用类型转换的情况就是将高精度的变量值赋给低精度变量 注意, 这种转换是有失精度的, 例如把 double 变量转换成 int 的时候, 就会完全丢失其小数部分 这里我们还巧妙地使用给浮点数加 0.5 再强制类型转换, 实现了四舍五入 还需要记住的是强制类型转换运算的优先级高于算数运算 一个好习惯是将运算表达式使用小括号括起来, 最后再进行强制类型转换 学会了使用 char 变量 知道了 Java 中单引号括起来一个字符就是一个 char 变量 两个 char 变量可以进行比较 等号不仅仅是赋值运算符, 它也有运算值 值就是赋值时使用的值 如果 a 是一个已经赋值了的 int 变量, 那么 a = a + a; 这行程序是正确的 同时, 围绕这两个主线, 还顺便学习了以下的知识点 分析了如何通过 Java 编译器输出的错误信息来定位和解决语法错误的一个例子 开始写程序想避免编译错误是不可能的 当遇到编译错误的时候, 需要根据 Java 编译器的输出首先定位错误, 然后仔细检查到底犯了什么语法错误 等把错误解决掉了, 最好回过头来看看这种错误是怎样造成的, 加强记忆 慢慢地就会熟悉这些错误的原因并熟练地将错误解决掉 Java 编译器很 可爱, 要学会看懂它 知道了 Java 中的注释的意义 : 解释代码的意义 程序是抽象的, 不易理解的 通过给程序添加适当的注释可以帮助理解程序 其实自己写的程序很可能不到一个月后就看上去有些陌生了, 给程序加注释是个好习惯 在 Java 中最简单的加注释的方法是使用两个连续的斜杠 (//), 然后在两个斜杠以后的内容都属于注释内容, 可以随便用一种文字写注释 注意, 别跟转义符弄混了, 转义符是使用反斜杠的 (\) 介绍了 Java 中用来判断两个浮点数是否相等的方法 介绍了程序中变量类型和变量名之间必须至少有一个空格, 用来将两者分开, 而运算符则不必 为了使程序看起来更美观, 可以使用空格让程序排列更整齐 知道了 System.out.println 和 System.out.print 的区别 初步介绍了 String 类型, 它不是基本类型 现在我们对 String 的认识是 :a. 它代表一串字符, 字符数可以为 0 到足够多 ;b. 两个 String 使用加号拼接起来 还有就是前面多次强调过的, 记得给 String 赋值, 哪怕是个空字符串 了解了 Java 中转义符的概念和转义符存在的意义 同时介绍了 Java 中常用的转义符 反斜杠 (\) 是转义符的标志 迄今为止, 我们接触到了以下 Java 中的关键字 Java 中用来表示基本数据类型的有 :byte short int long float double char 和 boolean 下面的关键字现在不用关心其含义, 只要知道它们是关键字就好了 第 1 章中, 接触了 Java 中用来修饰类的两个关键字 :public 和 class 同时还接触到了 Java 中用来修饰 main() 方法的几个关键字 :public static 和 void 本章可以算是我们与 Java 的 第一次亲密接触 前面两章中, 是在为本书后面的内 71

34 第 1 篇 Java 语言基本语法 容做准备工作 从本章开始, 就是在系统地学习 Java 这门语言了 本章中介绍的 Java 基本数据类型和 Java 基本运算符是学习 Java 的必备知识, 内容相当多, 而且不是一次就能记住并理解的 可以将本章从头温习一遍, 将例程走一遍 一定要努力看懂例程中 main() 方法内每一行程序的含义, 明白为什么可以这么写 当不小心发现了编译错误的时候, 我们需要做的就是提起精神, 仔细看 Java 编译器给出的错误信息, 定位错误, 找出错误原因, 并解决错误 初学一门编程语言, 犯错然后自己将错误修正掉是最快的成长之路, 因为这样给自己的印象是最深的 以后再次看到类似的错误, 可以马上胸有成竹地打开源代码编辑器, 将错误修正 本章中, 除了介绍两个 Java 基本数据类型和基本运算符之外, 还介绍了很多其他的内容 仿佛有点 不务正业 但是学习编程语言就是这样, 它是一个有机的整体 当讲解一个部分的时候, 难免会涉及其他的部分 这时候我们能做的就是多看, 多理解 一回生两回熟, 等用得多了见得多了, 也就慢慢增加了对 Java 语言的熟悉程度 本章中, 对 main() 方法之外的内容还是一无所知, 这个没关系 但是对于 main() 方法之内的每一行代码, 都要理解 学习完本章之后, 已经可以写一些小程序 自娱自乐 一下了 提醒大家一下, 记得源程序文件的文件名要和类名一致 不记得什么是类名了? 那么到第 1 章中再温习一下吧 还是那句话, 一回生两回熟, 书多看几遍就记住啦 3.5 习题 1. 声明两个 int 类型的变量 a 和 b, 然后给 a 赋初始值 2, 给 b 赋值 7, 计算 a 和 b 的平方和, 最后向控制台输出结果 2. 声明两个 double 类型的变量 a 和 b, 然后给 a 赋初始值 2.5, 给 b 赋值 7.5, 计算 a 和 b 的平方和, 最后向控制台输出结果 3. 声明两个 double 类型的变量 a 和 b 和一个 int 类型的变量 c 给 a 赋初始值 2.5, 给 b 赋值 7.5, 计算 a 和 b 的平方和, 并将结果四舍五入后赋值给变量 c, 最后向控制台输出 c 的值 4. 声明两个 double 类型的变量 a 和 b 和一个 boolean 类型的变量 c 然后给 a 赋初始值 8.0, 给 b 赋初始值 9.5, 比较 a 和 b 的大小, 并将结果赋值给变量 c, 最后向控制台输出 c 的值 5. 编写一个程序, 使用转义符, 向控制台输出如下内容 : 使用转义符回车换行 使用转义符输出两个 tab 字符 使用转义符输出一个双引号" 72