第1部分

Transcription

1 第 1 部分 Java 基础程序设计 Java 语言介绍 简单的 Java 程序 Java 中的变量与数据类型 运算符 表达式与语句 循环与选择结构 数组与方法的使用 第 1 页

2 第 1 章认识 Java 1.1 Java 的历史 Java 来自于 Sun 公司的一个叫 Green 的项目, 其原先的目的是为家用电子消费产品开发一个分布式代码系统, 这样就可以把 发给电冰箱 电视机等家用电器, 对它们进行控制, 和它们进行信息交流 开始他们准备采用 C++, 但 C++ 太复杂, 安全性差, 最后基于 C++ 开发一种新语言 Oak(Java 的前身 ) Oak 是一种用于网络的精巧而安全的语言,Sun 公司曾以此投标一个交互式电视项目, 但结果被 SGI 打败 于是 Oak 几乎无家可归, 恰巧这时 Mark Ardreesen 开发的 Mosaic 和 Netscape 启发了 Oak 项目组成员, 他们用 Java 编制了 HotJava 浏览器, 得到了 Sun 公司首席执行官 Scott McNealy 的支持, 触发了 Java 进军 Internet Java 技术是由美国 Sun 公司倡导和推出的, 它包括 Java 语言和 Java Media APIS Security APIs Management APIs Java Applet Java RMI JavaBean JavaOS Java Servlet JavaServer Page 以及 JDBC 等 现把 Java 技术的发展历程简述如下 : 1990 年,Sun 公司 James Gosling 领导的小组设计了一种平台独立的语言 Oak, 主要用于为各种家用电器编写程序 1995 年 1 月,Oak 被改名为 Java;1995 年 5 月 23 日,Sun 公司在 Sun World 95 上正式发布 Java 和 HotJava 浏览器 1995 年 8 月至 12 月,Netscape 公司 Oracle 公司 Borland 公司 SGI 公司 Adobe 公司 IBM 公司 AT&T 公司 Intel 公司获得 Java 许可证 1996 年 1 月,Sun 公司宣布成立新的业务部门 JavaSoft 部, 以开发 销售并支持基于 Java 技术的产品, 由 Alan Baratz 任总裁 同时推出 Java 开发工具包 JDK(Java Development Kit)1.0, 为开发人员提供用来编制 Java 应用软件所需的工具 1996 年 2 月,Sun 公司发布 Java 芯片系列, 包括 PicoJava MicroJava 和 UltraJava, 并推出 Java 数据库连接 JDBC(Java Database Connectivity) 1996 年 3 月,Sun 公司推出 Java WorkShop 第 2 页

3 1996 年 4 月,Microsoft 公司 SCO 公司 苹果电脑公司 (Apple) NEC 公司等获得 Java 许可证 Sun 公司宣布允许苹果电脑 HP 日立 IBM Microsoft Novell SGI SCO Tamdem 等公司将 Java 平台嵌入到其操作系统中 1996 年 5 月,HP 公司 Sybase 公司获得 Java 许可证 北方电讯公司宣布把 Java 技术和 Java 微处理器应用到其下一代电话机中的计划 5 月 29 日,Sun 公司在旧金山举行第一届 JavaOne 世界 Java 开发者大会, 业界人士踊跃参加 Sun 公司在大会上推出一系列 Java 平台新技术 1996 年 8 月,JavaWorkShop 成为 Sun 公司通过互联网提供的第一个产品 1996 年 9 月,Addison-Wesley 和 Sun 公司推出 Java 虚拟机规范和 Java 类库 1996 年 10 月, 德州仪器等公司获得 Java 许可证 Sun 公司提前完成 JavaBean 规范并发布, 同时发布第一个 Java JIT(Just-In-Time) 编译器, 并打算在 Java WorkShop 和 Solaris 操作系统中加入 JIT 10 月 29 日,Sun 公司发布 Java 企业计算技术, 包括 JavaStation 网络计算机 65 家公司发布的 85 个 Java 产品及应用 7 个新的 Java 培训课程及 Java 咨询服务 基于 Java 的 Solstice 互联网邮件软件 新的 Java 开发者支持服务 HotJava Views 演示 Java Tutor Java Card API 等 Sun 公司宣布完成 Java Card API 规范, 这是智能卡使用的第一个开放 API Java Card 规范将把 Java 能力赋予全世界亿万张智能卡 1996 年 11 月,IBM 公司获得 JavaOS 和 HotJava 许可证 Novell 公司获得 Java WorkShop 许可证 Sun 公司和 IBM 公司宣布双方就提供 Java 化的商业解决方案达成一项广泛协议,IBM 公司同意建立第一个 Java 检验中心 1996 年 12 月,Xerox 等公司获得 Java 或 JavaOS 许可证 Sun 公司发布 JDK1.1 Java 商贸工具包 JavaBean 开发包及一系列 Java APIs; 推出一个新的 JavaServer 产品系列, 其中包括 Java Web Server Java NC Server 和 JavaServer Toolkit Sun 公司发布 100% 纯 Java 计划, 得到百家公司的支持 1997 年 1 月,SAS 等公司获得 Java 许可证 Sun 公司交付完善的 JavaBean 开发包, 这是在确定其规范后不到 8 个月内完成的 1997 年 2 月,Sun 公司和 ARM 公司宣布同意使 JavaOS 运行在 ARM 公司的 RISC 处理器架构上 Informix 公司宣布在其 Universal Server 和其他数据库产品上支持 JDK1.1 Netscape 公司宣布其 Netscape Communicator 支持所有 Java 第 3 页

4 化的应用软件和核心 API 1997 年 3 月,HP 公司获得 Java WorkShop 许可证, 用于其 HP-UX 操作系统 西门子 AG 公司等获得 Java 许可证 日立半导体公司 Informix 公司等获得 JavaOS 许可证 Novell 公司获得 Java Studio 许可证 Sun 公司发售的 JavaOS 1.0 操作系统, 这是一种在微处理器上运行 Java 环境的最小 最快的方法, 可提供给 JavaOS 许可证持有者使用 Sun 公司发售 HotJava Browser 1.0, 这是一种 Java 浏览器, 可以方便地按需编制专用的信息应用软件, 如客户自助台和打上公司牌号的网络应用软件 1996 年 6 月,Sun 公司发布 JSP1.0, 同时推出 JDK1.3 和 Java Web Server 年 11 月,Sun 公司发布 JSP1.1, 同时推出 JSWDK1.0.1 和 Java Servlet 年 9 月,Sun 公司发布 JSP1.2 和 Java Servlet 2.3 API 1.2 Java 的现状 Java 是 Sun 公司推出的新一代面向对象程序设计语言, 特别适于 Internet 应用程序开发, 它的平台无关性直接威胁到 Wintel 的垄断地位, 这表现在以下几个方面 : 计算机产业的许多大公司购买了 Java 许可证, 包括 IBM Apple DEC Adobe SiliconGraphics HP Oracle TOSHIBA 以及 Microsoft 这一点说明,Java 已得到了业界的认可 众多的软件开发商开始支持 Java 软件产品 例如 Inprise 公司的 JBuilder Sun 公司自己做的 Java 开发环境 JDK 与 JRE Sysbase 公司和 Oracle 公司均已支持 HTML 和 Java Intranet 正在成为企业信息系统最佳的解决方案, 而其中 Java 将发挥不可替代的作用 Intranet 的目的是将 Internet 用于企业内部的信息类型, 它的优点是便宜 易于使用和管理 用户不管使用何种类型的机器和操作系统, 界面是统一的 Internet 浏览器, 而数据库 Web 页面 Applet Servlet JSP 则存储在 Web 服务器上, 无论是开发人员还是管理人员, 或是用户都可以受益于该解决方案 第 4 页

5 1.3 Java 的特点 Java 语言的优点 Java 语言是一种优秀的编程语言 它最大的优点就是与平台无关, 在 Windows 9x Windows NT Solaris Linux MacOS 以及其它平台上, 都可以使用相同的代码 一次编写, 到处运行 的特点, 使其在互联网上被广泛采用 由于 Java 语言的设计者们十分熟悉 C++ 语言, 所以在设计时很好地借鉴了 C++ 语言 可以说,Java 语言是一种比 C++ 语言 还面向对象 的一种编程语言 Java 语言的语法结构与 C++ 语言的语法结构十分相似, 这使得 C++ 程序员学习 Java 语言更加容易 当然, 如果仅仅是对 C++ 改头换面, 那么就不会有今天的 Java 热了 Java 语言提供的一些有用的新特性, 使得使用 Java 语言比 C++ 语言更容易写出 无错代码 这些新特性包括 : 1 提供了对内存的自动管理, 程序员无需在程序中进行分配 释放内存, 那些可怕的内存分配错误不会再打扰设计者了 ; 2 去除了 C++ 语言中的令人费解 容易出错的 指针, 用其它方法来进行弥补 ; 3 避免了赋值语句 ( 如 a = 3) 与逻辑运算语句 ( 如 a = = 3) 的混淆 ; 4 取消了多重继承这一复杂的概念 Java 语言的规范是公开的, 可以在 上找到它, 阅读 Java 语言的规范是提高技术水平的好方法 Java 语言的关键特性 Java 语言有许多有效的特性, 吸引着程序员们, 最主要的有以下几个 : 第 5 页

6 1. 简洁有效 Java 语言是一种相当简洁的 面向对象 程序设计语言 Java 语言省略了 C++ 语言中所有的难以理解 容易混淆的特性, 例如头文件 指针 结构 单元 运算符重载 虚拟基础类等 它更加严谨 简洁 2. 可移植性对于一个程序员而言, 写出来的程序如果不需修改就能够同时在 Windows MacOS UNIX 等平台上运行, 简直就是美梦成真的好事! 而 Java 语言就让这个原本遥不可及的事已经越来越近了 使用 Java 语言编写的程序, 只要做较少的修改, 甚至有时根本不需修改就可以在不同平台上运行了 3. 面向对象可以这么说, 面向对象 是软件工程学的一次革命, 大大提升了人类的软件开发能力, 是一个伟大的进步, 是软件发展的一个重大的里程碑 在过去的 30 年间, 面向对象 有了长足的发展, 充分体现了其自身的价值, 到现在已经形成了一个包含了 面向对象的系统分析 面向对象的系统设计 面向对象的程序设计 的完整体系 所以作为一种现代编程语言, 是不能够偏离这一方向的,Java 语言也不例外 4. 解释型 Java 语言是一种解释型语言, 相对于 C/C++ 语言来说, 用 Java 语言写出来的程序效率低, 执行速度慢 但它正是通过在不同平台上运行 Java 解释器, 对 Java 代码进行解释, 来实现 一次编写, 到处运行 的宏伟目标的 为了达到目标, 牺牲效率还是值得的, 况且, 现在的计算机技术日新月异, 运算速度也越来越快, 用户是不会感到太慢的 5. 适合分布式计算 Java 语言具有强大的 易于使用的联网能力, 非常适合开发分布式计算的程序 Java 应用程序可以像访问本地文件系统那样通过 URL 访问远程对象 使用 Java 语言编写 Socket 通信程序十分简单, 使用它比使用任何其它语言都简 第 6 页

7 单 而且它还十分适用于公共网关接口 (CGI) 脚本的开发, 另外还可以使用 Java 小 应用程序 (Applet) Java 服务器页面 (Java Server Page, 简称 JSP) Servlet 等等手段 来构建更丰富的网页 6. 拥有较好的性能正如前面所述, 由于 Java 是一种解释型语言, 所以它的执行效率相对就会慢一些, 但由于 Java 语言采用了两种手段, 使得其性能还是不错的 A Java 语言源程序编写完成后, 先使用 Java 伪编译器进行伪编译, 将其转换为中间码 ( 也称为字节码 ), 再解释 ; B 提供了一种 准实时 (Just-in-Time,JIT) 编译器, 当需要更快的速度时, 可以使用 JIT 编译器将字节码转换成机器码, 然后将其缓冲下来, 这样速度就会更快 7. 健壮 防患于未然 Java 语言在伪编译时, 做了许多早期潜在问题的检查, 并且在运行时又做了一些相应的检查, 可以说是一种最严格的 编译器 它的这种 防患于未然 的手段将许多程序中的错误扼杀在摇蓝之中 经常有许多在其它语言中必须通过运行才会暴露出来的错误, 在编译阶段就被发现了 另外, 在 Java 语言中还具备了许多保证程序稳定 健壮的特性, 有效地减少了错误, 这样使得 Java 应用程序更加健壮 8. 具有多线程处理能力线程, 是一种轻量级进程, 是现代程序设计中必不可少的一种特性 多线程处理能力使得程序能够具有更好的交互性 实时性 Java 在多线程处理方面性能超群, 具有让设计者惊喜的强大功能, 而且在 Java 语言中进行多线程处理很简单 9. 具有较高的安全性由于 Java 语言在设计时, 在安全性方面考虑很仔细, 做了许多探究, 使得 Java 语言成为目前最安全的一种程序设计语言 尽管 Sun 公司曾经许诺过 : 通过 Java 可以轻松构建出防病毒 防黑客的系统, 但 世界上没有绝对的安全 这一真理是不会因为某人的许诺而失灵验的 第 7 页

8 就在 JDK (Java Development Kit)1.0 发布不久后, 美国 Princeton( 普林斯顿 ) 大学的一组安全专家发现了 Java 1.0 安全特性中的第一例错误 从此,Java 安全方面的问题开始被关注 不过至今所发现的安全隐患都很微不足道, 而且 Java 开发组还宣称, 他们对系统安全方面的 Bugs 非常重视, 会对这些被发现的 Bugs 立即进行修复 而且由于 Sun 公司开放了 Java 解释器的细节, 所以有助于通过各界力量, 共同发现 防范 制止这些安全隐患 10. 是一种动态语言 Java 是一种动态的语言, 这表现在以下两个方面 : A 在 Java 语言中, 可以简单 直观地查询运行时的信息 ; B 可以将新代码加入到一个正在运行的程序中去 11. 是一种中性结构 Java 编译器生成的是一种中性的对象文件格式 也就是说,Java 编译器通过伪编译后, 将生成一个与任何计算机体系统无关的 中性 的字节码 这种中性结构其实并不是 Java 首创的, 在 Java 出现之前 UCSD Pascal 系统就已在一种商业产品中做到了这一点, 另外在 UCSD Pascal 之前也有这种方式的先例, 在 Niklaus Wirth 实现的 Pascal 语言中就采用了这种降低一些性能, 换取更好的可移植性和通用性的方法 Java 的这种字节码经过了许多精心的设计, 使得其能够很好地兼容于当今大多数流行的计算机系统, 在任何机器上都易于解释, 易于动态翻译成为机器代码 1.4 Java 虚拟机 (JVM) Java 虚拟机 (JVM) 是可运行 Java 代码的假想计算机 只要根据 JVM 规范描述将解 释器移植到特定的计算机上, 就能保证经过编译的任何 Java 代码能够在该系统上运 行 如图 1-1 所示 : 第 8 页

9 图 1-1 Java 虚拟机 从图 1-1 中不难明白 JAVA 可以实现可移植性的原因, 只要在操作系统上 (WINNT Linux Unix) 植入 JVM(Java 虚拟机 ),JAVA 程序就具有可移植性, 也符合 SUN 公 司提出的口号 Write Once, Run Anywhere ( 一次编写, 处处运行 ) 目前,Java 技术的架构包括以下三个方面 : J2EE (Java 2 Platform Enterprise Edition) 企业版, 是以企业为环境而开发应用程序的解决方案 J2SE (Java 2 Platform Stand Edition) 标准版, 是桌面开发和低端商务应用的解决方案 J2ME (Java 2 Platform Micro Edition) 小型版, 是致力于消费产品和嵌入式设备的最佳解决方案 第 9 页

10 1.5 JDK 的安装及环境变量的配置 要开发 Java 程序首先必须要配置好环境变量, 而 Java 的运行环境的配置比较麻 烦, 相信有些读者也会有这种体会, 下面来看一下 JDK 的安装过程 在这里 JDK 选 用的是 J2SDK1.4.2 版本 安装分为两个步骤 : 1 首先要准备好 JDK 的安装文件 :j2sdk-1_4_0_03-windows-i586 ; 2 配置环境变量 path 先来看一下步骤一的安装过程 : 图 1-2 启动 JDK 安装程序 第 10 页

11 图 1-3 将安装路径设置为 c:\j2sdk 之后走默认的安装设置即可 从图 1-1 可以看出, 在编译 Java 程序时需要用到 Javac 这个命令, 执行 Java 程序 需要 java 这个命令, 而这两个命令并不是 windows 自带的命令, 所以使用它们的时候 需要配置好环境变量, 这样就可以在任何的目录下使用这两个命令了 那么该如何设置环境变量呢? 在我的电脑上点击右键 > 选择属性 > 选择高级 > 环境变量 >path 第 11 页

12 图 1-4 系统环境变量的配置 在 path 后面加上 c:\j2sdk\bin; c:\j2sdk 是安装 JDK 的路径, 如果记不清楚了, 可回去看一下图 1-3 注意 : 在这里使用的是 windows 2000 操作系统, 至于其他的操作系统, 如 windows98 在设置环境变量的时与 windows2000 的配置有许多不同, 如果读者感兴趣, 可以去查 阅其他的资料 第 12 页

13 图 1-5 添加环境变量 这样就可以在任何目录下使用 javac 和 java 这两个命令了 1.6 编写第一个 Java 程序 说了这么多, 现在就自己来动手编写一个 Java 的程序来亲自感受一下 Java 语言的基本形式 需要说明的是,JAVA 程序分为两种形式 : 一种是网页上使用的 Applet 程序 (Java 小程序 ), 另一种是 Appliction 程序 ( 即 :Java 应用程序 ), 本书主要讲解的是 Java Application 程序 第 13 页

14 范例 :Hello.java 01 public class Hello 02 { 03 // 是程序的起点, 所有程序由此开始运行 04 public static void main(string args[]) 05 { 06 // 此语句表示向屏幕上打印 "Hello World!" 字符串 07 System.out.println("Hello World!"); 08 } 09 } 将上面的程序保存为 HelloCareers.java 文件, 并在命令行中输入 javac Hello.java, 没有错误后输入 java Hello 输出结果 : Hello World! 程序说明 : 在所有的 Java Application 中, 所有程序都是从 public static void main(string args[]), 开始运行的, 刚接触的读者可能会觉得有些难记, 在后面的章节中会详细给读者讲解 main 方法的各个组成部分 上面的程序如果暂时不明白也没有关系, 读者只要将程序一点一点都敲下来, 之 后按照步骤编译 执行, 就可以了, 在这里只是让读者对 Java Application 程序有一个 初步印象, 因为以后所有的内容讲解的都将围绕 Java Application 程序进行 1.7 classpath 的指定 在 java 中可以使用 set classpath 命令指定 java 类的执行路径 下面通过一个实验 来了解 classpath 的作用, 假设这里的 Hello.class 类位于 c:\ 盘下 第 14 页

15 在 D 盘下的命令行窗口执行下面的指令 : set classpath=c: 之后在 D 盘根目录下执行 :java Hello, 如下图所示 : 图 1-6 由上面的输出结果可以发现, 虽然在 D 盘中并没有 Hello.class 文件, 但是却也可以用 java Hello 执行 Hello.class 文件, 之所以会有这种结果, 就是因为在 D 盘中使用 set classpath 命令, 将类的查找路径指向了 C 盘, 所以在运行时, 会从 C 盘下开始查找 小提示 : 可能有些读者在按照上述的方法操作时, 发现并不好用, 这里要告诉读者的是, 在设置 classpath 时, 最好将 classpath 指向当前目录, 即 : 所有的 class 文件都从当前文件夹中开始查找 : set classpath=. 第 15 页

16 本章摘要 : 1 Java 程序比较特殊, 它必须先经过编译, 然后再利用解释的方式来运行 2 Byte-codes 最大的好处是 可越平台运行, 可让 一次编写, 处处运行 成为可能 3 使用 classpath 可以指定 class 的运行路径 第 16 页

17 第 2 章简单的 Java 程序 从本章开始, 就要正式学习 Java 语言的程序设计, 除了认识程序的架构外, 本章 还介绍了修饰符 关键字以及一些基本的数据类型 通过简单的范例, 让读者了解到 检测与提高程序可读性的方法, 以培养读者正确的程序编写观念与习惯 2.1 一个简单的例子 首先来看一个简单的 Java 程序 在介绍程序的内容之前, 先简单回顾一下第一章 讲解的例子, 之后再来看下面这个程序, 试试看是否看得出它是在做哪些事情! 范例 :TestJava2_1.java 01 // TestJava2_1.java,java 的简单范例 02 public class TestJava2_1 03 { 04 public static void main(string args[]) 05 { 06 int num ; // 声明一个整型变量 num 07 num = 3 ; // 将整型变量赋值为 3 08 // 输出字符串, 这里用 "+" 号连接变量 09 System.out.println(" 这是数字 "+num); 10 System.out.println(" 我有 "+num+" 本书!"); 11 } 12 } 输出结果 : 这是数字 3 我有 3 本书! 如果现在看不懂上面的这个程序也没有关系, 先将它敲进 Java 编辑器里, 将它存 盘 编辑 运行, 就可以看到上面的输出结果 第 17 页

18 从上面的输出结果中可以看出 System.out.println() 的作用, 就是输出括号内所包含 的文字, 至于 public class static void 这些关键字的意思, 将在以后的章节中再做 更深入一层的探讨 程序说明 : 1 第 1 行为程序的注释,Java 语言的注释是以 / / 标志开始的, 注释有助于对程序的阅读与检测, 被注释的内容在编译时不会被执行 2 第 2 行 public class TestJava2_1 中的 public 与 class 是 Java 的关键字,class 为 类 的意思, 后面接上类名称, 在本程序中取名为 TestJava2_1 public 则是用来表示该类为公有, 也就是在整个程序里都可以访问到它 需要注意的是, 如果将一个类声明成 public, 则也要将文件名称取成和这个类一样的名称, 如图 2-1 所示 本例中的文件名为 TestJava2_1.java, 而 public 之后所接的类名称也为 TestJava2_1 也就是说, 在一个 Java 文件里, 最多只能有一个 public 类, 否则.java 的文件便无法命名 图 2-1 如果将类声明成 public, 则也要将文件名称取成和这个类一样的名称 3 第 4 行 public static void main(string args[]) 为程序运行的起点 第 4~10 行的功能类似于一般程序语言中的函数 (function), 但在 Java 中称之为 method( 方法 ) 因此 C 语言里的 main() 函数 ( 主函数 ), 在 Java 中则被称为 main() method( 主方法 ) 4 main() method 的主体 (body) 从第 5 行的左大括号 { 到第 11 行的右大括号 } 第 18 页

19 为止 每一个独立的 Java 程序一定要有 main() method 才能运行, 因为它是程序开始运行的起点 5 第 6 行 int num; 的目的是声明 num 为一个整数类型的变量 在使用变量之前必须先声明其类型 6 第 7 行 num=3; 为一赋值语句, 即把整数 2 赋给存放整数的变量 num 7 第 8 行的语句为 : System.out.println(" 这是数字 "+num); 程序运行时会在显示器上输出引号 ( ) 内所包含的内容 包括 这是数字 和整数变量 num 所存放的值两部分内容 8 System.out 是指标准输出, 通常与计算机的接口设备有关, 如打印机 显示器等 其后所续的文字 println, 是由 print 与 line 所组成的, 意思是将后面括号中的内容打印在标准输出设备 显示器上 因此第 8 行的语句执行完后会换行, 也就是把光标移到下一行的开头继续输出 读者可以把 System.out.println(), 改成 System.out.print(), 看一下换行与不换行的区别 9 第 10 行的右大括号则告诉编译器 main() method 到这儿结束 10 第 11 行的右大括号则告诉编译器 class TestJava2_1 到这儿结束 这里只是简单的介绍了一下 TestJava2_1 这个程序, 相信读者已经对 Java 语 言有了初步的了解 TestJava2_1 程序虽然很短, 却是一个相当完整的 Java 程序! 在后面的章节中, 将会对 Java 语言的细节部分, 做详细的讨论 2.2 简单的 Java 程序解析 本节将仔细探讨 Java 语言的一些基本规则及用法 第 19 页

20 2.2.1 类 (class) Java 程序是由类 (class) 所组成, 至于类的概念在以后会有详细讲解, 读者只要 先记住所有的 Java 程序都是由类组成的就可以了 下面的程序片段即为定义类的典型 范例 : public class Test { } // 定义 public 类 Test 上面的程序定义了一个新的 public 类 Test, 这个类的原始程序的文件名称应取名为 Test.java 类 Test 的范围由一对大括号所包含 public 是 Java 的关键字, 指的是对于类的访问方式为公有 需要读者注意的是, 由于 Java 程序是由类所组成, 因此在完整的 Java 程序里, 至少需要有一个类 此外, 本书曾在前面提到过在 Java 程序中, 其原始程序的文件名不能随意命名, 必须和 public 类名称一样, 因此在一个独立的原始程序里, 只能有一个 public 类, 却可以有许多 non-public 类 此外, 若是在一个 Java 程序中没有一个类是 public, 那么该 Java 程序的文件名就可以随意命名了 大括号 段及主体 将类名称定出之后, 就可以开始编写类的内容 左大括号 { 为类的主体开始标记, 而整个类的主体至右大括号 } 结束 每个命令语句结束时, 必须以分号 ; 做结尾 当某个命令的语句不只一行时, 必须以一对大括号 {} 将这些语句包括起来, 形成一个程序段 (segment) 或是块 (block) 再以一个简单的程序为例来说明什么是段与主体 若是暂时看不懂 TestJava2_2 第 20 页

21 这个程序, 也不用担心, 慢慢的都会讲到该程序中所用到的命令 在下面的程序中, 可以看到 main() method 的主体以左右大括号包围起来 ;for 循环中的语句不只一行, 所以使用左右大括号将属于 for 循环的段内容包围起来 ; 整个程序语句的内容又被第 3 与第 13 行的左右大括号包围, 这个块属于 public 类 TestJava2_2 所有 此外, 应该注意到每个语句结束时, 都是以分号作为结尾 范例 :TestJava2_2.java 程序运行的起始点 main() method Java 程序是由一个或一个以上的类组合而成, 程序起始的主体也是被包含在类之 中 这个起始的地方称为 main(), 用左右大括号将属于 main() 段内容包围起来, 称之 第 21 页

22 为 method( 方法 ) main() 方法为程序的主方法, 在一个 Java 程序中有且只能有一个 main() 方法, 它 是程序运行的开端, 通常看到的 main() method 如下面的语句片段所示 : public static void main(string args[]) { } // main() method, 主程序开始 如前一节所述,main() method 之前必须加上 public static void 这三个标识符 public 代表 main() 公有的 method;static 表示 main() 在没有创建类对象的情况下, 仍然可以被运行 ;void 则表示 main() 方法没有返回值 Main 后的括号 () 中的参数 String args[] 表示运行该程序时所需要的参数, 这是固定的用法, 如果现在不了解也没有关系, 在以后的章节中会一一介绍 Java 程序的注释 为程序添加注释可以用来解释程序的某些语句的作用和功能, 提高程序的可读性 也可以使用注释在原程序中插入设计者的个人信息 此外, 还可以用程序注释来暂时屏蔽某些程序语句, 让编译器暂时不要处理这部分语句, 等到需要处理的时候, 只需把注释标记取消就可以了,Java 里的注释根据不同的用途分为三种类型 : 单行注释 多行注释 文档注释 单行注释, 就是在注释内容前面加双斜线 (//),Java 编译器会忽略掉这部分信息 如下所示 : int num ; // 定义一个整数 多行注释, 就是在注释内容前面以单斜线加一个星形标记 (/*) 开头, 并在注释 内容末尾以一个星形标记加单斜线 (*/) 结束 当注释内容超过一行时一般使用这种 第 22 页

23 方法, 如下所示 : /* */ int c = 10 ; int x = 5 ; 文档注释, 是以单斜线加两个星形标记 (/**) 开头, 并以一个星形标记加单斜线 (*/) 结束 用这种方法注释的内容会被解释成程序的正式文档, 并能包含进如 javadoc 之类的工具生成的文档里, 用以说明该程序的层次结构及其方法 Java 中的标识符 Java 中的包 类 方法 参数和变量的名字, 可由任意顺序的大小写字母 数字 下划线 (_) 和美元符号 ($) 组成, 但标识符不能以数字开头, 不能是 Java 中的保留关键字 下面是合法的标识符 : yourname your_name _yourname $yourname 下面是非法的标识符 : class 67.9 Hello Careers! 小提示 : 一些刚接触编程语言的读者可能会觉得记住上面的规则很麻烦, 所以在这里 提醒读者, 标识符最好永远用字母开头, 而且尽量不要包含其他的符号 第 23 页

24 2.2.6 Java 的关键字 和其他语言一样,Java 中也有许多保留关键字, 如 public static 等, 这些保留关 键字不能当作标识符使用 下面列出了 Java 中的保留关键字, 这些关键字并不需要读 者去强记, 因为一旦使用了这些关键字做标识符时, 编辑器会自动提示错误 Java 中的保留关键字 : abstract boolean break byte case catch char class continue default do double else extend false final finally float for if implement import instanceof int interface long native new null package private protected public return short static synchronized super this throw throws transient true try void volatile while 要特别注意的是, 虽然 goto const 在 Java 中并没有任何意义, 却也是保留字, 与其它的关键字一样, 在程序里不能用来做为自定义的标识符 变量 变量在程序语言中扮演了最基本的角色 变量可以用来存放数据, 而使用变量之 前必须先声明它所预保存的数据类型 接下来, 来看看在 Java 中变量的使用规则 变量的声明 举例来说, 想在程序中声明一个可以存放整数的变量, 这个变量的名称为 num, 第 24 页

25 在程序中即可写出如下所示的语句 : int num; // 声明 num 为整数变量 int 为 Java 的关键字, 代表整数 (Integer) 的声明 若要同时声明多个整型的变量, 可以像上面的语句一样分别声明它们, 也可以把它们都写在同一个语句中, 每个变量 之间以逗号分开, 如下面的写法 : int num,num1,num2 ; // 同时声明 num,num1,num2 为整数变量 变量的数据类型 除了整数类型之外,Java 还提供了多种其它的数据类型 Java 的变量类型可以是整型 (int) 长整型(long) 短整型(short) 浮点型(float) 双精度浮点型(double) 等, 除了这些数据类型外, 还有字符型 (char) 或字符串型 (String) 关于这些数据类型, 本书在第三章中有详细的介绍 变量名称 读者可以依据个人的喜好来决定变量的名称, 这些变量的名称不能使用到 Java 的关键字 通常会以变量所代表的意义来取名 ( 如 num 代表数字 ) 当然也可以使用 a b c 等简单的英文字母代表变量, 但是当程序很大时, 需要的变量数量会很多, 这些简单名称所代表的意义就比较容易忘记, 必然会增加阅读及调试程序的困难度 变量名称的限制 同 所述标识符的名称限制 第 25 页

26 2.2.8 变量的设置 给所声明的变量赋予一个属于它的值, 用等号运算符 (=) 来实现 具体可使用 如下所示的三种方法进行设置 : 方法 1 在声明变量的时设置 举例来说, 在程序中声明一个整数的变量 num, 并直接把这个变量赋值为 2, 可 以在程序中写出如下的语句 : int num = 2 ; // 声明变量, 并直接设置 方法 2 声明后再设置一般来说也可以在声明后再给变量赋值 举例来说, 在程序中声明整数的变量 num1 num2 及字符变量 ch, 并且给它们分别赋值, 在程序中即可写出如下面的语句 : int num1,num2 ; // 声明变量 char c ; num1 = 2 ; num2 = 3 ; ch = 'z' ; // 赋值给变量 方法 3 在程序中的任何位置声明并设置 以声明一个整数的变量 num 为例, 可以等到要使用这个变量时, 再给它赋值 : int num ; num = 2 ; // 声明变量 // 用到变量时, 再赋值 println() 读者会发现从第 1 章开始, 所有的例题中出现了不少次的 System.out.println(), 第 26 页

27 在本节中, 就先了解一下 println() 至于详细的使用方法, 在第三章会讲到 System.out 是指标准输出, 通常与计算机的接口设备有关, 如打印机 显示器等 其后所连接的 println, 是由 print 与 line 所组成的, 意义是将后面括号中的内容打印在标准输出设备 显示器上 左 右括号之间的内容, 即是欲打印到显示器中的参数, 参数可以是字符 字符串 数值 常量或是表达式, 参数与参数之间以括号作为间隔 当参数为字符串时以一对双引号 ( ) 包围 ; 变量则直接将其名称做为参数 ; 表达式作为参数时, 要用括号将表达式包围起来 举例来说, 想在屏幕上输出 我有 20 本书!, 其中 20 以变量 num 代替, 程序的编写如下 : 范例 :TestJava2_3.java 01 // 下面这段程序采用声明变量并赋值的方式, 之后在屏幕上打印输出 02 public class TestJava2_3 03 { 04 public static void main(string args[]) 05 { 06 int num = 2 ; // 声明变量并直接赋值为 2 07 System.out.println(" 我有 "+num+" 本书! "); 08 } 09 } 输出结果 : 我有 20 本书! 在 TestJava2_3 程序中,println() 中的变量共有三个, 以加号连接这些将被打印的 数据 在此, 加号是 合并 的意思, 并非作为算术运算符号的用途 2.3 程序的检测 现在相信读者大概可以依葫芦画瓢似地写出几个类似的程序了, 接下来, 要对读 者做一些小检测! 看看读者是否能够准确地找出下面的程序中存在错误 : 第 27 页

28 范例 :TestJava2_4.java 01 // 下面程序的错误属于语法错误, 在编译的时候会自动检测到 02 public class TestJava2_4 03 { 04 public static void main(string args[]) 05 { 06 int num1 = 2 ; // 声明整数变量 num1, 并赋值为 2 07 int num2 = 3 ; 声明整数变量 num2, 并赋值为 System.out.println(" 我有 "+num1" 本书!"); 10 System.out.println(" 你有 "+num2+" 本书!") 11 ) 12 } 语法错误 程序 TestJava2_4 在语法上犯了几个错误, 若是通过编译器编译, 便可以把这些错误找出来 首先, 可以看到第 4 行,main() method 的主体以左大括号开始, 应以右大括号结束 所有括号的出现都是成双成对的, 因此第 11 行 main() method 主体结束时应以右大括号做结尾, 而 Careers2_4 中却以右括号 ) 结束 注释的符号为 //, 但是在第 7 行的注释中, 没有加上 // 在第 9 行, 字符串的连接中少了一个 + 号, 最后, 还可以看到在第 10 行的语句结束时, 少了分号作为结束 上述的三个错误均属于语法错误 当编译程序发现程序语法有错误时, 会把这些错误的位置指出, 并告诉设计者错误的类型, 即可以根据编译程序所给予的信息加以更正 将程序更改后重新编译, 若还是有错误, 再依照上述的方法重复测试, 这些错误就将会被一一改正, 直到没有错误为止 上面的程序经过检测 调试之后运行的结果如下 : 第 28 页

29 输出结果 我有 2 本书! 你有 3 本书! 语义错误 当程序本身的语法都没有错误, 但是运行后的结果却不符合设计者的要求, 此时 可能犯了语义错误, 也就是程序逻辑上的错误 读者会发现, 想要找出语义错误会比 找语法错误更难, 以下面的程序进行简单的说明 : 范例 :TestJava2_5.java 01 // 下面这段程序原本是要计算一共有多少本书, 但是由于错把加号写成了减号, // 所以造成了输出结果不正确属于语义错误 02 public class TestJava2_5 03 { 04 public static void main(string args[]) 05 { 06 int num1 = 4 ; // 声明一整型变量 num1 07 int num2 = 5 ; // 声明一整型变量 num System.out.println(" 我有 "+num1+" 本书! "); 10 System.out.println(" 你有 "+num2+" 本书! "); 11 // 输出 num1-num2 的值 s 12 System.out.println(" 我们一共有 "+(num1-num2)+ " 本书! "); 13 } 14 } 输出结果 : 我有 4 本书! 你有 5 本书! 我们一共有 1 本书! 第 29 页

30 可以发现, 在程序编译过程中并没有发现错误, 但是运行后的结果却是不正确的, 这种错误就是语义错误, 就是在第 12 行中, 因失误将 num1+num2 写成了 num1-num2, 虽然语法是正确的, 但是却不符合程序的要求, 只要将错误更正后, 程序的运行结果就是想要的了 2.4 提高程序的可读性 能够写出一个程序的确很让人兴奋, 但如果这个程序除了本人之外, 其他人都很难读懂, 那这就不算是一个好的程序, 所以每个程序设计者在设计程序的时候, 也要学习程序设计的规范格式, 除了前面所说的加上注释之外, 还应当保持适当的缩进, 可以看见上面的范例程序都是按缩进的方法编写的, 是不是觉得看起来很清晰 明白? 读者可以比较下面两个程序, 相信看完之后, 就会明白程序中使用缩进的好处了! 范例 :TestJava2_6.java 01 // 以下这段程序是有缩进的样例, 可以发现这样的程序看起来比较清楚 02 public class Careers2_6 03 { 04 public static void main(string args[]) 05 { 06 int x ; for(x=1;x<=3;x++) 09 { 10 System.out.print("x = "+x+", "); 11 System.out.println("x * x = "+(x*x)); 12 } 13 } 14 } 第 30 页

31 下面是没有缩进的例子 : 范例 :TestJava2_7.java 01 // 下面的程序于前面程序的输出结果是一样的, 但不同的是, // 这个程序没有采用任何缩进, 所以看起来很累 02 public class TestJava2_7{ 03 public static void main(string args[]){ 04 int x ; for(x=1;x<=3;x++){ 05 System.out.print("x = "+x+", "); 06 System.out.println("x * x = "+(x*x));}}} TestJava2_7 这个例子虽然简短, 而且语法也没有错误, 但是因为编写风格的关系, 阅读起来肯定没有 TestJava2_6 这个程序好读, 所以建议读者尽量使用缩进, 养成良好 的编程习惯 范例 TestJava2_6 和 TestJava2_7 运行后的输出结果如下 : x = 1, x * x = 1 x = 2, x * x = 4 x = 3, x * x = 9 第 31 页

32 本章摘要 : 1 Java 语言的注释方式有三种 : (1) // 记号开始, 至该行结束 ; (2) /* 与 */ 这两个符号之间的文字 ; (3) 文档注释 2 如果将一个类声明成 public, 则它的文件名称必须取成这个类的名称才能顺利编译 3 main() 在 Java 里是一个相当特殊的 method, 它一定要声明成 public, 使得在类的其它地方皆可调用到它, 且 main() method 没有返回值, 所以在它之前要加上 void 关键字 4 System.out 是指标准输出, 其后所连接的 println 是由 print 与 line 所组成的, 意思是将后面括号中的内容打印在标准输出设备 显示器上 5 由于 Java 程序是由类所组成, 所以在完整的 Java 程序里, 必须且至少有一个类 6 Java 的变量名称可以由英文字母 数字 下划线 (_) 和美元符号 ($) 组成, 但标识符不能以数字开头, 也不能是 Java 中的保留关键字 此外,Java 的变量有大小写之分 7 变量的设置有以下三种方法 : 在声明的时候设置 声明后再设置 在程序中的任何位置声明并设置 8 提高程序可读性的方法有 : (1) 在程序中加上批注 ; (2) 为变量取个有意义的名称 ; (3) 保持每一行只有一个语句 ; (4) 适当的缩进 第 32 页

33 第 3 章 Java 基本程序设计 3.1 变量与数据类型 变量是利用声明的方式, 将内存中的某个块保留下来以供程序使用 可以声明为块记载的数据类型为整型 字符型 浮点型或是其他数据类型, 作为变量的保存之用 本章将就变量及各种数据类型做一个基础性地介绍 数据类型在程序语言的构成要素里, 占有相当重要的地位 Java 的数据类型可分为原始数据类型与引用数据类型 原始数据类型也称为基本数据类型, 它们包括了最基本的 boolean byte char short int long float 与 double 等类型 另一种数据类型为引用数据类型, 它是以一种特殊的方式指向变量的实体, 这种机制类似于 C / C++ 的指针 这类的变量在声明时是不会分配内存的, 必须另外进行开辟内存空间的操作, 如字符串与数组均属于这种数据类型 变量与常量 下面先来看一个简单的实例, 好让读者了解 Java 里变量与常量之间的关系, 下面 的程序里声明了两种 Java 经常使用到的变量, 分别为整型变量 num 与字符变量 ch 为它们赋值后, 再把它们的值分别显示在显示器上 : 范例 :TestJava3_1.java 01 // 下面的程序声明了两个变量, 一个是整型, 一个是字符型 02 public class TestJava 3_1 03 { 04 public static void main(string args[]) 05 { 06 int num = 3 ; // 声明一整型变量 num, 赋值为 3 07 char ch = 'z'; // 声明一字符变量 ch, 赋值为 z 第 33 页

34 08 System.out.println(num+ " 是整数!"); // 输出 num 的值 09 System.out.println(ch + " 是字符!"); // 输出 ch 的值 10 } 11 } 输出结果 : 3 是整数! z 是字符! 在 TestJava 3_1 中, 声明了两种不同类型的变量 num 与 ch, 并分别将常量 3 与字符 z 赋值给这两个变量, 最后再将它们显示在显示器上 声明一个变量时, 编译程序会在内存里开辟一块足以容纳此变量的内存空间给它 不管变量的值如何改变, 都永远使用相同的内存空间 因此, 善用变量将会是一种节省内存的方式 常量是不同于变量的一种类型, 它的值是固定的, 例如整数常量 字符串常量 通常给变量赋值时, 会将常量赋值给它, 在程序 TestJava 3_1 中, 第 6 行 num 是整型变量, 而 3 则是常量 此行的作用是声明 num 为整型变量, 并把常量 3 这个值赋给它 相同的, 第 7 行声明了一个字符变量 ch, 并将字符常量 'z' 赋给它 当然, 在程序进行的过程中, 可以为变量重新赋值, 也可以使用已经声明过的变量 Java 的变量类型 在 Java 中规定了八种基本数据类型变量来存储整数 浮点数 字符和布尔值 如 图 3-1 所示 : 第 34 页

35 图 3-1 Java 的变量类型 在这里只是先介绍基本数据类型, 引用数据类型会在以后的章节中介绍 基本数据类型 到目前为止, 相信读者已经对 Java 有了一些初步的认识, 如果想在程序中使用一 个变量, 就必须先声明, 此时编译程序会在未使用的内存空间中寻找一块足够能保存 这个变量的空间以供这个变量使用 Java 的基本数据类型如表 3-1 所示 表 3-1 Java 的基本数据类型 数据类型 字节 表示范围 long( 长整数 ) ~ int( 整数 ) ~ short( 短整数 ) ~ byte( 位 ) ~ 127 char() 1 0 ~ 255 boolean() 1 布尔值只能使用 true 或 false float() 4-3.4E38( ) ~ 3.4E38( ) double() 8-1.7E308( )~ 1.7E308( ) 第 35 页

36 整数类型 当数据不带有小数或分数时, 即可以声明为整数变量, 如 3,-147 等即为整数 Java 中, 整数数据类型可以分为 long int short 及 byte 四种 :long 为 64 位, 也就是 8 个字节 (bytes), 可表示范围为 到 ;int 为 32 位, 也就是 4 个字节, 表示范围为 到 ; 若是数据值的范围在 到 之间时, 可以声明为 short( 短整数 ) 类型 ; 若是数据值更小, 在 -128 到 127 之间时, 可以声明为 byte 类型以节省内存空间 举例来说, 想声明一个短整型变量 sum 时, 可以在程序中做出如下的声明 : short sum ; // 声明 snum 为短整型 经过声明之后,Java 即会在可使用的内存空间中, 寻找一个占有 2 个字节的块供 sum 变量使用, 同时这个变量的范围只能在 到 之间 常量的数据类型 有趣的是,Java 把整数常量的数据类型均视为 int 型, 因此, 如果在程序中使用 了超过 这个大小的常量, 编译时将发生错误, 如下面的范例 : 范例 :TestJava3_2.java 01 // 下面这段程序说明了值的可取范围的问题 02 public class TestJava3_2 03 { 04 public static void main(string args[]) 05 { 06 long num = ; // 声明一长整型变量 07 System.out.println( num = +num); 08 } 09 } 第 36 页

37 如果编译上面的程序代码, 将会得到下列的错误信息 : TestJava3_2.java:5: integer number too large: long num = ; 这是因为把整数常量看成是 int 类型, 但 这个整数已超出了 int 类型所能表示的范围, 因此虽然把 num 的类型设为 long, 但编译时仍然会发生错误 要解决这个问题, 只要在整数常量后面加上一个大写的 L 即可, 此举代表该常量是 long 类型的整数常量 所以只要把第 6 行的语句改成 : 06 long num = L ; 即可成功地编译运行 数据类型的最大值与最小值 Java 提供了 long int short 及 byte 四种整数类型的最大值 最小值的代码, 以方便设计者使用 最大值的代码是 MAX_VALUE, 最小值是 MIN_VALUE 如果要取用某个类型的最大值或最小值, 只要在这些代码之前, 加上它们所属的类的全名即可 举例来说, 如果程序代码里需要用到长整数的最大值, 如图 3-2 所示的语法表示 图 3-2 代码的表示法 由上面的语法可知, 如果要使用某个类型的代码, 则必须先指定该类型所在的类 库以及该类型所属的类, 但因 java.lang 这个类库属于常用类库, 所以默认的 Java 程序 会将它加载, 因此在实际的应用上设计者可以将它省略 第 37 页

38 Java 所提供的整数的最大值与最小值的标识符及常量值, 可在表 3-2 中查阅 若 是读者现在不懂什么叫类库也没有关系, 现在只要会使用它就行了 表 3-2 整数常量的特殊值代码 Long int 使用类全名 java.lang.long java.lang.integer 最大值代码 MAX_VALUE MAX_VALUE 最大值常量 最小值代码 MIN_VALUE MIN_VALUE 最小值常量 short byte 使用类全名 java.lang.short java.lang.byte 最大值代码 MAX_VALUE MAX_VALUE 最大值常量 最小值代码 MIN_VALUE MIN_VALUE 最小值常量 下面程序是输出 Java 定义的四种整数类型的常量的最大和最小值, 可以将程序与 上表做对照 比较 范例 :TestJava3_3.java 01 // 下面这段程序调用了表 3-2 中的方法, 可以得到数据类型的最大值和最小值 02 public class TestJava3_3 03 { 04 public static void main(string args[]) 05 { 06 long long_max = java.lang.long.max_value ;// 得到长整型的最大值 07 int int_max = java.lang.integer.max_value ; // 得到整型的最大值 08 short short_max = Short.MAX_VALUE ; // 得到短整型的最大值 09 byte byte_max = Byte.MAX_VALUE ; // 得到 Byte 型的最大值 System.out.println("LONG 的最大值 : "+long_max); 第 38 页

39 12 System.out.println("INT 的最大值 :"+int_max); 13 System.out.println("SHORT 的最大值 :"+short_max); 14 System.out.println("BYTE 的最大值 :"+byte_max); 15 } 16 } 输出结果 : LONG 的最大值 : INT 的最大值 : SHORT 的最大值 :32767 BYTE 的最大值 :127 程序 TestJava3_3 列出了各种整数类型的最大值, 通过它的运行, 读者可以了解到 Java 对于整数的最大值 最小值的规定 读者可以自己改写程序, 输出一下最小值 溢出的发生 当整数的数据大小超出了可以表示的范围, 而程序中又没有做数值范围的检查时, 这个整型变量所输出的值将发生紊乱, 且不是预期的运行结果 在下面的程序范例中, 声明了一个整型的数, 并把它赋值为整型所可以表示范围的最大值, 然后将它分别加 1 及加 2 范例 :TestJava3_4.java 01 // 整数值如果超出了自己所可以表示范围的最大值, 会出现溢出 02 public class TestJava3_4 03 { 04 public static void main(string args[]) 05 { 06 int x = java.lang.integer.max_value ; // 得到整型的最大值 System.out.println("x = "+x); 第 39 页

40 09 System.out.println("x+1 = "+(x+1)); 10 System.out.println("x+2 = "+(x+2)); 11 } 12 } 输出结果 : x = x+1 = x+2 = 当最大值加上 1 时, 结果反而变成表示范围中最小的值 ; 当最大值加上 2 时, 结果变成表示范围中次小的值, 这就是数据类型的溢出 读者可以发现, 这个情形会出现一个循环, 若是想避免这种情况的发生, 在程序中就必须加上数值范围的检查功能, 或者使用较大的表示范围的数据类型, 如长整型 当声明了一整数 i, 其表示的范围为 ~ 之间, 当 i 的值设为最大值 , 仍在整数的范围内, 但是当 x 加 1 或加 2 时, 整数 x 的值反而变成 和 , 成为可表示范围的最小及次小值 上述的情形就像计数器的内容到最大值时会自动归零一样 而在整数中最小值为 , 所以当整数 x 的值最大时, 加上 1 就会变成最小值 , 也就是产生了溢出 可以参考图 3-3 来了解数据类型的溢出问题 图 3-3 数据类型的溢出 为了避免 int 类型的溢出, 可以在该表达式中的任一常量后加上大写的 L, 或 是在变量前面加上 long, 作为强制类型的转换 以 TestJava3_5 为例, 在下面的程序中 加上防止溢出的处理, 为了让读者方便比较, 特地保留一个整数的溢出语句 第 40 页

41 范例 :TestJava3_5.java 01 // 下面的这段程序当整型发生溢出之后, 用强制类型进行转换 02 public class TestJava3_5 03 { 04 public static void main(string args[]) 05 { 06 int x = java.lang.integer.max_value ; System.out.println("x = "+x); 09 System.out.println("x + 1 = "+(x+1)); 10 System.out.println("x + 2 = "+(x+2l)); 11 System.out.println("x + 3 = "+((long)x+3)); 12 } 13 } 输出结果 : x = x + 1 = x + 2 = x + 3 = 程序说明 : 1 第 6 行声明 int 类型的整数变量 x, 并赋值为整数最大值, 即 第 8 行输出 x 的值, 即 : 第 9 行输出 x+1 的值, 此时溢出发生, 运行结果变成 第 10 行输出 x+2 的值, 为了避免溢出发生, 在表达式的常量部分 2 后加上 L, 执行结果变成 第 11 行输出 x+3 的值, 为了避免溢出发生, 在表达式的整数部分 x 之前加上 long, 执行结果变成 由上面的程序可知, 处理 int 类型的溢出, 可以利用强制类型转换方式 但是对 于 long 类型的溢出, 就没有处理办法了, 此时就需要在程序中加上变量值的界限检查, 第 41 页

42 在运行时才不会发生错误 字符类型 字符类型在内存中占有 2 个字节, 可以用来保存英文字母等字符 计算机处理字符类型时, 是把这些字符当成不同的整数来看待, 因此, 严格说来, 字符类型也算是整数类型的一种 在计算机的世界里, 所有的文字 数值都只是一连串的 0 与 1 这些 0 与 1 对于设计者来说实在是难以理解, 于是就产生了各种方式的编码 它们指定一个数值来代表某个字符, 如常用的字符码系统 ASCII 虽然各类的编码系统合起来有数百种之多, 却没有一种是包含足够的字符 标点符号及常用的专业技术符号 这些编码系统之间可能还会有相互冲突的情形发生, 也就是说, 不同的编码系统可能会使用相同的数值来表示不同的字符, 在数据跨平台的时候就会发生错误 Unicode 就是为了避免上述情况的发生而产生的, 它为每个字符制订了一个唯一的数值, 因此在任何的语言 平台 程序中都可以安心地使用 Java 所使用的就是 Unicode 字符码系统 举例来说,Unicode 中的小写 a 是以 97 来表示, 在下面的程序中可以看到, 声明字符类型的变量 ch1 ch2, 分别将变量 ch1 的值设为 97,ch2 的值设为字符 a, 再输出字符变量 ch1 及 ch2 的内容 范例 :TestJava3_6.java 01 // 字符类型也可以直接赋给数值, 下面的这段程序就是采用这种赋值方式 02 public class TestJava3_6 03 { 04 public static void main(string args[]) 05 { 06 char ch1 = 97 ; 07 char ch2 = 'a' ; System.out.println("ch1 = "+ch1); 第 42 页

43 10 System.out.println("ch2 = "+ch2); 11 } 12 } 输出结果 : ch1 = a ch2 = a 给字符变量在赋值可以使用数值和字符, 它们都可以使程序正确地运行 要注意的是, 字符要用一对单引号 (' ') 括起 举例来说, 想在程序中输出一个包括双引号的字符串时, 可把字符变量赋值为转义字符, 再将它输出来, 也就是说, 在程序中声明一个字符类型变量 ch, 然后把 ch 设置为 \", 再进行输出的操作 或者, 也可以直接在要输出的字符串中加入特殊的转义字符 表 3-3 为常用的转义字符 : 表 3-3 常用的转义字符 转义字符 所代表的意义 转义字符 所代表的意义 \f 换页 \\ 反斜线 \b 倒退一格 \' 单引号 \r 归位 \" 双引号 \t 跳格 \n 换行 以下面的程序为例, 将 ch 赋值为 \" ( 要以单引号 (') 包围 ), 并将字符变量 ch 输出在显示器上, 同时在打印的字符串里直接加入转义字符, 读者可自行比较一下 两种方式的差异 范例 :TestJava3_7.java 01 // 下面这道程序表明了转义字符的使用方法 02 public class TestJava3_7 03 { 04 public static void main(string args[]) 05 { 06 char ch =' \" '; 第 43 页

44 07 08 System.out.println(ch+" 测试转义字符!"+ch); 09 System.out.println("\"hello world!\""); 10 } 11 } 输出结果 : " 测试转义字符!" "hello world!" 不管是用变量存放转义字符, 或是直接使用转义字符的方式来输出字符串, 程序都可以顺利运行 由于使用变量会占用内存资源, 似乎显得有些不妥 ; 当然也可以不必声明字符变量就可以输出转义字符, 但如果在程序中加上太多的转移字符, 以至于造成混淆而不易阅读时, 利用声明字符变量的方式就是一个很好的选择 浮点数类型与双精度浮点数类型 在日常生活中经常会使用到小数类型的数值, 如身高 体重等需要精确的数值时, 整数就不能满足程序设计者的要求了 在数学中, 这些带有小数点的数值称为实数, 在 Java 里, 这种数据类型称为浮点数类型 (float), 其长度为 4 个字节, 有效范围为 到 当浮点数的表示范围不够大的时候, 还有一种双精度 (double) 浮点数可供使用 双精度浮点数类型的长度为 8 个字节, 有效范围为 到 浮点数的表示方式, 除了指数的形式外, 还可用带有小数点的一般形式来表示 举例来说, 想声明一个 double 类型的变量 num 与一个 float 类型的变量 sum, 并同时给 sum 赋初值 3.0, 可以在程序中做出如下的声明及设置 : double num ; // 声明 sum 为双精度浮点型变量 float sum = 3.0f ; // 声明 sum 为浮点型变量, 其初值为 3.0 声明之后,Java 即会在可使用的内存空间中, 寻找一个占有 8 个字节的块供 num 第 44 页

45 变量使用, 其范围在 到 之间, 寻找另一个占有 4 个字节的块供 sum 变量使用, 而这个变量的范围只能在 到 之间 在此例中,sum 的初 值为 3.0 下列为声明与设置 float 与 double 类型的变量时应注意的事项 : double num1 = -6.3e64 ; // 声明 num1 为 double, 其值为 double num2 = -5.34E16 ; // e 也可以用大写的 E 来取代 float num3 = 7.32f ; // 声明 num3 为 float, 并设初值为 7.32f float num4 = 2.456E67 ; // 错误, 因为 已超过 float 可表示的范围 值得一提的是, 使用浮点型数值时, 默认的类型是 double, 在数值后面可加上 D 或是 d, 作为 double 类型的标识 在 Java 中,D 或 d 是可有可无的 在数据后面加上 F 或是 f, 则作为 float 类型的识别 若是没有加上,Java 就会将该数据视为 double 类型, 而在编译时就会发生错误, 错误提示会告诉设计者可能会失去精确度 下面举一个简单的例子, 在下面的程序里, 声明一个 float 类型的变量 num, 并赋值为 3.0, 将 num*num 的运算结构输出到显示器上 范例 :TestJava3_8.java 01 // 下面这道程序说明了浮点数类型的使用方法 02 public class TestJava3_8 03 { 04 public static void main(string args[]) 05 { 06 float num = 3.0f ; 07 System.out.println(num+" *"+num+" = "+(num*num)); 08 } 09 } 输出结果 : 3.0 * 3.0 = 9.0 第 45 页

46 Java 也提供了浮点数类型的最大值与最小值的代码, 其所使用的类全名与所代表 的值的范围, 可以在表 3-4 中查阅 : 表 3-4 浮点数常量的特殊值 float double 使用类全名 java.lang.float java.lang.double 最大值 MAX_VALUE MAX_VALUE 最大值常量 E E308 最小值 MIN_VALUE MIN_VALUE 最小值常量 1.4E E-324 相同的, 在类全名中, 可以省去类库 java.lang, 直接取用类名称即可 下面的程 序是输出 float 与 double 两种浮点数类型的最大与最小值, 读者可以将下面程序的输 出结果与上表一一进行比较 范例 :TestJava3_9.java 01 // 下面这道程序用于取得单精度和双精度浮点数类型的最大 最小值 02 public class TestJava3_9 03 { 04 public static void main(string args[]) 05 { 06 System.out.println("float_max = "+java.lang.float.max_value); 07 System.out.println("float_min = "+java.lang.float.min_value); 08 System.out.println("double_max = "+java.lang.double.max_value); 09 System.out.println("double_min = "+java.lang.double.min_value); 10 } 11 } 输出结果 : float_max = E38 float_min = 1.4E-45 double_max = E308 double_min = 4.9E-324 第 46 页

47 布尔类型 布尔 (boolean) 类型的变量, 只有 true( 真 ) 和 false( 假 ) 两种 也就是说, 当将一个变量定义成布尔类型时, 它的值只能是 true 或 false, 除此之外, 没有其他的值可以赋值给这个变量 举例来说, 想声明名称为 status 变量为的布尔类型, 并设置为 true 值, 可以使用下面的语句 : boolean status = true ; // 声明布尔变量 status, 并赋值为 true 经过声明之后, 布尔变量的初值即为 true, 当然如果在程序中需要更改 status 的 值时, 即可以随时更改 将上述的内容写成了程序 TestJava3_10, 读者可以先熟悉一 下布尔变量的使用 : 范例 :TestJava3_10.java 01 // 下面的程序声明了一个布尔值类型的变量 02 public class TestJava3_10 03 { 04 public static void main(string args[]) 05 { 06 // 声明一布尔型的变量 status, 布尔型只有两个值一个是 true 一个是 false 08 boolean status = true ; 09 System.out.println("status = "+status); 10 } 11 } 输出结果 : status = true 布尔值通常用来控制程序的流程, 读者可能会觉得有些抽象, 本书会陆续在后面 的章节中介绍布尔值在程序流程中所起的作用 第 47 页

48 基本数据类型的默认值 在 Java 中, 若在变量的声明时没有给变量赋初值, 则会给该变量赋默认值, 表 3-5 列出了各种类型的默认值 表 3-5 基本数据类型的默认值 数据类型 默认值 byte (byte)0 short (short)0 int 0 long 0L float 0.0f double 0.0d char \u0000( 空 ) boolean false 在某些情形下,Java 会给予这些没有赋初始值的变量一个确切的默认值, 但这没有任何意义, 是没有必要的, 但应该保证程序执行时, 不会有这种未定义值的变量存在 虽然这种方式给程序编写者带来了很多便利, 但是过于依赖系统给变量赋初值, 就不容易检测到是否已经给予变量应有的值了, 这是个需要注意的问题 数据类型的转换 Java 的数据类型在定义时就已经确定了, 因此不能随意转换成其它的数据类型, 但 Java 容许用户有限度地做类型转换处理 数据类型的转换方式可分为 自动类型转 换 及 强制类型转换 两种 第 48 页

49 自动类型转换 在程序中已经定义好了数据类型的变量, 若是想用另一种数据类型表示时,Java 会在下列的条件皆成立时, 自动做数据类型的转换 : 1 转换前的数据类型与转换后的类型兼容 2 转换后的数据类型的表示范围比转换前的类型大 举例来说, 若是想将 short 类型的变量 a 转换为 int 类型, 由于 short 与 int 皆为整数类型, 符合上述条件 1; 而 int 的表示范围比 short 大, 亦符合条件 2 因此 Java 会自动将原为 short 类型的变量 a 转换为 int 类型 值得注意的是, 类型的转换只限该行语句, 并不会影响原先所定义的变量的类型, 而且通过自动类型的转换, 可以保证数据的精确度, 它不会因为转换而损失数据内容 这种类型的转换方式也称为扩大转换 前面曾经提到过, 若是整数的类型为 short 或 byte, 为了避免溢出,Java 会将表达式中的 short 和 byte 类型自动转换成 int 类型, 即可保证其运算结果的正确性, 这也是 Java 所提供的 扩大转换 功能 以 扩大转换 来看可能比较容易理解 字符与整数是可使用自动类型转换的 ; 整数与浮点数亦是兼容的 ; 但是由于 boolean 类型只能存放 true 或 flase, 与整数及字符是不兼容, 因此是不可能做类型的转换 接下来看看当两个数中有一个为浮点数时, 其运算的结果会有什么样的变化? 范例 :TestJava3_11.java 01 // 下面这段程序声明了两个变量, 一个是整型, 一个是浮点型 02 public class TestJava3_11 03 { 04 public static void main(string args[]) 05 { 06 int a = 156 ; 07 float b = 24.1f ; // 声明一浮点型变量 f, 并赋值 System.out.println("a = "+a+", b = "+b); 第 49 页

50 10 System.out.println("a / b = "+(a/b)); // 这里整型会自动转化为浮点型 11 } 12 } 输出结果 : a = 156, b = 24.0 a / b = 6.5 从运行的结果可以看出, 当两个数中有一个为浮点数时, 其运算的结果会直接转换为浮点数 当表达式中变量的类型不同时,Java 会自动以较小的表示范围转换成较大的表示范围后, 再作运算 也就是说, 假设有一个整数和双精度浮点数作运算时, Java 会把整数转换成双精度浮点数后再作运算, 运算结果也会变成双精度浮点数 关于表达式的数据类型转换, 在后面的章节中会有更详细的介绍 强制类型转换 当两个整数进行运算时, 其运算的结果也会是整数 举例来说, 当做整数除法 8/3 的运算, 其结果为整数 2, 并不是实际的 , 因此在 Java 中若是想要得到计算 的结果是浮点数时, 就必须将数据类型做强制性的转换, 转换的语法如下 : 格式 3-1 数据类型的强制性转换语法 ( 欲转换的数据类型 ) 变量名称 ; 因为这种强制类型的转换是直接编写在程序代码中的, 所以也称为显性转换 下 面的程序说明了在 Java 里, 整数与浮点数是如何转换的 范例 :TestJava3_12 01 // 下面范例中说明了自动转换和强制转换这两种转换的使用方法 02 public class TestJava3_12 03 { 04 public static void main(string args[]) 05 { 第 50 页

51 06 int a = 55 ; 07 int b= 9 ; 08 float g,h ; System.out.println("a = "+a+", b = "+b); 11 g = a/b ; 12 System.out.println("a / b ="+g+"\n"); 13 System.out.println("a = "+a+", b = "+b); 14 h = (float)a/b ; // 在这里将数据类型进行强制类型转换 15 System.out.println("a /b = "+h); 16 } 17 } 输出结果 : a = 55, b = 9 a / b = 6.0 a = 55, b = 9 a /b = 当两个整数相除时, 小数点以后的数字会被截断, 使得运算的结果保持为整数 但由于这并不是预期的计算结果, 而想要得到运算的结果为浮点数, 就必须将两个整 数中的其中一个 ( 或是两个 ) 强制转换类型为浮点数, 下面的三种写法都正确 : (1) (float)a/b // 将整数 a 强制转换成浮点数, 再与整数 b 相除 (2) a/(float)b // 将整数 b 强制转换成浮点数, 再以整数 a 除之 (3) (float)a/(/float)b // 将整数 a 与 b 同时强制转换成浮点数, 再相除 只要在变量前面加上欲转换的数据类型, 运行时就会自动将此行语句里的变量做类型转换的处理, 但这并不影响原先所定义的数据类型 此外, 若是将一个超出该变量可表示范围的值赋值给这个变量时, 这种转换称为缩小转换 由于在转换的过程中可能会丢失数据的精确度,Java 并不会自动做这些类型的转换, 此时就必须要做强制性的转换 第 51 页

52 3.2 运算符 表达式与语句 程序是由许多语句组成的, 而语句的基本单位是表达式与运算符 本章将介绍 Java 运算符的用法 表达式与运算符之间的关系, 以及表达式里各种变量的数据类型的转 换等 学完本章, 希望读者能对 Java 语句的运作过程有更深一层的认识 表达式与运算符 Java 中的语句有很多种形式, 表达式就是其中一种形式 表达式是由操作数与运算符所组成 : 操作数可以是常量 变量也可以是方法, 而运算符就是数学中的运算符号, 如 + - * / % 等 以下面的表达式 (z+100) 为例, z 与 100 都是操作数, 而 + 就是运算符 图 3-4 表达式是由操作数与运算符所组成 Java 提供了许多的运算符, 这些运算符除了可以处理一般的数学运算外, 还可以 做逻辑运算 地址运算等 根据其所使用的类的不同, 运算符可分为赋值运算符 算 术运算符 关系运算符 逻辑运算符 条件运算符 括号运算符等 赋值运算符号 想为各种不同数据类型的变量赋值时, 就必须使用赋值运算符 (=), 表 3-6 中所 列出的赋值运算符虽然只有一个, 但它却是 Java 语言中必不可缺的 第 52 页

53 表 3-6 赋值运算符 赋值运算符号 意义 = 赋值 等号 (=) 在 Java 中并不是 等于 的意思, 而是 赋值 的意思 还记得在前 几章中, 为变量赋值的语句吗? 图 3-5 表达式的赋值范例 上面的语句是将整数 22 赋值给 num 这个变量 再来看看下面这个语句 num = num 3 // 将 num-3 的值运算之后再赋值给变量 num 存放 从未学习过 C 或 C++ 的读者, 可能会不习惯这种思考方式 若是把等号 (=) 当成 等于, 这种语句在数学上根本说不通, 但是把它看成 赋值 时, 这个语句就很容易理解了, 把 num-3 的值运算之后再赋值给 num 存放, 因为之前已经把 num 的值设为 22, 所以执行这个语句时,Java 会先处理等号后面的部分 num-3( 值为 19), 再赋值给等号前面的变量 num, 执行后, 存放在变量 num 的值就变成了 19 了 将上面的语句编写成下面这个程序 : 范例 :TestJava3_13.java 01 // 在程序中赋值采用 = 02 public class TestJava4_1 03 { 04 public static void main(string args[]) 05 { 06 int num = 22 ; // 声明整数变量 num, 并赋值为 22 第 53 页

54 07 08 System.out.println(" 第一次赋值后,num = "+num); // 输出 num 的值 num = num 3 ; // 将变量 num 的值减三之后再赋给 num 变量 11 System.out.println(" 改变之后的值,num = "+num);// 输出计算后 num 的值 12 } 13 } 输出结果 : 第一次赋值后,num = 22 改变之后的值,num = 19 当然, 在程序中也可以将等号后面的值赋值给其他的变量, 如 : in sum = num1+num2 ; // num1 与 num2 相加之后的值再赋给变量 sum 存放 内容 num1 与 num2 的值经过运算后仍然保持不变,sum 会因为 赋值 的操作而更改 一元运算符 对于大部分的表达式而言, 运算符的前后都会有操作数 但是有一种运算符较特别, 它只需要一个操作数, 称为一元运算符 下面的语句就是由一元运算符与一个操作数所组成的 +3 ; // 表示正 3 ~a ; // 表示取 a 的补码 b = -a ; // 表示负 a 的值赋值给变量 b 存放!a ; // a 的 NOT 运算, 若 a 为零, 则!a 为 1, 若 a 不为零, 则!a 为零 表 3-7 列出了一元运算符的成员 : 第 54 页

55 表 3-7 一元运算符 一元运算符意义 + 正号 负号! NOT, 否 ~ 取补码 下面的程序声明了 byte 类型的变量 a 及 boolean 类型的变量 b, 可以看到两个变 量分别进行了 ~ 与! 运算之后的结果 范例 :TestJava3_14.java 01 // 下面这段程序说明了一元运算符的使用 02 public class TestJava3_14 03 { 04 public static void main(string args[]) 05 { 06 byte a = java.lang.byte.max_value ; // 声明并将其类型最大值赋给 a 07 boolean b = false ; System.out.println("a = "+a+", ~a = "+(~a)); 10 System.out.println("b = "+b+",!b = "+(!b)); 11 } 12 } 输出结果 : a = 127, ~a = 128 b = false,!b = true 程序说明 : 1 第 6 行声明了 byte 变量 a, 并赋值为该类型的最大值, 即 a 的值为 127 程序第 7 行, 声明 boolean 变量 b, 赋值为 false 2 第 9 行输出 a 与 ~a 的运算结果 第 55 页

56 3 第 10 行输出 b 与!b 的运算结果 b 的值为 flase, 因此进行! 运算后,b 的值 就变成了 true 算术运算符 算术运算符在数学上面经常会使用到, 表 3-8 列出了它的成员 : 表 3-8 算术运算符 算术运算符意义 + 加法 减法 * 乘法 / 除法 % 余数 加法运算符 + 将加法运算符 + 的前后两个操作数相加 如下面的语句 : System.out.println("3 + 8 = "+(3+8)); // 直接输出表达式的值 减法运算符 - 将减法运算符 前面的操作数减去后面的操作数, 如下面的语句 : num = num 3 ; a = b c ; // 将 num-3 运算之后赋值给 num 存放 // 将 b c 运算之后赋值给 a 存放 ; // 运算 的值 第 56 页

57 乘法运算符 * 将乘法运算符 * 的前后两个操作数相乘, 如下面的语句 : b = b * 5 ; a = a *a ; // 将 b*5 运算之后赋值给 b 存放 // 将 a * a 运算之后赋值给 a 存放 19 * 2 ; // 运算 19 * 2 的值 除法运算符 / 将除法运算符 / 前面的操作数除以后面的操作数, 如下面的语句 : a = b / 5 ; c = c / d ; // 将 b / 5 运算之后的值赋给 a 存放 // 将 c / d 运算之后的值赋给 c 存放 15 / 5 ; // 运算 14 / 7 的值 使用除法运算符时要特别注意一点, 就是数据类型的问题 以上面的例子来说当 a b c d 的类型皆为整数, 若是运算的结果不能整除时, 输出的结果与实际的值会有差异, 这是因为整数类型的变量无法保存小数点后面的数据, 因此在声明数据类型及输出时要特别小心 以下面的程序为例, 在程序里给两个整型变量 a b 赋值, 并将 a / b 的运算结果输出 : 范例 :TestJava3_15.java 01 // 下面这段程序说明了除法运算符的使用方法 02 public class TestJava3_15 03 { 04 public static void main(string[] args) 05 { 06 int a = 13 ; 07 int b = 4 ; System.out.println("a = "+a+", b = "+b); 10 System.out.println("a / b = "+(a/b)); 11 System.out.println("a / b = "+((float)a/b)); // 进行强制类型转换 第 57 页

58 12 } 13 } 输出结果 : a = 13, b = 4 a / b = 3 a / b = 3.25 程序说明 : 1 第 10 行与 11 行, 程序分别做出不同的输出 : 第 10 行中, 因为 a,b 皆为整数类型, 输出结果也会是整数类型, 程序运行结果与实际的值不同 2 第 11 行中, 为了保证程序运行结果与实际的值相同, 所以使用了强制性的类型转换, 即将整数类型 (int) 转换成浮点数类型 (float), 程序运行的结果才不会有问题 余数运算符 % 将余数运算符 % 前面的操作数除以后面的操作数, 取其所得到的余数 下面 的语句是余数运算符的使用范例 : num = num % 3 ; a = b % c ; // 将 num%3 运算之后赋值给 num 存放 // 将 b%c 运算之后赋值给 a 存放 100 % 7 ; // 运算 100%7 的值 以下面的程序为例, 声明两个整型变量 a b, 并分别赋值为 5 和 3, 再将 a%b 的运算结果输出 范例 :TestJava3_16.java 01 // 在 JAVA 中用 % 进行取模操作 02 public class TestJava3_16 03 { 第 58 页

59 04 public static void main(string[] args) 05 { 06 int a = 5 ; 07 int b = 3 ; System.out.println(a+" % "+b+" = "+(a%b)); 10 System.out.println(b+" % "+a+" = "+(b%a)); 11 } 12 } 输出结果 : 5 % 3 = 2 3 % 5 = 关系运算符与 if 语句 设计者常常会在 if 语句中使用到关系运算符, 所以有必要先来认识 if 语句的用法 if 语句的格式如下 : 格式 3-2 if 语句的格式 if ( 判断条件 ) 语句 ; 如果括号中的判断条件成立, 就会执行后面的语句 ; 若是判断条件不成立, 则后 面的语句就不会被执行, 如下面的程序片段 : if (x>0) System.out.println("I like Java!"); 当 x 的值大于 0, 就是判断条件成立时, 会执行输出字符串 I like Java! 的操作 ; 相反, 当 x 的值为 0 或是小于 0 时,if 语句的判断条件不成立, 就不会执行上述操作 第 59 页

60 了 表 3-9 列出了关系运算符的成员, 这些运算符在数学上也是经常使用的 表 3-9 关系运算符 关系运算符 意义 > 大于 < 小于 >= 大于等于 <= 小于等于 == 等于!= 不等于 在 Java 中, 关系运算符的表示方式和在数学中很类似, 但是由于赋值运算符为 =, 为了避免混淆, 当使用关系运算符 等于 (==) 时, 就必须用 2 个等号表示 ; 而关系运算符 不等于 的形式有些特别, 用!= 代表, 这是因为在键盘上想要取得数学上的不等于符号 较为困难, 所以就用!= 表示不等于 当使用关系运算符去判断一个表达式的成立与否时, 若是判断式成立会产生一个响应值 true, 若是判断式不成立则会产生响应值 false 以下面的程序为例, 判断 if 语句括号中的条件是否成立, 若是成立则执行 if 后面的语句 范例 :TestJava3_17.java 01 // 下面这段程序说明了关系运算符的使用方法, 关系运算符返回值为布尔值 02 public class TestJava3_17 03 { 04 public static void main(string[] args) 05 { 06 if(5>2) 07 System.out.println(" 返回值 :"+(5>2)); if(true) 10 System.out.println("Hello Java!"); 第 60 页

61 11 12 if((3+6)==(3-6)) 13 System.out.println("I like Java!"); 14 } 15 } 输出结果 : 返回值 :true Hello Java! 程序说明 : 1 在第 6 行中, 由于 5>2 的条件成立, 所以执行第 7 行的语句 : 输出返回值 true 2 在第 9 行中, 若是 if 语句的参数为 true, 判断亦成立, 所以接着执行第 10 行的语句 : 输出字符串 Hello TestJava! 3 第 12 行,3+6 并不等于 3-6,if 的判断条件不成立, 所以第 13 行语句不被执行 递增与递减运算符 递增与递减运算符在 C / C++ 中就已经存在了,Java 仍然将它们保留了下来, 是 因为它们具有相当大的便利性 表 3-10 列出了递增与递减运算符的成员 表 3-10 递增与递减运算符 递增与递减运算符 意义 ++ 递增, 变量值加 1 -- 递减, 变量值减 1 善用递增与递减运算符可使程序更加简洁 例如, 声明一个 int 类型的变量 a, 在 程序运行中想让它加 1, 语句如下 : a = a+1 ; // a 加 1 后再赋值给 a 存放 将 a 的值加 1 后再赋值给 a 存放 也可以利用递增运算符 ++ 写出更简洁的语 第 61 页

62 句, 而语句的意义是相同的 : a++ ; // a 加 1 后再赋值给 a 存放,a++ 为简洁写法 在程序中还可以看到另外一种递增运算符 ++ 的用法, 就是递增运算符 ++ 在变量的前面, 如 ++a, 这和 a++ 所代表的意义是不一样的 a++ 会先执行整个语句后再将 a 的值加 1, 而 ++b 则先把 b 的值加 1 后, 再执行整个语句 以下面的程序为例, 将 a 与 b 的值皆设为 3, 将 a++ 及 ++b 输出来, 可以轻易地比较出两者的不同 范例 :TestJava3_18.java 01 // 下面这段程序说明了 ++ 的两种用法的使用 02 public class TestJava3_18 03 { 04 public static void main(string args[]) 05 { 06 int a = 3, b = 3 ; System.out.print("a = "+a); // 输出 a 09 System.out.println(", a++ = "+(a++)+", a= "+a); // 输出 a++ 和 a 10 System.out.print("b = "+b); // 输出 b 11 System.out.println(", ++b = "+(++b)+", b= "+b); // 输出 ++b 和 b 12 } 13 } 输出结果 : a = 3, a++ = 3, a= 4 b = 3, ++b = 4, b= 4 程序说明 : 1 在第 9 行中, 输出 a++ 及运算后的 a 的值, 所以执行完 a++ 后,a 的值才会加 1, 变成 4 2 程序的第 11 行中, 输出 ++b 运算后 b 的值, 所以执行 ++b 前,b 的值即先加 1, 变成 4 同样的, 递减运算符 -- 的使用方式和递增运算符 ++ 是相同的, 递增 第 62 页

63 运算符 ++ 用来将变量值加 1, 而递减运算符 -- 则是用来将变量值减 1 此外, 递增与递减运算符只能将变量加 1 或减 1, 若是想要将变量加减非 1 的数 时, 还是得用原来的 a = a+2 的方法 逻辑运算符 在 if 语句中也可以看到逻辑运算符, 表 3-11 列出了它的成员 表 3-11 逻辑运算符 逻辑运算符 意义 && AND, 与 OR, 或 当使用逻辑运算符 && 时, 运算符前后的两个操作数的返回值皆为真, 运算的结 果才会为真 ; 使用逻辑运算符 时, 运算符前后的两个操作数的返回值只要有一个 为真, 运算的结果就会为真, 如下面的语句 : (1) a>0 && b> 0 // 两个操作数皆为真, 运算结果才为真 (2) a>0 b>0 // 两个操作数只要一个为真, 运算结果就为真 在第 1 个例子中, a>0 而且 b>0 时, 表达式的返回值为 true, 即表示这两个条件 必须同时成立才行 ; 在第 2 个例子中, 只要 a>0 或者 b>0, 表达式的返回值即为 true, 这两个条件仅需要一个成立即可, 读者可以参考表 3-12 中所列出的结果 : 表 3-12 AND 及 OR 结果表 条件 1 条件 2 结果 &&( 与 ) ( 或 ) true true true true true false false true false true false true false false false false 第 63 页

64 由表 3-12 可以看出, 在条件中, 只要有一个条件为假 (false), 相与的结果就是假 (false); 相反的如果有一个条件为真 (true), 那么相或的结果就为真 (true) 下面的这个程序是判断 a 的值是否在 0~100 之间, 如果不在即表示成绩输入错误 ; 若是 a 的值在 50~60 之间, 则需要补考 范例 :TestJava3_19.java 01 // 下面这段程序是对与操作进行的说明, 返回值为布尔类型 02 public class TestJava3_19 03 { 04 public static void main(string[] args) 05 { 06 int a = 56 ; if((a<0) (a>100)) 09 System.out.println(" 输入的数据有错误!"); 10 if((a<60)&&(a>49)) 11 System.out.println(" 准备补考吧!"); 12 } 13 } 输出结果 : 准备补考吧! 程序说明 : 1 当程序执行到第 8 行时,if 会根据括号中 a 的值作判断,a<0 或是 a>100 时, 条件判断成立, 即会执行第 9 行的语句 : 输出字符串 输入的数据有错误! 由于学生成绩是介于 0~100 分之间, 因此当 a 的值不在这个范围时, 就会视为是输入错误 2 不管第 9 行是否有执行, 都会接着执行第 10 行的程序 if 再根据括号中 a 的值做判断,a<60 且 a>49 时, 条件判断成立, 表示该成绩需要进行补考, 即会执行第 11 行的语句, 输出 准备补考吧! 第 64 页

65 括号运算符 除了前面所述的内容外, 括号 () 也是 Java 的运算符, 如表 3-13 所示 : 表 3-13 括号运算符 括号运算符 意义 () 提高括号中表达式的优先级 括号运算符 () 是用来处理表达式的优先级的 以一个简单的加减乘除式子为例 : 3+5+4*6-7 // 未加括号的表达式 相信根据读者现在所学过的数学知识, 这道题应该很容易解开 加减乘除的优先级 (* / 的优先级大于 + -) 来计算结果, 这个式子的答案为 25 但是如果想先计算 及 6-7 之后再将两数相乘时, 就必须将 及 6-7 分别加上括号, 而成为下面的式子 : (3+5+4)*(6-7) // 加上括号的表达式 经过括号运算符 () 的运作后, 计算结果为 -12, 所以括号运算符 () 可以使括 号内表达式的处理顺序优先 运算符的优先级 表 3-14 列出了各个运算符的优先级的排列, 数字越小的表示优先级越高 第 65 页

66 表 3-14 运算符的优先级 优先级 运算符 类 结合性 1 () 括号运算符 由左至右 1 [] 方括号运算符 由左至右 2! +( 正号 ) -( 负号 ) 一元运算符 由右至左 2 ~ 位逻辑运算符 由右至左 递增与递减运算符 由右至左 3 * / % 算术运算符 由左至右 算术运算符 由左至右 5 << >> 位左移 右移运算符 由左至右 6 > >= < <= 关系运算符 由左至右 7 ==!= 关系运算符 由左至右 8 &( 位运算符 AND) 位逻辑运算符 由左至右 9 ^( 位运算符号 XOR) 位逻辑运算符 由左至右 10 ( 位运算符号 OR) 位逻辑运算符 由左至右 11 && 逻辑运算符 由左至右 12 逻辑运算符 由左至右 13?: 条件运算符 由右至左 14 = 赋值运算符 由右至左 表 3-14 的最后一栏是运算符的结合性 什么是结合性呢? 结合性可以让程序设计者了解到运算符与操作数之间的关系及其相对位置 举例来说, 当使用同一优先级的运算符时, 结合性就非常重要了, 它决定谁会先被处理 读者可以看看下面的例子 : a = b +d / 5 * 4 ; 这个表达式中含有不同优先级的运算符, 其中是 / 与 * 的优先级高于 +, 而 + 又高于 =, 但是读者会发现, / 与 * 的优先级是相同的, 到底 d 该先除以 5 再乘以 4 呢? 还是 5 乘以 4 后 d 再除以这个结果呢? 结合性的定义, 就解决了这方面的困扰, 算术运算符的结合性为 由左至右, 就是在相同优先级的运算符中, 先由运算符左边的操作数开始处理, 再处理右边的操作数 上面的式子中, 由于 / 与 * 的优先级相同, 因此 d 会先除以 5 再乘以 4 得到的结果如上 b 后, 将整个值赋给 a 存放 第 66 页

67 3.2.3 表达式 表达式是由常量 变量或是其他操作数与运算符所组合而成的语句, 如下面例子, 均是表达式正确的使用方法 : -49 // 表达式由一元运算符 - 与常量 49 组成 sum + 2 // 表达式由变量 sum 算术运算符与常量 2 组成 a + b c / ( d * 3 9 ) // 表达式由变量 常量与运算符所组成 此外,Java 还有一些相当简洁的写法, 是将算术运算符和赋值运算符结合成为新 的运算符, 表 3-15 列出了这些运算符 表 3-15 简洁的表达式 运算符 范例用法 说明 意义 += a += b a + b 的值存放到 a 中 a = a + b -= a -= b a - b 的值存放到 a 中 a = a - b *= a *= b a * b 的值存放到 a 中 a = a * b /= a /= b a / b 的值存放到 a 中 a = a / b %= a %= b a % b 的值存放到 a 中 a = a % b 下面的几个表达式, 皆是简洁的写法 : a++ // 相当于 a = a + 1 a -= 5 // 相当于 a = a 5 b %= c a /= b-- // 相当于 b = b % c // 相当于计算 a = a / b 之后, 再计算 b-- 这种独特的写法虽然看起来有些怪异, 但是它却可以减少程序的行数, 提高运行 的速度! 看下面这道范例 : 第 67 页

68 范例 :TestJava3_20.java 01 // 下面是关于简洁写法的一段程序 02 public class TestJava3_20 03 { 04 public static void main(string[] args) 05 { 06 int a = 5, b = 8 ; System.out.println(" 改变之前的数是 : a = "+a+", b = "+b); 09 a +=b ; 10 System.out.println(" 改变之后的数是 : a = "+a+", b = "+b); 11 } 12 } 输出结果 : 改变之前的数是 : a = 5, b = 8 改变之后的数是 : a = 13, b = 8 程序说明 : 1 第 6 行分别把变量 a b 赋值为 5 及 8 2 第 8 行在运算之前先输出变量 a b 的值,a 为 5,b 为 8 3 第 9 行计算 a+=b, 这个语句也就相当于 a = a +b, 将 a+b 的值存放到 a 中 计算 5+8 的结果后赋值给 a 存放 4 程序第 10 行, 再输出运算之后变量 a b 的值 所以 a 的值变成 13, 而 b 仍为 8 除了前面所提到的算术运算符和赋值运算符的结合可以存在于简洁的表达式中, 递增 递减运算符也同样可以应用在简洁的表达式中 表 3-16 列出了一些简洁写法的 运算符及其范例说明 第 68 页

69 表 3-16 简洁表达式的范例 运算符 范例 执行前执行后说明 a b a b += a += b 12 4 a + b 的值存放到 a 中 ( 同 a = a + b) = a -= b 12 4 a - b 的值存放到 a 中 ( 同 a = a b) 8 4 *= a *= b 12 4 a * b 的值存放到 a 中 ( 同 a = a * b) 48 4 /= a /= b 12 4 a / b 的值存放到 a 中 ( 同 a = a / b) 3 4 %= a %= b 12 4 a % b 的值存放到 a 中 ( 同 a = a % b) 0 4 B++ a *= b a * b 的值存放到 a 后,b 加 1 ( 同 a = a * b;b++) b a *= ++b 12 4 b 加 1 后, 再将 a*b 的值存放到 a ( 同 b++;a=a*b) 60 5 b-- a *= b a * b 的值存放到 a 后,b 减 1 ( 同 a=a*b;b--) b a *= --b 12 4 b 减 1 后, 再将 a*b 的值存放到 a ( 同 b--;a=a*b) 36 3 举一个实例来说明这些简洁的表达式在程序中该如何应用 以 TestJava3_21 为例, 输入两个数, 经过运算之后, 来看看这两个变量所存放的值有什么变化 范例 :TestJava3_21.java 01 // 下面的程序说明了简洁表达式的使用方法, 但这种方式现在已不提倡使用了 02 public class TestJava3_21 03 { 04 public static void main(string[] args) 05 { 06 int a = 10, b = 6 ; System.out.println(" 改变之前的数 : a = "+a+", b = "+b); 09 a -= b++ ; // 先计算 a-b 的值, 将结果设给 a 之后, 再将 b 值加 1 10 System.out.println(" 改变之后的数 : a = "+a+", b = "+b); 11 } 12 } 第 69 页

70 输出结果 : 改变之前的数 : a = 10, b = 6 改变之后的数 : a = 4, b = 7 程序说明 : 1 第 8 行输出运算前变量 a b 的值 在程序中 a b 的赋值为 10 6, 因此输出的结果 a 为 10,b 为 6 2 第 9 行计算 a -= b++, 也就是执行下面这两个语句 : a = a- b ; //(a = 10-6 = 4, 所以 a = 4) b++ ; //(b = b+1 = 6+1 = 7, 所以 b = 7) 3 程序第 10 行, 将经过运算之后的结果输出, 即可得到 a 为 4,b 为 7 的答案 表达式的类型转换 当 int 类型遇上了 float 类型, 到底谁是 赢家 呢? 在前面曾提到过数据类型的转换, 在这里, 要再一次详细讨论表达式的类型转换 Java 是一个很有弹性的程序设计语言, 当上述的情况发生时, 只要坚持 以不流失数据为前提 的大原则, 即可做不同的类型转换, 使不同类型的数据 表达式都能继续存储 依照大原则, 当 Java 发现程序的表达式中有类型不相符的情况时, 会依据下列的规则来处理类型的转换 1 占用字节较少的类型转换成占用字节较多的类型 2 字符类型会转换成 int 类型 3 int 类型会转换成 float 类型 4 表达式中若某个操作数的类型为 double, 则另一个操作数字也会转换成 double 类型 5 布尔类型不能转换成其它类型 第 70 页

71 范例 :TestJava3_22.java 01 // 下面的程序说明了表达式类型的自动转换问题 02 public class TestJava3_22 03 { 04 public static void main(string[] args) 05 { 06 char ch = 'a' ; 07 short a = -2 ; 08 int b = 3 ; 09 float f = 5.3f ; 10 double d = 6.28 ; System.out.print("(ch / a) - (d / f) - (a + b) = "); 13 System.out.println((ch / a) - (d / f) - (a + b)); 14 } 15 } 输出结果 : (ch / a) - (d / f) - (a + b) = 先别急着看结果, 在程序运行之前可先思考一下, 这个复杂的表达式 (ch / a)- (d / f) (b + a) 最后的输出类型是什么? 它又是如何将不同的数据类型转换成相同的呢? 读者可以参考图 3-6 的分析过程 图 3-6 数据类型的转换过程 第 71 页

72 3.3 循环与选择性语句 到目前为止, 本书所编写的程序, 都是简单的程序语句 如果想处理重复的工作时, 循环 就是一个很好的选择, 它可以运行相同的程序片段, 还可以使程序结构化 在本章中就要认识选择与循环结构语句, 学习如何利用这些不同的结构编写出有趣的程序, 让程序的编写更灵活, 操控更方便 程序的结构设计 一般来说程序的结构包含有下面三种 : 1 顺序结构 2 选择结构 3 循环结构 这三种不同的结构有一个共同点, 就是它们都只有一个入口, 也只有一个出口 程序中使用了上面这些结构到底有什么好处呢? 这些单一入 出口可以让程序易读 好维护, 也可以减少调试的时间 现在以流程图的方式来让读者了解这三种结构的不同 顺序结构 本书前面所讲的那些例子采用的都是顺序结构, 程序至上而下逐行执行, 一条语 句执行完之后继续执行下一条语句, 一直到程序的末尾 这种结构如图 3-7 所示 : 第 72 页

73 图 3-7 顺序结构的基本流程顺序结构在程序设计中是最常使用到的结构, 在程序中扮演了非常重要的角色, 因为大部分的程序基本上都是依照这种由上而下的流程来设计 选择结构 选择结构是根据条件的成立与否, 再决定要执行哪些语句的结构, 其流程图如图 3-8 所示 图 3-8 选择结构的基本流程 第 73 页

74 这种结构可以依据判断条件的结构, 来决定要执行的语句 当判断条件的值为真时, 就运行 语句 1 ; 当判断条件的值为假, 则执行 语句 2 不论执行哪一个语句, 最后都会再回到 语句 3 继续执行 举例来说, 想在下面的程序中声明两个整数 a 及 b, 并赋其初值, 如果 a 大于 b, 在显示器中输出 a-b 的计算结果 无论 a 是否大于 b, 最后均输出 a*b 的值 范例 :TestJava3_23.java 01 // 下面的程序说明了 if 语句的操作, 只有当条件满足时才会被执行 02 public class TestJava3_23 03 { 04 public static void main(string[] args) 05 { 06 int a = 6, b = 5 ; System.out.println("a = "+a+", b = "+b); 09 if(a>b) 10 System.out.println("a - b = "+(a-b)); 11 System.out.println("a * b = "+(a*b)); 12 } 13 } 输出结果 : a = 6, b = 5 a - b = 1 a * b = 30 读者可以试着更改程序第 6 行中变量 a b 的初值, 将 a 的值设置得比 b 值小, 可 较容易观察程序运行的流程 如果输入的 a 值小于或等于 b 值, 则会跳至执行第 11 行 第 74 页

75 循环结构 循环结构则是根据判断条件的成立与否, 决定程序段落的执行次数, 而这个程序 段落就称为循环主体 循环结构的流程图如下图 3-9 所示 图 3-9 循环结构的基本流程 选择结构 选择结构包括 if if..else 及 switch 语句, 语句中加上了选择结构之后, 就像是十 字路口, 根据不同的选择, 程序的运行会有不同的结果 现在先来看看 if 语句 if 语句 在前面简单地介绍了 if 的用法 要根据判断的结构来执行不同的语句时, 使用 if 语句就是一个很好的选择, 它会准确地检测判断条件成立与否, 再决定是否要执行后 面的语句 第 75 页

76 if 语句的格式如下所示 : 格式 3-3 if 语句的格式 if ( 判断条件 ) { 语句 1 ; 语句 2 ; 语句 3 ; } 若是在 if 语句主体中要处理的语句只有 1 个, 可省略左 右大括号 当判断条件 的值不为假时, 就会逐一执行大括号里面所包含的语句,if 语句的流程图如图 3-10 所 示 图 3-10 if 语句的流程图 选择结构中除了 if 语句之外, 还有 if else 语句 在 if 语句中如果判断条件成立, 即可执行语句主体内的语句, 但若要在判断条件不成立时可以执行其他的语句, 使用 if else 语句就可以节省判断的时间 第 76 页

77 if else 语句 当程序中存在含有分支的判断语句时, 就可以用 if...else 语句处理 当判断条件成立, 即执行 if 语句主体 ; 判断条件不成立时, 则会执行 else 后面的语句主体 if else 语句的格式如下 : 格式 3-4 if else 语句的格式 if ( 判断条件 ) { 语句主体 1 ; } else { 语句主体 2; } 若是在 if 语句或 else 语句主体中要处理的语句只有一个, 可以将左 右大括号去 除 if else 语句的流程图如图 3-17 所示 图 3-17 if..else 语句的基本流程 第 77 页

78 下面举一个简单的例子 : 声明一个整型变量 a, 并给其赋初值 5, 在程序中判断 a 是奇数还是偶数, 再将判断的结果输出 范例 :TestJava3_24.java 01 // 以下程序说明了 if...else 的使用方法 02 public class TestJava3_24 03 { 04 public static void main(string[] args) 05 { 06 int a = 5 ; if(a%2 = = 1) 09 System.out.println(a+" 是奇数!"); 10 else 11 System.out.println(a+" 是偶数!"); 12 } 13 } 输出结果 : 5 是奇数! 程序说明 : 1 第 8~11 行为 if..else 语句 在第 8 行中,if 的判断条件为 a%2 = = 1, 当 a 除以 2 取余数, 若得到的结果为 1, 表示 a 为奇数, 若 a 除以 2 取余数得到的结果为 0, 则 a 为偶数 2 当 a 除以 2 取余数的结果为 1 时, 即执行第 9 行的语句, 输出 a 为奇数! ; 否则执行第 11 行, 输出 a 为偶数! 3 读者可以自行将变量 a 的初值更改, 再重复执行程序 从上面的程序中发现, 程序的缩进在这种选择结构中起着非常重要的作用, 它可 以使设计者编写的程序结构层次清晰, 在维护上也就比较简单 所以本书建议读者以 后在编写程序时要养成缩进的好习惯 第 78 页

79 条件运算符 还有一种运算符可以代替 if else 语句, 即条件运算符, 如表 3-17 所示 : 表 3-17 条件运算符 条件运算符 意义? : 根据条件的成立与否, 来决定结果为 : 前或 : 后的表达式 使用条件运算符时, 操作数有 3 个, 其格式如下 : 格式 3-5 if else 语句的格式 条件判断? 表达式 1: 表达式 2 将上面的格式以 if 语句解释, 就是当条件成立时执行表达式 1, 否则执行表达式 2, 通常会将这两个表达式之一的运算结果指定给某个变量, 也就相当于下面的 if..else 语句 : 格式 3-6?: 与 if else 语句的相对关系 if ( 条件判断 ) 变量 x = 表达式 1 ; else 变量 x = 表达式 2 ; 接下来, 可以试着练习用条件运算符来编写程序, 在下面的程序中声明变量 a b, 并为其赋初值, 再利用条件运算符判断其最大值 范例 :TestJava3_25.java 01 // 以下程序说明了条件运算符的使用方法 02 public class TestJava3_25 03 { 04 public static void main(string[] args) 第 79 页

80 05 { 06 int a = 5, b = 13, max ; max = (a>b)?a:b ; System.out.println("a = "+a+", b = "+b); 11 System.out.println(" 最大的数是 : "+max); 12 } 13 } 输出结果 : a = 5, b = 13 最大的数是 : 13 程序说明 : 1 第 6 行声明变量并为其赋初值 a b 为要比较大小的两个整数值 ;max 存放比较大小后的最大的那个值 2 第 8 行 (max = (a>b)?a:b) 赋值当 a>b 时,max = a, 否则 max = b 3 第 10 行输出 a b 的值 程序第 11 行, 输出最大值 4 可以自行将 a b 的值更改, 再运行此程序 读者可以发现, 使用条件运算符编写程序时较为简洁, 它用一个语句就可以替代 一长串的 if..else 语句, 所以条件运算符的执行速度也较高 if..else if..else 语句 下 : 如果需要在 if..else 里判断多个条件时, 就需要 if..else if else 语句了, 其格式如 第 80 页

81 格式 3-7 if else if else 语句 if ( 条件判断 1) { 语句主体 1 ; } else if ( 条件判断 2) { 语句主体 2 ; }. // 多个 else if() 语句 else { 语句主体 3 ; } 这种方式用在含有多个判断条件的程序中, 请看下面的范例 : 范例 :TestJava3_26.java 01 // 以下程序说明了多分支条件语句 if..else if...else 的使用 02 public class TestJava3_26 03 { 04 public static void main(string[] args) 05 { 06 int x = 1 ; if(x= =1) 09 System.out.println("x = = 1"); 10 else if(x= =2) 11 System.out.println("x = = 2"); 12 else if(x= =3) 13 System.out.println("x = = 3"); 14 else 15 System.out.println("x > 3"); 16 } 第 81 页