Java 程 序 设 计 实 践 教 程 刘 万 军 梁 清 华 王 松 波 宋 强 编 著 清 华 大 学 出 版 社 北 京
内 容 简 介 Java 是 一 种 面 向 对 象 的 新 型 编 程 语 言, 应 用 非 常 广 泛 本 书 详 细 介 绍 了 Java 语 言 的 基 础 知 识, 数 据 类 型 运 算 符 和 表 达 式, 程 序 控 制 语 句, 类 对 象 和 方 法, 继 承 和 接 口, 字 符 串, 包 类 库 和 Applet 等 基 础 知 识 在 此 基 础 上, 本 书 讲 解 了 Java 编 程 语 言 中 GUI 编 程, 异 常 处 理, 多 线 程,I/O 系 统, 网 络 通 信 和 多 媒 体, 数 据 库 编 程 和 广 泛 的 Java 数 据 结 构 等 主 题, 读 者 可 以 深 入 学 习 Java 语 言 的 应 用 知 识 本 书 可 以 作 为 读 者 学 习 Java 语 言 和 面 向 对 象 开 发 的 教 程, 适 合 于 普 通 高 校 计 算 机 专 业 和 非 计 算 机 专 业 的 程 序 设 计 教 程, 也 可 供 自 学 读 者 使 用 版 权 所 有, 翻 印 必 究 举 报 电 话 :010-62782989 13501256678 13801310933 本 书 封 面 贴 有 清 华 大 学 出 版 社 防 伪 标 签, 无 标 签 者 不 得 销 售 本 书 防 伪 标 签 采 用 特 殊 防 伪 技 术, 用 户 可 通 过 在 图 案 表 面 涂 抹 清 水, 图 案 消 失, 水 干 后 图 案 复 现 ; 或 将 表 面 膜 揭 下, 放 在 白 纸 上 用 彩 笔 涂 抹, 图 案 在 白 纸 上 再 现 的 方 法 识 别 真 伪 图 书 在 版 编 目 (CIP) 数 据 Java 程 序 设 计 实 践 教 程 / 刘 万 军 等 编 著. 北 京 : 清 华 大 学 出 版 社,2006.9 ISBN 7-302-13465-0 Ⅰ. J Ⅱ. 刘 Ⅲ. JAVA 语 言 程 序 设 计 IV. TP312 中 国 版 本 图 书 馆 CIP 数 据 核 字 (2006) 第 099488 号 出 版 者 : 清 华 大 学 出 版 社 地 址 : 北 京 清 华 大 学 学 研 大 厦 http://www.tup.com.cn 邮 编 :100084 社 总 机 :010-62770175 客 户 服 务 :010-62776969 责 任 编 辑 : 夏 兆 彦 印 刷 者 : 装 订 者 : 肖 米 发 行 者 : 新 华 书 店 总 店 北 京 发 行 所 开 本 :185 260 印 张 :26 字 数 :645 千 字 版 次 :2006 年 9 月 第 1 版 2006 年 9 月 第 1 次 印 刷 书 号 :ISBN 7-302-13465-0 / TP 8450 印 数 :1~5000 定 价 :25.00 元
Java 是 Sun 公 司 开 发 的 新 一 代 编 程 语 言 Java 是 一 种 卓 越 的 Internet 语 言, 它 的 平 台 无 关 性 使 其 非 常 适 合 当 前 的 网 络 应 用 开 发 任 务 使 程 序 设 计 产 生 了 革 命, 改 变 了 我 们 考 虑 程 序 形 式 与 功 能 的 方 式 本 书 内 容 本 书 主 要 介 绍 了 Java 语 言 的 特 点 以 及 面 向 对 象 程 序 设 计 的 基 本 概 念 等 ; 使 用 Java 语 言 进 行 程 序 的 基 础 ;Java 的 程 序 控 制 语 句 ;Java 数 组 知 识, 包 括 Java 的 一 维 数 组 多 维 数 组 不 规 则 数 组 搜 索 和 排 序 数 组 等 Java 是 一 种 完 全 面 向 对 象 的 编 程 语 言, 本 书 重 点 介 绍 了 Java 中 的 类 对 象 和 方 法, 内 容 包 括 在 Java 中 构 造 类 创 建 类 的 实 例 化 对 象, 控 制 类 成 员 的 访 问 以 及 this 关 键 字 等 ;Java 面 向 对 象 中 的 继 承 和 接 口, 内 容 包 括 继 承 重 载 重 写 构 造 抽 象 类 以 及 Java 语 言 的 根 类 和 接 口 等 本 书 深 入 介 绍 了 Java 语 言 中 字 符 串 的 实 现 ; 包 类 库 和 Applet;GUI 编 程 基 础 ;Java 的 异 常 处 理 ;Java 的 多 线 程 程 序 设 计 ; 使 用 文 件 保 存 Java 程 序 中 的 数 据 这 些 知 识 完 善 了 Java 面 向 对 象 语 言 的 功 能 本 书 最 后 介 绍 了 Java 的 网 络 和 多 媒 体 编 程 ; 使 用 JDBC 开 发 Java 数 据 库 程 序 这 些 知 识 更 进 一 步 体 现 了 Java 语 言 的 实 用 性 本 书 最 后 介 绍 Java 程 序 开 发 中 常 用 的 类, 内 容 包 括 Java 的 集 合 架 构 以 及 可 枚 举 的 类 和 接 口 等 这 些 内 容 体 现 了 J2SE 5 的 新 特 性 本 书 特 色 本 书 通 过 实 例 介 绍 Java 程 序 开 发 知 识, 具 有 实 用 性 教 程 的 特 色 本 书 汇 总 了 多 年 的 程 序 员 职 业 教 学 培 训 经 验, 内 容 组 织 更 合 理, 实 例 丰 富 全 面 本 书 使 用 Java 语 言 开 发 了 大 量 实 例, 读 者 可 以 通 过 这 些 丰 富 实 例 学 习 Java 编 程 实 践 知 识 本 章 编 写 了 大 量 实 验 项 目, 引 导 读 者 应 用 该 章 知 识 独 立 练 习 编 程 项 目 复 习 题 可 以 帮 助 学 生 检 查 对 Java 开 发 理 论 知 识 的 掌 握 程 度 读 者 对 象 本 书 由 多 家 院 校 的 教 师 联 合 编 写, 在 各 家 院 校 成 熟 教 案 及 原 有 自 编 教 材 的 基 础 上 整 合 编 写 作 者 均 从 事 Java 教 学 和 开 发 工 作, 拥 有 丰 富 的 Java 开 发 案 例 和 教 学 经 验 本 书 共 15 章, 需 要 45 个 课 时 为 了 给 教 师 授 课 提 供 方 便, 本 书 提 供 了 教 学 课 件, 读 者 可 以 从 www.tup.tsinghua.edu.cn 下 载 使 用
Java 程 序 设 计 实 践 教 程 本 书 可 以 作 为 普 通 高 校 计 算 机 相 关 专 业 Java 编 程 初 级 教 程, 也 可 以 作 为 接 触 过 Java 基 础 知 识, 需 要 深 入 学 习 面 向 对 象 开 发 的 中 级 教 程 编 写 过 程 难 免 会 有 错 误, 欢 迎 读 者 与 我 们 联 系, 帮 助 我 们 改 正 提 高 编 者 II
第 1 章 Java 概 述... 1 1.1 Java 的 发 展... 1 1.1.1 Java 的 发 展 史... 1 1.1.2 Java 与 C C++ 和 C# 的 关 系... 2 1.2 Java 的 特 点... 3 1.3 面 向 对 象 程 序 设 计... 4 1.3.1 封 装... 5 1.3.2 继 承... 5 1.3.3 多 态 性... 6 1.3.4 Java 的 开 发 工 具... 6 1.4 一 个 简 单 的 Java 程 序... 7 1.4.1 编 写 Java 程 序... 7 1.4.2 编 译 和 执 行 Java 程 序... 8 1.4.3 Java 程 序 的 基 本 要 素... 9 1.5 实 验 指 导... 12 1.6 思 考 与 练 习... 13 第 2 章 数 据 类 型 与 运 算 符... 15 2.1 常 量 变 量 和 表 达 式... 15 2.1.1 常 量... 15 2.1.2 变 量... 16 2.2 数 据 类 型... 18 2.2.1 整 数 类 型... 19 2.2.2 浮 点 类 型... 20 2.2.3 字 符 类 型... 21 2.2.4 布 尔 类 型... 22 2.2.5 类 型 之 间 的 转 换... 22 2.2.6 转 义 序 列... 23 2.3 运 算 符 和 表 达 式... 24 2.3.1 算 术 运 算 符... 25 2.3.2 关 系 运 算 符 和 逻 辑 运 算 符... 28 2.3.3 位 运 算 符... 29 2.3.4 赋 值 运 算 符 和 条 件 运 算 符... 30 2.3.5 扩 展 运 算 符... 31 2.3.6 其 他 运 算 符... 32 2.3.7 运 算 符 优 先 级... 33 2.4 实 验 指 导... 33 2.5 思 考 与 练 习... 34 第 3 章 程 序 控 制 语 句... 36 3.1 选 择 语 句... 36 3.1.1 简 单 的 if 语 句... 36 3.1.2 if-else 语 句... 37 3.1.3 if 嵌 套 语 句... 38 3.1.4 switch 语 句... 40 3.2 循 环 语 句... 42 3.2.1 while 循 环 语 句... 42 3.2.2 do-while 循 环 语 句... 43 3.2.3 for 循 环 语 句... 45 3.3 与 程 序 有 关 的 其 他 语 句... 47 3.3.1 break 语 句... 47 3.3.2 continue 语 句... 51 3.3.3 return 语 句... 52 3.4 实 验 指 导... 53 3.5 思 考 与 练 习... 53 第 4 章 数 组... 56 4.1 一 维 数 组... 56 4.1.1 声 明 数 组 和 创 建 数 组... 56 4.1.2 一 维 数 组 初 始 化 及 元 素 引 用... 57 4.2 多 维 数 组... 60 4.2.1 声 明 数 组 和 创 建 数 组... 60 4.2.2 初 始 化 数 组... 61 4.2.3 数 组 程 序 举 例... 62
IV Java 程 序 设 计 实 践 教 程 4.3 不 规 则 数 组... 67 4.4 搜 索 数 组... 70 4.5 排 序 数 组... 72 4.5.1 选 择 排 序... 72 4.5.2 冒 泡 排 序... 73 4.5.3 快 速 排 序... 75 4.6 实 验 指 导... 76 4.7 思 考 与 练 习... 78 第 5 章 类 对 象 和 方 法... 79 5.1 Java 类... 79 5.1.1 类 的 基 本 形 式... 79 5.1.2 类 的 定 义... 80 5.2 创 建 对 象... 82 5.3 对 象 引 用 变 量... 83 5.4 方 法... 84 5.4.1 添 加 方 法... 85 5.4.2 调 用 对 象 的 方 法... 86 5.4.3 将 对 象 传 递 给 方 法... 87 5.5 构 造 函 数 和 垃 圾 回 收... 88 5.5.1 构 造 函 数... 88 5.5.2 垃 圾 回 收... 89 5.6 new 运 算 符... 90 5.7 类 成 员 的 访 问 控 制... 90 5.8 共 享 变 量 常 量 和 静 态 方 法... 91 5.9 this 关 键 字... 94 5.10 对 象 数 组... 95 5.11 实 验 指 导... 97 5.12 思 考 与 练 习... 98 第 6 章 继 承 和 接 口... 101 6.1 继 承... 101 6.1.1 超 类 和 子 类... 101 6.1.2 成 员 访 问 和 继 承... 103 6.2 super 关 键 字... 105 6.2.1 使 用 super 调 用 超 类 构 造 函 数... 106 6.2.2 使 用 super 访 问 超 类 成 员... 109 6.2.3 创 建 多 级 层 次 结 构... 110 6.2.4 何 时 调 用 构 造 函 数... 112 6.3 方 法 重 载 和 方 法 重 写... 113 6.3.1 方 法 重 载... 113 6.3.2 方 法 重 写... 114 6.3.3 重 写 的 方 法 支 持 多 态 性... 115 6.3.4 使 用 重 写 方 法 的 原 因... 116 6.4 抽 象 类... 117 6.5 继 承 中 的 final 修 饰 符... 119 6.5.1 使 用 final 防 止 重 写... 119 6.5.2 使 用 final 防 止 继 承... 120 6.6 Object 类... 120 6.6.1 clone 方 法... 121 6.6.2 equals 方 法... 121 6.6.3 tostring 方 法... 122 6.7 接 口... 122 6.7.1 接 口 定 义... 122 6.7.2 实 现 接 口... 123 6.7.3 接 口 引 用... 126 6.7.4 接 口 中 的 变 量... 128 6.7.5 接 口 的 扩 展... 129 6.8 实 验 指 导... 130 6.9 思 考 与 练 习... 131 第 7 章 字 符 串... 133 7.1 字 符 类... 133 7.1.1 构 造 字 符 串... 133 7.1.2 匹 配 字 符 串... 136 7.1.3 求 字 符 串 长 度 和 检 索 单 个 字 符... 136 7.1.4 字 符 串 比 较... 137 7.1.5 查 找 子 字 符 串... 138 7.2 Character 类... 141 7.2.1 Character 类 的 介 绍... 141 7.2.2 Character 类 方 法 的 应 用... 142 7.3 StringBuffer 类... 144 7.3.1 构 造 StringBuffer 类... 145 7.3.2 StringBuffer 类 常 用 方 法... 146 7.3.3 StringBuffer 类 特 有 的 方 法... 148
目 Java Web 开 发 技 术 概 述 录 7.3.4 StringBuffer 类 特 有 方 法 的 应 用 示 例... 148 7.4 实 验 指 导... 151 7.5 思 考 与 练 习... 152 第 8 章 包 和 Applet... 155 8.1 包... 155 8.1.1 定 义 包... 155 8.1.2 导 入 包... 156 8.1.3 类 路 径 (CLASSPATH)... 157 8.1.4 访 问 控 制... 157 8.2 applet 程 序... 160 8.2.1 applet 类... 160 8.2.2 请 求 重 绘... 163 8.3 HTML APPLET 标 记... 164 8.4 将 参 数 传 递 到 applet... 165 8.5 实 验 指 导... 166 8.6 思 考 与 练 习... 167 第 9 章 GUI 编 程 基 础... 169 9.1 GUI 类... 169 9.2 框 架... 171 9.2.1 创 建 框 架... 171 9.2.2 在 框 架 内 添 加 组 件... 172 9.3 布 局 管 理... 173 9.3.1 FlowLayout... 173 9.3.2 GridLayout... 174 9.3.3 BorderLayout... 175 9.3.4 CardLayout... 177 9.3.5 GridBagLayout... 179 9.3.6 null... 182 9.4 面 板 容 器... 183 9.5 事 件... 185 9.5.1 事 件 和 事 件 源... 185 9.5.2 事 件 监 听... 186 9.5.3 处 理 事 件... 188 9.6 用 户 界 面 对 象 (UI)... 192 9.6.1 按 钮... 192 9.6.2 标 签... 195 9.6.3 单 行 文 本 框 和 多 行 文 本 域... 196 9.6.4 复 选 框 和 单 选 按 钮... 199 9.6.5 组 合 框... 203 9.6.6 滚 动 条... 206 9.6.7 滚 动 面 板... 209 9.6.8 菜 单... 210 9.7 GUI 绘 图... 213 9.7.1 颜 色... 214 9.7.2 绘 制 几 何 图 形... 214 9.7.3 显 示 字 体... 218 9.8 实 验 指 导... 221 9.9 思 考 与 练 习... 223 第 10 章 异 常 处 理... 227 10.1 异 常 和 异 常 类 型... 227 10.1.1 异 常 的 含 义... 227 10.1.2 异 常 类 型... 228 10.2 理 解 异 常 处 理... 228 10.3 声 明 异 常 (throws)... 230 10.4 抛 出 异 常 (throw)... 231 10.5 捕 获 异 常... 233 10.5.1 使 用 try-catch... 233 10.5.2 使 用 多 重 catch 语 句... 235 10.5.3 嵌 套 try 语 句... 236 10.6 finally 的 用 法... 238 10.7 异 常 的 应 用... 240 10.7.1 Java 中 的 内 置 异 常... 241 10.7.2 创 建 自 定 义 的 异 常 类... 242 10.7.3 输 出 警 告 信 息... 244 10.7.4 应 用 异 常 的 建 议... 245 10.8 实 验 指 导... 246 10.9 思 考 与 练 习... 248 第 11 章 线 程 与 多 线 程... 251 11.1 线 程 与 多 线 程... 251 11.1.1 线 程 的 性 质... 252 11.1.2 线 程 的 状 态... 254 11.1.3 守 护 线 程... 254 V
Java 程 序 设 计 实 践 教 程 VI 11.2 创 建 线 程... 256 11.2.1 扩 展 Thread 类 创 建 线 程... 257 11.2.2 实 现 Runnable 接 口 创 建 线 程... 259 11.2.3 创 建 多 线 程... 260 11.3 多 线 程 程 序 设 计... 263 11.3.1 多 线 程 同 时 运 行... 263 11.3.2 多 线 程 优 先 级 调 度... 267 11.3.3 多 线 程 的 互 斥 和 同 步... 269 11.3.4 死 锁... 276 11.4 多 线 程 的 控 制... 280 11.4.1 判 断 线 程 是 否 结 束... 281 11.4.2 线 程 阻 塞... 283 11.4.3 处 理 线 程 阻 塞... 284 11.5 线 程 的 应 用... 288 11.5.1 为 applet 创 建 线 程... 289 11.5.2 使 用 Timer 类 来 控 制 动 画... 290 11.6 实 验 指 导... 295 11.7 思 考 与 练 习... 295 第 12 章 输 入 输 出 系 统... 297 12.1 Java 的 I/O 基 于 流... 297 12.1.1 字 节 流... 298 12.1.2 字 符 流... 299 12.1.3 预 定 义 流... 300 12.2 字 节 流... 302 12.2.1 InputStream 类 和 OutputStream 类... 302 12.2.2 文 件 字 节 流 的 顺 序 输 入 输 出... 303 12.2.3 文 件 字 节 流 的 随 机 访 问... 306 12.3 过 滤 流... 308 12.3.1 DataInputStream 和 DataOutputStream... 309 12.3.2 BufferedInputStream 和 BufferedOutputStream... 310 12.3.3 LineNumberInputStream... 311 12.3.4 PushbackInputStream... 312 12.4 字 符 流... 313 12.4.1 基 类 Reader 和 Writer... 313 12.4.2 InputStreamReader 和 OutputStreamWriter... 314 12.4.3 FileReader 和 FileWriter... 315 12.4.4 BufferedReader 和 BufferedWriter... 316 12.4.5 PrintWriter 类... 317 12.5 File 类... 318 12.5.1 File 类 的 3 种 构 造 函 数... 318 12.5.2 File 类 的 常 用 方 法... 319 12.6 对 象 的 串 行 化... 321 12.7 实 验 指 导... 325 12.8 思 考 与 练 习... 326 第 13 章 网 络 通 信 和 多 媒 体... 328 13.1 网 络 基 础 知 识... 328 13.1.1 域 名 和 IP 地 址... 328 13.1.2 端 口 号 (port)... 330 13.2 Socket( 套 接 字 ) 通 信... 330 13.3 UDP 和 FTP 类 型 通 信... 334 13.3.1 UDP 通 信 介 绍... 334 13.3.2 FTP 通 信 介 绍... 335 13.4 applet 通 信... 336 13.4.1 同 页 applet 之 间 的 通 信... 336 13.4.2 applet 和 浏 览 器 之 间 的 通 信... 340 13.5 多 媒 体... 342 13.5.1 Applet 中 播 放 音 频... 342 13.5.2 Applet 中 显 示 图 像... 345 13.5.3 在 应 用 程 序 中 载 入 图 像 和 音 频 文 件... 347 13.5.4 显 示 一 列 图 像... 351 13.5.5 MediaTracker... 353
目 Java Web 开 发 技 术 概 述 录 13.6 实 验 指 导... 355 13.7 思 考 与 练 习... 356 第 14 章 数 据 库 编 程... 358 14.1 JDBC 简 介... 358 14.2 JDBC 应 用 模 型... 359 14.3 java.sql 包... 360 14.4 访 问 数 据 库... 360 14.4.1 配 置 ODBC 数 据 源... 360 14.4.2 加 载 JDBC 驱 动 程 序... 361 14.4.3 创 建 数 据 库 连 接... 362 14.4.4 执 行 SQL 语 句... 363 14.4.5 处 理 结 果 集... 364 14.4.6 更 新 数 据 库... 369 14.4.7 数 据 库 连 接... 372 14.5 使 用 预 编 译 SQL 语 句... 373 14.6 获 取 数 据 库 信 息... 375 14.7 实 验 指 导... 377 14.8 思 考 与 练 习... 378 第 15 章 Java 的 数 据 结 构... 381 15.1 了 解 Java 集 合 架 构... 381 15.2 Collection 接 口 Map 接 口 及 其 子 接 口... 383 15.2.1 Collection 接 口... 383 15.2.2 Set 接 口 和 SortedSet 接 口... 384 15.2.3 List 接 口... 384 15.2.4 Map 接 口 和 SortedMap 接 口... 385 15.3 AbstractSet 类 和 HashSet 类... 386 15.4 TreeSet 类 和 Comparator 接 口... 387 15.4.1 使 用 TreeSet 类... 387 15.4.2 使 用 Comparator 接 口... 388 15.5 ArrayList 类 和 LinkedList 类... 389 15.6 Vector 类 和 Stack 类... 390 15.7 HashMap 类 和 TreeMap 类... 392 15.8 Collections 类 和 Arrays 类... 395 15.8.1 使 用 Collections 类... 395 15.8.2 使 用 Arrays 类... 398 15.9 实 验 指 导... 400 15.10 思 考 与 练 习... 400 附 录 思 考 与 练 习 答 案... 402 VII
第 1 章 Java 概 述 Java 是 一 种 跨 平 台 面 向 对 象 基 于 网 络 及 支 持 多 媒 体 的 编 程 语 言 自 1995 年 5 月 发 布 以 来,Java 很 快 成 为 开 发 因 特 网 应 用 程 序 的 极 具 魅 力 的 语 言 Java 程 序 可 以 插 入 HTML 页, 由 Web 浏 览 器 下 载, 为 Web 客 户 带 来 动 画 和 交 互 式 的 享 受 Java 的 强 大 功 能 不 仅 仅 限 于 Web 应 用 程 序 它 还 是 一 种 面 向 对 象 的 通 用 编 程 语 言, 其 编 程 功 能 完 备, 可 以 开 发 单 独 的 应 用 程 序 Java 体 系 非 常 庞 大, 本 章 将 介 绍 Java 的 基 本 知 识 和 Java 的 基 础 特 性 Java 虽 然 是 一 种 面 向 对 象 的 编 程 语 言, 但 是 也 兼 容 面 向 过 程 语 言 中 的 数 据 类 型 控 制 语 句 等 基 础 知 识, 本 章 将 会 详 细 介 绍 本 章 学 习 目 的 是 了 解 Java, 包 括 它 的 历 史 设 计 原 理 和 一 些 最 重 要 的 特 性 另 外, 通 过 一 个 简 单 的 Java 程 序, 我 们 还 要 学 习 Java 程 序 的 编 写 编 译 和 执 行 以 及 编 码 规 范 等 基 础 知 识 对 于 这 些 内 容 我 们 并 不 进 行 深 入 讨 论, 只 是 关 注 Java 程 序 共 有 的 一 些 概 念 本 章 学 习 要 点 : 了 解 Java 的 发 展 了 解 Java 与 C C++ C# 之 间 的 关 系 了 解 Java 的 特 点 理 解 Java 是 一 种 面 向 对 象 程 序 设 计 的 方 法 及 三 种 特 性 掌 握 Java 程 序 开 发 工 具 JDK1.5 的 配 置 及 应 用 掌 握 Java 程 序 的 基 本 要 素 及 编 码 规 范 1.1 Java 的 发 展 Java 语 言 是 一 门 发 展 非 常 迅 速 的 语 言, 从 诞 生 到 广 泛 应 用 仅 用 了 几 年 的 时 间 Java 诞 生 之 初, 只 有 在 美 国 硅 谷 的 Sun IBM BEA 等 几 家 公 司 有 人 知 道, 或 听 说 过 Java 这 个 名 词 现 在 无 论 在 美 国 还 是 在 中 国, 或 在 世 界 上 的 其 他 地 方, 你 都 能 到 图 书 馆 网 站 上 找 到 大 量 的 Java 资 料 Java 迅 速 从 一 种 编 程 语 言 发 展 为 一 个 平 台 一 个 社 群 一 个 产 业 现 在 Java 是 最 重 要 的 编 程 技 术 之 一, 全 球 超 过 450 万 名 程 序 员 使 用 Java 开 发 软 件, 14 亿 部 设 备 上 运 行 着 Java 编 写 的 程 序 Java 已 经 拥 有 一 个 庞 大 的 体 系 结 构 1.1.1 Java 的 发 展 史 Java 是 Sun 公 司 于 1991 年 开 发 的 新 一 代 编 程 语 言, 最 初 目 的 是 为 家 用 消 费 类 电 子 产 品 开 发 分 布 式 代 码 系 统 后 来 为 了 使 整 个 系 统 与 平 台 无 关, 该 项 目 小 组 的 领 导 人 James Gosling 决 定 开 发 一 种 新 语 言, 称 为 Oak, 这 就 是 Java 语 言 的 前 身, 后 来 改 名 为 Java
Java 程 序 设 计 实 践 教 程 随 着 Internet 的 迅 速 发 展,Web 的 应 用 日 益 广 泛,Java 语 言 也 得 到 了 迅 速 发 展 1994 年, Gosling 用 Java 开 发 了 一 个 实 时 性 较 高 可 靠 安 全 有 交 互 功 能 的 新 型 Web 浏 览 器, 它 不 依 赖 于 任 何 硬 件 平 台 和 软 件 平 台 这 种 新 的 浏 览 器 称 为 HotJava 1995 年 在 业 界 发 表, 引 起 了 巨 大 轰 动,Java 的 地 位 随 之 而 得 到 肯 定 Java 语 言 发 展 非 常 迅 猛,1995 年 3 月 Sun 公 司 发 布 了 Java 语 言 的 Alpha1.0a2 版 本, 1996 年 1 月 发 布 了 Java 语 言 的 第 一 个 开 发 包 JDK v1.0,1997 年 2 月 发 布 了 Java 语 言 的 开 发 包 JDK v1.1, 从 而 奠 定 了 Java 语 言 在 计 算 机 语 言 中 的 地 位 1998 年 12 月 Sun 公 司 发 布 Java 2 开 发 平 台 JDK v1.2 Java 2 平 台 是 Java 发 展 史 上 的 里 程 碑 1999 年 6 月,Sun 公 司 重 新 组 织 Java 平 台 的 集 成 方 法, 并 将 企 业 级 应 用 平 台 作 为 Java 语 言 发 展 方 向, 包 含 了 3 个 成 员 : J2ME(Java 2 Micro Edition) 用 于 嵌 入 式 应 用 的 Java 2 平 台 J2SE(Java 2 Standard Edition) 用 于 工 作 站 PC 机 的 Java 2 标 准 平 台 J2EE(Java 2 Enterprise Edition) 可 扩 展 的 企 业 级 应 用 的 Java 2 平 台 Java 是 天 生 面 向 对 象 的 计 算 机 语 言 虽 然 许 多 面 向 对 象 的 语 言 一 开 始 就 是 严 格 的 过 程 化 语 言,Java 却 从 一 开 始 就 被 设 计 为 面 向 对 象 的 语 言 2 1.1.2 Java 与 C C++ 和 C# 的 关 系 Java 又 被 称 作 C++++, 意 思 是 给 C++ 增 加 新 功 能, 去 除 不 良 功 能 从 这 一 点 可 以 看 出 Java 与 C 和 C++ 直 接 相 关 Java 继 承 了 C 的 大 部 分 语 法,Java 的 对 象 模 型 则 从 C++ 改 编 来 的 现 代 编 程 语 言 先 驱 是 C 语 言 C++ 在 C 语 言 的 基 础 上, 通 过 增 加 面 向 对 象 的 特 性 扩 充 形 成 因 此 它 包 括 了 C 所 有 的 特 征 属 性 和 优 点 这 也 是 C++ 作 为 语 言 成 功 的 一 个 关 键 原 因 Java 是 为 了 满 足 Web 的 需 要 而 在 C 和 C++ 的 基 础 上 开 发 出 来 的,Java 大 部 分 的 特 性 是 从 C 和 C++ 中 继 承 的 因 为 Java 与 C++ 的 相 似 性, 特 别 是 它 们 对 面 向 对 象 程 序 设 计 的 支 持, 使 得 Java 被 简 单 认 为 是 C++ 的 Internet 版 这 种 观 点 是 错 误 的 因 为 Java 在 实 际 应 用 以 及 基 本 原 理 上 与 C++ 有 显 著 的 不 同 尽 管 Java 受 到 C++ 的 影 响, 但 是 它 绝 不 是 C++ 的 增 强 版 例 如,Java 不 提 供 对 C++ 的 向 上 或 向 下 兼 容 功 能 另 外,Java 不 是 为 替 代 C++ 而 设 计 的, 两 者 将 在 很 长 的 时 期 内 共 存 近 来, 一 种 名 为 C# 的 新 语 言 浮 出 了 水 面 由 Microsoft 创 建, 用 以 支 持 其.NET 架 构 的 C# 与 Java 也 密 切 相 关 事 实 上,C# 的 许 多 功 能 都 是 直 接 从 Java 改 编 来 的 Java 和 C# 共 享 相 同 的 C++ 语 法 风 格, 都 支 持 分 布 式 程 序 设 计, 使 用 相 同 的 对 象 模 型 它 们 之 间 存 在 不 同, 但 就 整 体 外 观 而 言, 两 者 极 为 相 似 如 果 已 经 掌 握 了 C#, 那 么 学 习 Java 就 很 简 单, 反 之, 如 果 将 来 要 学 习 C#, 那 么 现 在 学 到 的 有 关 Java 的 知 识 也 会 使 你 将 来 受 益 匪 浅 鉴 于 Java 与 C# 两 者 的 相 似 性, 自 然 有 人 要 问, C# 会 替 代 Java 吗?Java 和 C# 是 对 两 种 不 同 类 型 计 算 环 境 的 优 化, 正 如 C++ 会 与 Java 长 期 共 存 一 样,C# 与 Java 也 会 长 期 共 存
Java 概 述 第 1 章 1.2 Java 的 特 点 Java 语 言 由 于 适 用 于 Internet 环 境, 以 及 它 具 有 小 型 化 平 台 无 关 性 等 特 点, 引 起 了 计 算 机 界 的 广 泛 关 注, 从 而 迅 速 发 展 成 为 计 算 机 网 络 编 程 语 言 它 简 单 面 向 对 象, 不 依 赖 于 机 器 结 构, 不 受 环 境 的 限 制, 具 有 可 移 植 性 可 靠 性 安 全 性 等 特 点, 并 且 提 供 了 多 线 程 并 发 机 制, 因 此 具 有 很 好 的 性 能 另 外,Java 语 言 还 提 供 了 丰 富 的 类 库, 方 便 用 户 进 行 自 定 义 操 作 下 面 我 们 就 来 论 述 Java 的 具 体 特 点 1. 简 单 性 Java 语 言 是 一 种 面 向 对 象 语 言, 语 法 规 则 和 C++ 类 似 它 通 过 提 供 最 基 本 的 方 法 来 完 成 指 定 的 任 务 但 Java 语 言 对 C++ 进 行 了 简 化 和 提 高 例 如, 指 针 和 多 重 继 承 通 常 使 编 程 变 得 复 杂,Java 用 称 为 接 口 的 简 单 语 言 构 造 取 代 了 C++ 中 的 多 重 继 承, 并 取 消 了 指 针 Java 语 言 还 通 过 实 现 自 动 垃 圾 收 集 大 大 简 化 了 程 序 设 计 人 员 的 内 存 管 理 工 作 另 外, 它 对 环 境 要 求 很 低, 包 括 基 本 解 释 器 类 标 准 类 库 和 线 程 的 支 持 才 仅 仅 有 两 百 多 千 字 节 2. 可 靠 性 Java 语 言 具 有 很 强 的 可 靠 性 它 在 程 序 编 译 和 运 行 时, 对 所 有 可 能 出 现 的 问 题 都 要 进 行 检 查, 可 以 以 消 除 错 误 的 产 生 通 过 在 运 行 时 实 现 面 向 对 象 的 异 常 处 理 机 制,Java 可 以 捕 获 异 常 情 况 并 对 它 做 出 响 应, 程 序 在 发 生 运 行 期 错 误 时 能 继 续 正 常 执 行 并 完 美 终 止 另 外,Java 取 消 了 在 其 他 语 言 中 发 现 的 易 于 产 生 错 误 的 编 程 构 造 类 型 例 如, 它 不 支 持 指 针, 因 此 消 除 了 重 写 内 存 及 破 坏 数 据 的 可 能 性 3 3. 安 全 性 Java 语 言 作 为 一 种 因 特 网 编 程 语 言, 当 用 于 网 络 和 分 布 式 环 境 时, 必 须 具 有 防 止 病 毒 入 侵 的 能 力 Java 语 言 不 支 持 指 针, 一 切 对 内 存 的 访 问 都 必 须 通 过 对 象 的 实 例 变 量 来 实 现, 这 样 就 防 止 用 户 使 用 特 洛 伊 木 马 等 欺 骗 手 段 访 问 对 象 的 私 有 成 员, 同 时 也 避 免 了 指 针 操 作 中 容 易 产 生 的 错 误 另 外, 如 果 下 载 一 个 Java applet( 特 殊 种 类 的 程 序 ) 并 在 计 算 机 上 运 行, 它 不 会 破 坏 你 的 系 统, 因 为 Java 执 行 了 几 种 保 护 系 统 不 受 外 部 程 序 破 坏 的 安 全 机 制 但 是 该 安 全 机 制 是 基 于 不 要 信 任 任 何 东 西 这 个 前 提, 存 在 着 自 己 的 弊 端 4. 解 释 器 通 用 性 运 行 Java 程 序 需 要 解 释 器 Java 解 释 器 直 接 对 Java 字 节 码 进 行 解 释 执 行 字 节 代 码 独 立 于 机 器, 它 本 身 携 带 了 许 多 编 译 时 信 息, 使 得 连 接 过 程 更 加 简 单, 因 此 可 以 在 任 何 有 Java 解 释 器 的 机 器 上 运 行 5. 可 移 植 性 Java 与 体 系 结 构 无 关 这 一 特 征 使 Java 程 序 可 以 方 便 地 移 植 到 网 络 的 不 同 机 器 同 时,Java 的 类 库 中 也 实 现 了 针 对 不 同 平 台 的 接 口, 使 这 些 类 库 可 以 移 植
Java 程 序 设 计 实 践 教 程 6. 分 布 性 分 布 式 计 算 涉 及 到 在 一 个 网 络 上 协 同 工 作 的 多 台 计 算 机 因 为 Java 语 言 是 面 向 网 络 的 语 言, 所 以 通 过 它 提 供 的 类 库 可 以 处 理 TCP/IP 协 议, 用 户 可 以 通 过 URL 地 址 在 网 络 上 很 方 便 地 访 问 其 他 对 象 7. 独 立 性 Java 是 可 解 释 的 这 一 特 征 使 Java 独 立 于 平 台 存 在 使 用 Java 虚 拟 机 (JVM), 可 以 编 写 运 行 在 任 何 平 台 上 的 程 序 原 因 是 Java 解 释 器 生 成 与 体 系 结 构 无 关 的 字 节 码 指 令, 这 些 字 节 码 指 令 仅 用 于 Java 虚 拟 机,Java 解 释 器 得 到 字 节 码 后, 对 它 进 行 转 换, 使 之 能 够 在 不 同 的 平 台 运 行 8. 面 向 对 象 性 Java 程 序 是 面 向 对 象 的 面 向 对 象 编 程 提 供 了 很 大 的 灵 活 性 模 块 性 和 可 重 用 性 Java 语 言 的 设 计 集 中 于 对 象 及 其 接 口, 它 提 供 了 简 单 的 类 机 制 以 及 动 态 的 接 口 模 型 对 象 中 封 装 了 它 的 状 态 变 量 以 及 相 应 的 方 法, 实 现 了 模 块 化 和 信 息 隐 藏 ; 而 类 则 提 供 了 一 类 对 象 的 原 型, 并 且 通 过 继 承 机 制, 子 类 可 以 使 用 父 类 所 提 供 的 方 法, 实 现 代 码 的 复 用 4 9. 高 性 能 性 因 为 Java 是 可 解 释 的, 字 节 码 不 是 直 接 由 系 统 执 行, 而 是 在 解 释 器 中 运 行 因 此, 它 的 速 度 对 多 数 交 互 式 应 用 程 序 来 说 得 到 了 很 大 的 提 高 另 外,Java 字 节 码 的 设 计 使 之 能 很 容 易 地 直 接 转 换 成 对 应 于 特 定 CPU 的 机 器 码, 从 面 得 到 较 高 的 性 能 10. 多 线 程 性 多 线 程 是 程 序 同 时 执 行 多 个 任 务 的 一 种 功 能 多 线 程 多 用 于 图 形 用 户 界 面 (GUI) 多 媒 体 和 网 络 编 程 中 多 线 程 机 制 能 够 使 用 应 用 程 序 并 行 执 行 多 项 任 务, 而 且 同 步 机 制 保 证 合 并 对 共 享 数 据 的 正 确 操 作 通 过 使 用 多 线 程, 程 序 设 计 人 员 可 以 分 别 用 不 同 的 线 程 完 成 特 定 的 行 为, 而 不 需 要 采 用 全 局 的 事 件 循 环 机 制, 这 样 就 很 容 易 实 现 网 络 的 实 时 交 互 行 为 11. 动 态 性 Java 语 言 的 设 计 使 它 适 合 应 用 于 不 断 变 化 的 动 态 环 境 Applet 作 为 一 种 特 殊 的 Java 程 序, 能 嵌 入 到 html 文 件 中, 实 现 用 户 的 交 互 操 作 和 网 页 的 动 态 变 化, 而 不 是 像 动 画 或 者 声 音 文 件 那 样 反 复 地 播 放 另 外, 在 类 库 中 可 以 自 由 加 入 新 的 方 法 和 实 例 变 量, 而 不 会 影 响 用 户 程 序 的 执 行 并 且 Java 通 过 接 口 来 支 持 多 重 继 承, 使 之 比 严 格 的 类 继 承 具 有 更 灵 活 的 方 式 和 扩 展 性 1.3 面 向 对 象 程 序 设 计 Java 的 核 心 是 面 向 对 象 程 序 设 计 (OOP) OOP 是 一 种 功 能 强 大 的 程 序 设 计 方 法
Java 概 述 第 1 章 从 计 算 机 诞 生 以 来, 为 适 应 程 序 不 断 增 加 的 复 杂 程 度, 程 序 设 计 方 法 也 有 了 巨 大 的 变 化 计 算 机 发 展 初 期, 程 序 设 计 是 通 过 使 用 计 算 机 面 板 输 入 二 进 制 机 器 指 令 来 完 成 的 20 世 纪 70 年 代, 诞 生 了 结 构 化 程 序 设 计 方 法 ( 如 C 和 Pascal) 结 构 化 语 言 可 以 编 写 中 等 复 杂 程 度 的 程 序, 但 不 适 合 于 开 发 大 型 工 程 为 了 冲 破 这 一 束 缚, 创 建 了 面 向 对 象 方 法 面 向 对 象 程 序 设 计 方 法 采 纳 了 结 构 化 程 序 设 计 的 思 想 精 华, 并 且 新 增 了 一 些 概 念 和 特 性, 使 其 性 能 大 大 提 高 所 有 面 向 对 象 程 序 设 计 语 言, 包 括 Java 在 内, 都 有 3 种 特 性 : 封 装 (encapsulation) 多 态 性 (polymorphism) 和 继 承 (inheritance) 下 面 将 分 别 简 单 介 绍 它 们 的 概 念 及 用 法 1.3.1 封 装 封 装 是 一 种 将 代 码 与 其 处 理 的 数 据 绑 定 在 一 起 的 编 程 机 制 该 机 制 保 证 了 程 序 的 数 据 不 受 外 部 干 扰 且 不 被 误 用 理 解 封 装 性 的 方 法 就 是 把 它 想 成 一 个 黑 匣 子, 它 可 以 阻 止 在 外 部 定 义 的 代 码 随 意 访 问 内 部 代 码 和 数 据 对 黑 匣 子 内 的 代 码 和 数 据 的 访 问 通 过 适 当 定 义 的 接 口 严 格 控 制 在 面 向 对 象 语 言 中, 代 码 和 数 据 可 以 创 建 自 包 含 的 黑 匣 子 该 黑 匣 中 包 含 了 所 有 必 需 的 数 据 和 代 码 当 代 码 和 数 据 以 这 种 方 式 绑 定 在 一 起 时, 就 创 建 了 对 象 在 对 象 中 的 代 码 或 数 据, 仅 可 以 被 对 象 的 其 他 部 分 访 问, 不 允 许 被 对 象 以 外 的 任 何 程 序 访 问 时, 我 们 就 称 该 代 码 和 数 据 为 私 有 的 (private) 对 象 中 的 代 码 或 数 据, 尽 管 是 定 义 在 对 象 中, 却 允 许 对 象 所 在 程 序 的 其 他 部 分 进 行 访 问, 那 么 我 们 称 该 代 码 和 数 据 为 公 有 的 (public) Java 的 基 本 封 装 单 元 是 类 (class) 本 书 后 面 将 会 详 尽 地 介 绍 类 的 知 识 类 定 义 了 对 象 的 形 式, 指 定 了 数 据 和 操 作 数 据 的 代 码 Java 使 用 类 规 范 来 构 造 对 象 对 象 是 类 的 实 例 因 此, 类 在 本 质 上 是 指 定 如 何 构 建 对 象 的 一 系 列 计 划 组 成 类 的 代 码 或 数 据 被 称 为 类 的 成 员 (member) 类 定 义 的 数 据 被 称 为 成 员 变 量 (member variable) 或 实 例 变 量 (instance variable) 处 理 这 些 数 据 的 代 码 则 被 称 为 成 员 方 法 (member method) 或 简 称 为 方 法 (method) 方 法 是 子 例 程 在 Java 中 的 术 语 如 果 熟 悉 C/C++, 那 么 这 将 有 助 于 了 解 Java 程 序 中 的 方 法 和 C/C++ 程 序 中 的 函 数 5 1.3.2 继 承 继 承 是 一 个 对 象 获 得 另 一 个 对 象 属 性 的 过 程 继 承 之 所 以 重 要 是 因 为 它 支 持 了 按 层 分 类 的 概 念, 即 类 层 次 结 构 例 如, 猎 犬 是 狗 类 的 一 种, 狗 又 是 哺 乳 动 物 类 的 一 种, 哺 乳 动 物 类 又 是 动 物 类 的 一 部 分 如 果 不 使 用 层 次 结 构, 我 们 就 不 得 不 分 别 定 义 每 个 动 物 的 所 有 属 性 使 用 了 继 承, 一 个 对 象 就 只 需 定 义 使 它 在 所 属 类 中 独 一 无 二 的 属 性 即 可, 因 为 它 可 以 从 它 的 父 类 继 承 所 有 通 用 属 性 因 此, 继 承 机 制 使 对 象 成 为 更 一 般 的 类 的 特 定 实 例 继 承 性 与 封 装 性 相 互 作 用 如 果 一 个 给 定 的 类 封 装 了 一 种 属 性, 那 么 它 的 任 何 子 类 将 具 有 同 样 的 属 性, 而 且 还 添 加 了 子 类 自 己 特 有 的 属 性 这 是 面 向 对 象 的 程 序 在 复 杂 性
Java 程 序 设 计 实 践 教 程 上 呈 线 性 而 非 几 何 性 增 长 的 一 个 关 键 特 性 1.3.3 多 态 性 6 多 态 性 是 允 许 一 个 接 口 被 多 个 同 类 动 作 使 用 的 特 性, 具 体 使 用 哪 个 动 作 与 应 用 场 合 有 关 下 面 我 们 用 一 个 先 进 先 出 型 堆 栈 为 例 说 明 假 设 你 的 程 序 需 要 3 个 不 同 类 型 的 堆 栈 一 个 用 于 处 理 整 型 值 一 个 用 于 处 理 浮 点 型 值, 一 个 用 于 处 理 字 符 在 这 个 示 例 中, 尽 管 堆 栈 存 储 的 数 据 类 型 不 同, 但 是 实 现 各 个 堆 栈 的 算 法 都 是 一 致 的 在 非 面 向 对 象 的 语 言 中, 需 要 创 建 3 个 不 同 的 堆 栈 例 程, 每 个 例 程 使 用 不 同 的 名 称 但 是, 如 果 使 用 Java, 由 于 它 具 有 多 态 性 的 特 点, 你 只 需 创 建 一 个 基 本 的 堆 栈 例 程 就 可 以 实 现 对 这 三 种 特 定 情 况 的 处 理 多 态 性 的 概 念 经 常 被 说 成 一 个 接 口, 多 种 方 法 这 就 意 味 着 可 以 为 一 组 相 关 的 动 作, 设 计 一 个 通 用 的 接 口 多 态 性 通 过 允 许 同 一 接 口 被 同 一 类 的 多 个 动 作 使 用, 从 而 减 少 了 程 序 的 复 杂 度 编 译 器 的 工 作 就 是 选 择 适 用 于 各 个 情 况 的 特 定 动 作 ( 即 方 法 ) 而 你 只 需 记 住 以 及 利 用 这 个 统 一 的 接 口 就 可 以 了 多 态 性 封 装 性 与 继 承 性 相 互 作 用 精 心 设 计 的 类 层 次 结 构 是 程 序 的 基 础, 封 装 可 以 使 在 不 破 坏 依 赖 于 类 公 共 接 口 的 代 码 基 础 上 对 程 序 进 行 升 级 迁 移, 多 态 性 则 有 助 于 编 写 清 楚 易 懂 易 读 易 修 改 的 程 序 在 由 多 态 性 封 装 性 与 继 承 性 共 同 组 成 的 编 程 环 境 中 可 以 写 出 比 面 向 过 程 模 型 环 境 更 可 靠 扩 展 性 更 好 的 程 序 1.3.4 Java 的 开 发 工 具 Java 语 言 提 供 了 一 个 免 费 的 开 发 工 具 集 Java Developer s Kit, 简 称 JDK, 又 称 为 J2SDK 可 以 到 http://www.javasoft.com 上 下 载, 其 安 装 过 程 十 分 简 单, 是 Java 最 基 本 的 开 发 工 具 目 前 最 新 版 本 是 JDK1.5, 又 称 为 JDK5.0 JDK 由 用 于 开 发 和 测 试 Java 程 序 的 许 多 单 独 程 序 组 成 的, 每 个 程 序 由 命 令 行 激 活 在 JDK 中, 有 两 个 重 要 程 序 javac.exe 和 java.exe javac.exe 是 Java 语 言 编 译 器, 用 来 将 java 源 程 序 编 译 成 Java 字 节 码 java.exe 是 Java 语 言 解 释 器, 用 来 执 行 Java 字 节 码 得 到 结 果 当 安 装 了 JDK 以 后, 在 编 译 和 运 行 Java 程 序 时, 有 两 个 环 境 变 量 需 要 设 置 :path 和 classpath,path 用 于 设 置 命 令 文 件 搜 索 的 路 径, 如 javac.exe, java.exe 等,classpath 用 于 设 置 用 户 类 文 件 搜 索 的 路 径 例 如,JDK 安 装 在 C:\Program Files\Java\jdk1.5.0_07 中, 而 源 文 件 及 编 译 生 成 的 目 标 文 件 在 D:\mycode 中 要 能 正 确 编 译 与 运 行 在 MS-DOS 方 式 下 应 该 设 置 如 下 : D:\>set path=.; C:\Program Files\Java\jdk1.5.0_07\bin; D:\>set classpath=.;d:\mycode; 在 Windows 2000/NT/XP 环 境 中, 右 击 桌 面 上 我 的 电 脑, 选 择 属 性, 然 后 选 择 高 级 选 项 卡, 单 击 环 境 变 量 按 钮, 出 现 如 图 1-1 所 示 的 环 境 变 量 对 话 框 选 中 系 统 变 量 下 的 path 选 项, 单 击 编 辑 按 钮, 打 开 如 图 1-2 所 示 的 编 辑 系 统 变 量
Java 概 述 第 1 章 对 话 框, 在 变 量 值 里 添 加 或 输 入 JDK 开 发 工 具 包 的 路 径 若 在 系 统 变 量 下 没 有 path 选 项, 则 单 击 新 建 按 钮, 出 现 如 图 1-3 所 示 的 新 建 系 统 变 量 对 话 框, 在 变 量 名 中 输 入 path, 再 在 变 量 值 中 添 加 或 输 入 JDK 开 发 工 具 包 的 路 径 classpath 的 设 置 步 骤 与 path 设 置 完 全 类 似 输 入 JDK 路 径 图 1-2 编 辑 系 统 变 量 对 话 框 输 入 path 输 入 JDK 路 径 图 1-1 环 境 变 量 对 话 框 图 1-3 新 建 系 统 变 量 对 话 框 除 传 统 的 JDK 之 外, 许 多 公 司 还 推 出 了 可 视 化 的 基 于 Java 语 言 的 集 成 开 发 工 具, 如 Visual Age for Java( 即 WebSphere Studio Application Developer),JCreator,Workshop, JBuilder 等 其 中 Borland 公 司 推 出 的 JBuilder 是 目 前 较 流 行 的 Java 可 视 化 集 成 开 发 工 具 在 此 我 们 不 做 过 多 介 绍, 有 兴 趣 的 读 者 可 以 查 看 其 他 相 关 资 料 7 1.4 一 个 简 单 的 Java 程 序 Java 程 序 分 为 两 种 :Java Application 和 Java Applet Java Application 可 以 独 立 运 行 Java Applet 不 能 独 立 运 行, 它 可 以 使 用 Applet Viewer 或 其 他 支 持 Java 的 浏 览 器 运 行 不 论 是 哪 种 Java 程 序, 都 保 存 成 后 缀 为.java 的 文 件 本 节 将 通 过 一 个 简 单 的 Java Application 程 序, 初 步 了 解 Java 程 序 编 写 编 译 运 行 的 基 本 过 程 ; 同 时 说 明 Java 程 序 的 基 本 要 素 1.4.1 编 写 Java 程 序 Java 程 序 的 代 码 可 以 用 多 种 工 具 编 写, 如 记 事 本 Word EditPlus UltraEdit 等 文 本 编 辑 工 具 现 在 我 们 用 记 事 本 输 入 一 段 代 码, 实 现 在 屏 幕 上 输 出 Hello World! 字 符 串 的 操 作 代 码 如 下 : /* This is a simple Java program. Call this file HelloWorld.java.
Java 程 序 设 计 实 践 教 程 */ public class HelloWorld { // A Java program begins with a call to main(). public static void main(string args[]) { System.out.println("Hello World!"); 我 们 将 代 码 保 存 到 HelloWorld.java( 扩 展 名 为.java, 设 路 径 为 d:\mycode) 文 件 中 根 据 上 述 代 码, 先 对 Java 程 序 文 件 做 一 个 简 要 说 明 在 Java 中, 每 个 Java 程 序 至 少 必 须 有 一 个 类 每 个 类 都 要 先 声 明, 然 后 定 义 该 类 的 数 据 和 方 法 上 例 中,HelloWorld 即 为 类 名 类 中 包 含 一 个 名 为 main 的 方 法 该 程 序 中 的 main 方 法 包 含 println 语 句 main 方 法 由 解 释 器 激 活 该 程 序 中,println( Hello World! ) 语 句 用 来 输 出 字 符 串 信 息 的 语 句 另 外, 与 其 他 语 言 可 以 随 便 命 名 文 件 名 不 同,Java 程 序 的 源 文 件 名 必 须 和 其 中 的 某 个 类 名 相 同, 若 有 公 共 类, 则 文 件 名 必 须 和 公 共 类 类 名 相 同 扩 展 名 必 须 是 java 在 该 例 中 文 件 名 必 须 是 HelloWorld.java 这 些 属 于 Java 语 言 的 语 法 规 则, 一 定 要 遵 守, 否 则 编 译 器 会 报 告 语 法 错 误 8 1.4.2 编 译 和 执 行 Java 程 序 现 在 我 们 开 始 编 译 和 执 行 HelloWorld.java 程 序 对 于 JDK 而 言, 我 们 需 要 首 先 进 入 MS-DOS 环 境, 并 进 入 D:\mycode 子 目 录 下 ( 和 本 章 1.3.4 节 内 环 境 变 量 中 配 置 的 一 致 ) 然 后, 用 编 译 器 javac.exe 进 行 编 译, 如 图 1-4 所 示 在 命 令 行 中 输 入 javac HelloWorld.java 命 令,Java 编 译 器 自 动 编 译 如 果 编 译 没 有 错 误, 将 生 成 字 节 码 文 件 HelloWorld.class; 如 果 有 错 误, 则 应 回 到 编 辑 状 态 修 改 源 文 件, 然 后 保 存 再 重 新 编 译 最 后 用 解 释 器 java.exe 运 行 字 节 码 文 件 HelloWorld. class 在 命 令 行 输 入 java HelloWorld 命 令, 运 行 并 得 到 图 1-4 编 译 Java 源 程 序 结 果, 即 在 屏 幕 上 输 出 了 Hello World! 字 符 串, 如 图 1-5 所 示 图 1-5 运 行 Java 字 节 码 文 件 得 到 的 结 果 注 意 在 执 行 程 序 时 不 要 在 命 令 行 使 用 扩 展 名.class Java 解 释 器 将 命 令 中 的 第 一 个 参 数 假 定 为 文 件 名, 然 后 用 文 件 名 加 上.class 后 缀 执 行 如 果 在 命 令 行 中 使 用 Java 文 件 名.class, 那 么 将 得 到 文 件 名.class.class 如 上 述 命 令 java HelloWorld 中 HelloWorld 为 HelloWorld. class 文 件
Java 概 述 第 1 章 1.4.3 Java 程 序 的 基 本 要 素 尽 管 HelloWorld.java 很 短, 但 它 包 括 了 所 有 Java 程 序 具 有 的 基 本 要 素 及 几 个 关 键 特 性 现 在 我 们 以 HelloWorld.java 为 例 简 要 说 明 java 程 序 的 基 本 要 素 及 编 码 规 范 上 述 应 用 程 序 包 含 以 下 元 素 : 标 识 符 保 留 字 注 释 修 饰 符 语 句 块 类 方 法 main 方 法 要 创 建 一 个 程 序, 必 须 理 解 这 些 基 本 元 素 下 面 分 别 解 释 这 些 元 素 1. 标 识 符 Java 中 标 识 符 是 给 方 法 变 量 或 其 他 用 户 定 义 项 所 起 的 名 称 标 识 符 可 以 有 一 个 或 多 个 字 符 在 Java 语 言 中, 标 识 符 构 成 规 则 如 下 : 标 识 符 由 数 字 (0~9) 和 字 母 (A~Z 和 a~z), 美 元 符 号 ($) 下 划 线 (_) 以 及 Unicode 字 符 集 中 符 号 大 于 0xC0 的 所 有 符 号 连 续 组 合 构 成 ( 各 符 号 之 间 没 有 空 格 ) 标 识 符 的 第 一 个 符 号 为 字 母 下 划 线 或 美 元 符 号, 后 面 可 以 是 任 何 字 母 数 字 美 元 符 号 或 下 划 线 另 外 Java 区 分 大 小 写, 对 Java 而 言,myvar 和 MyVar 是 两 个 不 同 的 变 量 9 注 意 标 识 符 命 名 时, 切 记 不 能 以 数 字 开 头, 也 不 能 使 用 任 何 Java 关 键 字 作 为 标 识 符, 而 且 也 不 能 赋 给 标 识 符 以 任 何 标 准 方 法 名 标 识 符 分 为 两 类 : 保 留 关 键 字 和 用 户 自 定 义 标 识 符 保 留 字 是 有 特 殊 含 义 的 标 识 符, 如 true false 表 示 逻 辑 的 真 假 接 下 来 我 们 将 详 细 介 绍 保 留 字 用 户 自 定 义 标 识 符 是 由 用 户 自 己 按 标 识 符 构 成 规 则 生 成 的 非 保 留 字 的 标 识 符, 如 abc 就 是 一 个 标 识 符 当 使 用 标 识 符 时 一 定 注 意 : 或 者 使 用 保 留 字, 或 者 自 己 定 义 非 保 留 字 的 标 识 符 ; 此 外, 标 识 符 可 以 包 含 保 留 字, 但 不 能 与 保 留 字 重 名 合 法 标 识 符 :Dec,$2100,_grade,P_$admin 等 不 合 法 标 识 符 :3Com,eye f,if,else 等 标 识 符 用 来 命 名 常 量 变 量 类 类 的 对 象 等 因 此, 一 个 良 好 的 编 程 习 惯 要 求 命 名 标 识 符 时, 应 赋 予 它 一 个 有 意 义 或 作 用 的 名 字 2. 保 留 字 保 留 字 或 关 键 字 是 对 编 译 器 有 特 殊 意 义 的 固 定 单 词, 不 能 在 程 序 中 做 其 他 目 的 之 用 保 留 字 具 有 专 门 意 义 和 用 途, 和 用 户 自 定 义 的 标 识 符 不 同, 不 能 当 作 一 般 的 标 识 符 使 用 例 如 在 HelloWorld.java 中,class 即 是 保 留 字, 它 用 来 声 明 一 个 新 类, 其 类 名 为 HelloWorld; public 也 是 保 留 字, 它 用 来 表 示 公 共 类 另 外,static 和 void 也 都 是 保 留 字, 它 们 的 使 用
Java 程 序 设 计 实 践 教 程 将 在 本 书 后 面 介 绍 Java 语 言 目 前 定 义 了 50 个 关 键 字 ( 如 表 1-1 所 示 ) 这 些 包 含 语 法 运 算 符 和 分 隔 符 的 关 键 字 形 成 了 Java 语 言 的 定 义 这 些 关 键 字 不 能 作 为 变 量 名 类 名 或 方 法 名 使 用 表 1-1 Java 的 保 留 关 键 字 abstract assert boolean break byte case catch char class continue default do double else enum extends 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 try void volatile while 提 示 因 为 Java 区 分 大 小 写, 所 以 public 是 保 留 字 而 Public 不 是 因 此, 为 了 程 序 的 清 晰 及 可 读 性, 要 尽 量 避 免 使 用 保 留 字 的 其 他 形 式 10 3. 注 释 注 释 是 对 程 序 语 名 的 说 明, 它 有 助 于 程 序 员 和 用 户 之 间 的 交 流, 方 便 理 解 程 序 注 释 不 是 编 程 语 句, 因 此 被 编 译 器 忽 略 在 Java 中, 一 行 的 注 释 以 双 斜 杠 (//) 标 志, 多 行 的 注 释 包 含 在 /* 和 */ 内 当 编 译 器 看 到 //, 就 会 忽 略 该 行 // 之 后 的 所 有 文 本 当 看 到 /* 后, 扫 描 下 一 个 */ 并 忽 略 /* 和 */ 之 间 的 任 何 文 本 下 面 是 HelloWorld.java 中 的 两 种 注 释 语 句 /* This is a simple Java program. // 多 行 注 释 Call this file HelloWorld.java. */ // A Java program begins with a call to main(). // 单 行 注 释 提 示 除 了 两 种 风 格 的 注 释 (// 和 */) 外,Java 还 支 持 特 殊 类 型 的 注 释, 称 为 javadoc 注 释 Javadoc 注 释 以 /** 开 始, 以 */ 结 束 它 们 用 于 归 档 类 数 据 和 方 法 可 以 使 用 JDK 的 javadoc 命 令 将 它 们 抽 取 到 HTML 文 件 要 获 得 更 多 有 关 信 息, 可 以 访 问 站 点 java.sun.com/j2se/javadoc/ indx.html 4. 修 饰 符 Java 使 用 了 一 定 数 量 的 称 为 修 饰 符 的 保 留 字, 这 些 修 饰 符 指 定 了 数 据 方 法 和 类 的 属 性 以 及 它 们 的 使 用 例 如,public 和 static 都 是 修 饰 符 另 外 还 有 private final abstract 和 protected 一 个 public 数 据 方 法 或 者 类 可 以 被 其 他 的 类 访 问 而 一 个 private 数 据 或 方 法 不 能 被 其 他 类 访 问 后 面 章 节 将 相 继 介 绍 这 些 修 饰 符 的 用 法
Java 概 述 第 1 章 5. 语 句 语 句 代 表 一 个 动 作 或 一 系 列 动 作 例 如 System.out.println("Hello World!"); 就 是 一 个 语 句, 表 示 输 出 字 符 串 "Hello World!" 到 屏 幕 上 在 Java 语 言 中 语 句 均 是 以 分 号 ; 结 尾 6. 块 程 序 中 的 大 括 号 形 成 了 组 织 程 序 中 元 件 的 块 在 Java 中, 每 个 块 以 大 括 号 { 开 始, 以 大 括 号 结 束 每 个 类 都 有 组 织 该 类 数 据 和 方 法 的 类 块 每 个 方 法 都 有 组 织 该 方 法 内 语 句 的 方 法 块 块 可 以 嵌 套, 也 就 是 说 一 个 块 可 以 放 置 在 另 一 个 块 内, 如 下 面 的 代 码 所 示 public class HelloWorld { // A Java program begins with a call to main(). public static void main(string args[]) { System.out.println("Hello World!"); 7. 类 类 是 Java 的 基 本 构 架 在 Java 中 编 程 必 须 理 解 类 并 学 会 编 写 和 使 用 类 上 面 我 们 已 经 讲 到, 在 Java 中, 每 个 Java 程 序 至 少 必 须 有 一 个 类 每 个 类 都 要 先 声 明, 然 后 定 义 该 类 的 数 据 和 方 法 Java 中 可 以 定 义 多 个 类 每 个 Java 程 序 的 定 义 都 是 使 用 一 个 或 多 个 类 完 成 的 在 上 例 中,HelloWorld 即 为 类 名 有 关 类 的 知 识 将 在 后 面 第 5 章 详 细 介 绍 11 8. 方 法 在 Java 中, 方 法 同 C 中 的 函 数 作 用 相 似, 都 可 以 执 行 一 系 列 动 作 如 上 例 中 System. out.println("hello World!"), 是 执 行 向 控 制 台 输 出 字 符 串 信 息 其 中 System.out 是 标 准 输 出 对 象 println 是 该 对 象 内 的 一 个 方 法, 它 由 执 行 向 标 准 输 出 设 备 显 示 信 息 的 一 系 列 操 作 语 句 集 组 成 通 过 调 用 带 有 字 符 串 参 数 的 语 句 对 它 进 行 操 作 在 上 例 中,"Hello World!" 即 为 参 数 可 以 用 不 同 的 参 数 调 用 同 一 个 println 方 法, 显 示 不 同 的 信 息 9.main() 方 法 main() 方 法 是 Java 程 序 中 非 常 重 要 的 方 法, 它 是 程 序 的 入 口 如 上 例 中, 在 HelloWorld 类 中 定 义 了 一 个 main() 方 法, 其 中 public 表 示 访 问 权 限, 指 明 所 有 的 类 都 可 以 使 用 这 一 方 法 ;static 指 明 该 方 法 是 一 个 类 方 法 ( 又 称 为 静 态 方 法 ), 它 可 以 通 过 类 名 直 接 调 用 ; void 则 指 明 main() 方 法 不 返 回 任 何 值 对 于 一 个 应 用 程 序 来 说,main() 方 法 是 必 需 的, 而 且 必 须 按 照 上 面 的 格 式 来 定 义 Java 解 释 器 在 没 有 生 成 任 何 实 例 情 况 下, 以 main() 作 为 入 口 来 执 行 程 序 Java 程 序 中 可 以 定 义 多 个 类, 每 个 类 中 可 以 定 义 多 个 方 法, 但 main() 方 法 只 能 有 一 个, 作 为 程 序 的 入 口 main() 方 法 定 义 中, 括 号 () 中 的 String[] args 是 传 递 给 main() 方 法 的 参 数, 参 数 名 为 args, 它 是 类 String 的 一 个 实 例, 参 数 可 以 为 0 个 或 多
Java 程 序 设 计 实 践 教 程 个, 多 个 参 数 间 用 括 号 分 隔 main() 方 法 的 实 现 由 花 括 号 { 括 起 来 10. 编 码 规 范 以 上 是 对 Java 程 序 中 的 基 本 要 素 下 面 我 们 介 绍 Java 程 序 编 码 规 范 编 码 规 范 是 对 编 码 的 一 些 约 定, 主 要 作 用 是 增 强 代 码 的 可 读 性 和 可 维 护 性, 便 于 代 码 重 用 首 先 要 求 程 序 中 的 各 个 要 素 都 遵 守 命 名 规 则, 然 后 在 编 码 中 严 格 按 照 编 码 格 式 编 写 代 码 命 名 规 则 包 括 以 下 几 点 : 包 的 名 字 由 一 个 小 写 字 母 序 列 组 成 类 的 名 字 由 大 写 字 母 开 头 而 其 他 字 母 都 小 写 的 单 词 组 成 类 的 实 例 的 名 字 由 一 个 小 写 字 母 开 头 后 面 的 单 词 由 大 写 字 母 开 头 常 量 的 名 字 都 大 写, 并 且 指 出 完 整 含 义 参 数 的 名 字 无 其 他 具 体 规 定 数 组 的 命 名 使 用 类 型 [] 数 组 名 形 式 比 如 使 用 下 面 语 句 : int[] count; // 定 义 一 个 int 型 的 count 数 组 12 另 外 编 码 格 式 规 定 如 下 : 程 序 最 开 始 编 写 导 入 包 和 类 语 句, 即 import 语 句 import 语 句 可 以 有 多 行 编 写 完 import 语 句 后 空 一 行 定 义 public 类, 顶 格 书 写 类 体 的 左 括 号 { 不 换 行 书 写, 右 括 号 顶 格 书 定 定 义 public 类 中 的 变 量, 跳 格 书 写 ( 一 般 跳 4 格 或 8 格, 建 议 4 格, 这 样 书 写 的 余 度 较 大 ) 一 般 一 个 变 量 定 义 占 一 行 定 义 方 法 跳 格 书 写 方 法 的 左 不 换 行 书 写, 右 和 方 法 首 行 第 一 个 字 符 对 齐 方 法 体 要 再 次 跳 格 书 写 最 后 一 个 变 量 定 义 和 第 一 个 方 法 定 义 之 间 方 法 和 方 法 之 间 最 好 空 一 行 注 意 在 单 一 的 语 句 后 有 ; 号, 在 一 对 括 号 { 之 外 无 ; 号 方 法 调 用 名 和 紧 跟 在 其 后 的 左 括 号 ( 无 空 格, 该 左 括 号 和 其 后 的 标 识 符 之 间 无 空 格 多 个 参 数 之 间 的 逗 号 和 前 一 个 参 数 紧 靠, 与 后 一 个 参 数 空 一 格 1.5 实 验 指 导 实 验 指 导 1-1: 配 置 JDK 环 境 变 量, 并 运 行 文 件 在 本 练 习 中, 下 载 并 安 装 JDK1.5, 然 后 配 置 环 境 变 量, 并 在 DOS 环 境 下 编 译 和 运 行 Example.java 文 件
Java 概 述 第 1 章 实 验 步 骤 : (1) 在 http://www.javasoft.com 中 下 载 JDK1.5, 并 安 装 到 C:\ java\jdk1.5 下 源 文 件 和 目 标 文 件 放 在 D:\code 中 (2) 配 置 JDK 环 境 变 量 path 和 classpath( 按 照 1.3.4 节 中 Windows 下 JDK 配 置 方 法 ) 其 中 path 的 变 量 值 =.; C:\ Java\jdk1.5.0_07\bin classpath 的 变 量 值 =.;D:\code (3) 在 记 事 本 内 输 入 以 下 代 码, 命 名 为 Example.java, 保 存 到 D:\code 下 /* Here is another short example. Call this file "Example.java". */ class Example { public static void main(string args[]) { int num; // this declares a variable called num num = 100; // this assigns num the value 100 System.out.println("This is num: " + num); num = num * 2; System.out.print("The value of num * 2 is "); System.out.println(num); 13 (4) 单 击 Windows 开 始 按 钮, 选 择 程 序 附 件, 单 击 命 令 提 示 符 进 入 DOS 环 境 (5) 在 命 令 行 输 入 DOS 命 令, 进 入 D:\code 目 录 (6) 在 命 令 行 输 入 javac Example.java, 编 译 Example.java 文 件 若 编 译 提 示 出 现 错 误, 则 返 回 文 件 的 编 辑 状 态 进 行 修 改 (7) 当 没 有 编 译 错 误 时, 在 命 令 行 输 入 java Example, 运 行 Example.class 文 件 (8) 输 出 运 行 结 果 1.6 思 考 与 练 习 一 填 空 题 1. 运 行 Java 程 序 需 要, 它 直 接 对 Java 字 节 码 进 行 解 释 执 行 2.Java 程 序 可 以 方 便 地 被 移 植 到 网 络 上 的 不 同 机 器, 同 时 Java 的 类 库 中 也 实 现 了 与 不 同 平 台 的 接 口, 这 是 Java 的 特 点 3.Java 的 核 心 是 面 向 对 象 程 序 设 计 (OOP), 它 有 3 个 特 性 : 封 装 继 承 4. 封 装 是 一 种 将 代 码 与 其 处 理 的 数 据 绑 定 在 一 起 的 编 程 机 制, 它 的 基 本 封 装 单 元 是 5. 多 态 性 的 概 念 经 常 被 说 成 6.Java 程 序 分 为 两 种 :Java Application 程 序 ( 可 以 独 立 运 行 ) 和 程 序 ( 不 能 独 立 运 行 ) 7.Java 程 序 首 先 通 过 javac.exe 程 序 编 译, 然 后 用 程 序 运 行 获 得 结 果 8.System.out.println() 语 句 的 作 用 是 9. 在 Java 中, 一 行 的 注 释 以 双 斜 杠 (//) 标 志, 一 行 或 多 行 的 注 释 包 含 在 内
Java 程 序 设 计 实 践 教 程 14 10. 在 Java 程 序 中 方 法 非 常 重 要, 是 整 个 程 序 的 入 口 二 选 择 题 1. 下 列 有 关 Java 与 C C++ C# 之 间 关 系 说 法 错 误 的 是 A.Java 继 承 了 C 的 大 部 分 语 法,Java 的 对 象 模 型 则 从 C++ 改 编 而 来 B.ava 大 部 分 的 特 性 是 从 C 和 C++ 中 继 承 的, 可 以 说 Java 是 C++ 的 增 强 版 C.C# 的 许 多 功 能 都 是 直 接 从 Java 改 编 来 的, 它 和 Java 共 享 相 同 的 C++ 语 法 风 格, 都 支 持 分 布 式 程 序 设 计, 使 用 相 同 的 对 象 模 型 D. 在 未 来 几 年 内,Java 和 C++ C# 将 会 长 期 共 存 2. 现 有 Test.java 文 件, 要 求 在 MS-DOS 环 境 进 行 编 译 和 运 行 首 先 在 命 令 行 输 入 语 句 进 行 编 译, 若 编 译 没 有 出 现 错 误, 然 后 在 命 令 行 输 入 语 句 运 行 生 成 的.class 文 件 A.javac Test.java B.javac Test C.java Test D.java Test.class 3. 下 列 哪 一 项 是 合 法 的 标 识 符 A.$count B.4point_5 C.x+y D.while 4. 下 面 哪 一 项 是 保 留 关 键 字 A.String B.IF C.Int D.private 5. 下 面 说 法 错 误 的 是 A. 包 的 名 字 由 一 个 小 写 字 母 序 列 组 成 B. 类 的 名 字 由 大 写 字 母 开 头 而 其 他 字 母 都 小 写 的 单 词 组 成 C. 类 的 实 例 名 字 由 一 个 小 写 字 母 开 头, 后 面 的 单 词 由 大 写 字 母 开 头 D. 无 论 在 单 一 的 语 句 后 还 是 在 一 对 括 号 { 之 外 都 要 用 ; 号 表 示 语 句 的 结 束
第 2 章 数 据 类 型 与 运 算 符 计 算 机 语 言 通 常 都 要 包 含 数 据 类 型 运 算 符 与 表 达 式 等 基 本 内 容,Java 语 言 也 不 例 外 这 些 内 容 相 对 于 一 门 语 言 来 说 就 如 同 一 座 大 楼 的 基 石 一 样 重 要, 它 们 不 仅 定 义 了 语 言 的 规 范 和 规 则, 还 决 定 了 它 可 以 执 行 什 么 样 的 数 据 操 作 数 据 类 型 和 运 算 符 是 本 章 的 重 点, 除 此 之 外 我 们 还 要 简 单 介 绍 常 量 变 量 和 表 达 式 等 基 本 内 容 由 于 数 据 类 型 和 运 算 符 包 括 的 内 容 很 多, 这 一 章 我 们 主 要 讲 述 Java 基 本 数 据 类 型 和 常 用 的 运 算 符 并 简 单 介 绍 常 量 变 量 和 表 达 式 本 章 学 习 要 点 : 理 解 常 量 变 量 和 表 达 式 掌 握 Java 中 的 数 据 类 型 掌 握 运 算 符 和 表 达 式 的 应 用 2.1 常 量 变 量 和 表 达 式 Java 中 的 数 据 分 为 常 量 和 变 量 常 量 在 程 序 中 被 赋 予 一 个 值, 在 程 序 的 执 行 中 该 值 可 以 随 时 被 引 用, 而 且 在 运 行 过 程 中 不 会 改 变 因 此 常 量 主 要 用 于 在 程 序 中 多 次 用 到 同 一 个 数 字 或 字 符 串 等 情 况 变 量 用 来 存 放 指 定 类 型 的 数 据, 其 值 在 程 序 运 行 过 程 中 是 可 变 的 它 主 要 用 于 命 名 程 序 中 临 时 引 用 的 数 据 参 与 运 算 的 数 据 称 为 操 作 数 表 达 式 是 由 操 作 数 和 运 算 符 按 一 定 语 法 形 式 组 成 的 符 号 序 列, 例 如 a+b a+b*10 "name"+" 李 明 " 等 都 是 表 达 式 每 个 表 达 式 经 过 运 算 后 都 会 产 生 一 个 确 定 的 值 2.1.1 常 量 Java 程 序 运 行 时 值 不 可 修 改 的 量 称 为 常 量, 分 为 字 面 值 ( 即 常 数 ) 与 标 识 符 常 量 两 种 标 识 符 常 量 实 际 上 是 一 个 变 量, 但 它 的 值 一 旦 初 始 化 以 后, 就 不 允 许 再 发 生 改 变 因 此 标 识 符 常 量 要 先 定 义 后 使 用, 一 般 用 于 给 常 数 取 一 个 有 意 义 的 名 字 字 面 值 即 是 Java 源 程 序 中 表 示 的 常 数 值, 如 12.6 246 false 等, 表 示 一 个 个 具 体 的 值 常 量 在 表 达 式 中 用 文 字 串 表 示, 它 区 分 不 同 类 型, 如 整 型 常 量 123 15, 实 型 常 量 12.1f, 字 符 常 量 'x', 布 尔 常 量 true, 字 符 串 类 型 常 量 "Test" 等 后 面 章 节 将 会 详 细 介 绍 数 据 类 型 的 知 识 下 面 是 声 明 常 量 的 语 法 : final type CONSTANTNAME=VALUE; 其 中,final 是 Java 的 关 键 字, 表 示 该 常 量 值 不 会 改 变 type 是 常 量 的 数 据 类 型, CONSTANTNAME 是 常 量 名 称,VALUE 是 常 量 对 应 的 值 按 照 Java 编 码 规 范, 常 量 名 称 通 常 用 大 写 表 示, 若 常 量 名 由 两 个 或 两 个 以 上 单 词 组 成, 则 单 词 间 用 下 划 线 连 接, 如
Java 程 序 设 计 实 践 教 程 final int MAX_VALUE = 100 下 面 的 ComputeArea.java 程 序 用 于 计 算 圆 面 积, 其 中 将 3.1415926 定 义 为 常 量 PI 代 码 如 下 : 16 //ComputeArea 为 类 名 public class ComputeArea { //Main 方 法 public static void main(string args[]){ // 定 义 变 量 radius area 和 常 量 PI double radius; double area; final double PI= 3.1415926; // 给 变 量 赋 值 Radius Radius = 20; //Compute area Area = radius * radius * PI; // 输 出 结 果 System.out.println("The area for the circle of radius " +radius + " is " + area); 程 序 运 行 结 果 如 图 2-1 所 示 上 述 代 码 用 来 计 算 圆 面 积, 其 中 定 义 变 量 radius area 和 常 量 PI, 分 别 表 示 圆 半 径 面 积 和 算 术 运 算 中 的 π 值 这 里 PI 就 是 一 个 常 量, 它 的 值 是 3.1415926( 即 π), 它 的 数 据 类 型 是 double 型 在 程 序 执 行 过 程 中 PI 的 值 不 会 改 变 图 2-1 输 出 圆 的 面 积 提 示 常 量 在 使 用 前 必 须 进 行 声 明 和 初 始 化 常 量 的 值 一 旦 声 明 就 不 能 改 变 通 常 应 该 给 常 量 取 一 个 有 意 义 的 名 字 2.1.2 变 量 与 常 量 不 同, 变 量 在 程 序 运 行 时 值 会 发 生 改 变, 即 在 程 序 中 不 同 时 刻 可 以 被 赋 予 不 同 的 值 变 量 对 应 着 内 存 空 间 中 的 一 个 或 几 个 单 元, 变 量 的 值 就 存 放 在 所 对 应 的 内 存 单 元 中 变 量 名 就 是 对 应 的 内 存 单 元 的 名 称, 这 样 在 程 序 中 可 以 按 变 量 名 称 来 区 分 和 使 用 这 些 内 存 单 元 变 量 用 于 保 存 数 据 输 入 数 据 输 出 或 中 间 值 声 明 变 量 的 语 法 :type var-name; 其 中 type 是 变 量 的 数 据 类 型,var-name 是 变 量 的 名 称 下 面 是 变 量 声 明 的 几 个 例 子 : int x; double radius; // 将 x 声 明 为 整 型 变 量 // 将 radius 声 明 为 双 精 度 型 变 量
数 据 类 型 与 运 算 符 第 2 章 double interestrate; // 将 interestrate 声 明 为 双 精 度 型 变 量 char a; // 将 a 声 明 为 字 符 变 量 ; 上 面 的 例 子 用 到 了 整 型 双 精 度 型 和 字 符 型 数 据 类 型 本 章 后 面 将 介 绍 其 他 数 据 类 型, 如 字 节 型 短 整 型 长 整 型 浮 点 型 字 符 型 和 布 尔 型 如 果 几 个 变 量 为 同 一 种 类 型, 可 以 使 用 以 下 简 单 格 式 对 它 们 进 行 统 一 声 明 变 量 之 间 用 逗 号 隔 开 type var1,var2,..,varn; 注 意 按 照 Java 编 码 规 范, 变 量 名 以 小 写 字 母 开 头, 如 果 一 个 变 量 名 由 多 个 单 词 组 成, 则 第 一 个 单 词 之 后 的 所 有 单 词 都 以 大 写 字 母 开 头, 以 便 于 理 解 该 变 量 名 Java 中 在 使 用 变 量 之 前 必 须 赋 值 赋 值 方 法 有 两 种 : 一 种 方 法 是 对 已 声 明 过 的 变 量 利 用 赋 值 语 句 赋 值 赋 值 语 句 的 语 法 :var = value; 例 如 对 上 述 已 声 明 的 变 量 赋 值 :x = 1; radius = 1.0; interestrate = 2.35 a ='A'; 另 一 种 方 法 是 在 声 明 变 量 时 就 初 始 化, 即 赋 给 变 量 一 个 初 值 这 需 要 在 变 量 名 后 面 添 加 一 个 等 号, 然 后 赋 值 初 始 化 变 量 的 语 法 :type var = value; value 是 创 建 var 时 赋 给 它 的 值, 该 值 必 须 与 指 定 的 类 型 兼 容 下 面 是 几 个 示 例 : 17 int count =10; // 定 义 整 型 变 量 count, 并 给 它 赋 初 始 值 10 char ch ='x'; // 定 义 字 符 型 变 量 ch, 并 给 它 赋 初 始 值 字 符 x float f =1.2F; // 定 义 浮 点 型 变 量 f, 并 给 它 赋 初 始 值 1.2F 使 用 逗 号 分 隔 列 表 声 明 同 一 类 型 的 两 个 或 多 个 变 量 时, 可 以 给 一 个 或 多 个 变 量 赋 初 值 例 如 : int a, b=8,c=19,d; // 定 义 了 a,b,c,d 四 个 变 量, 但 只 初 始 化 了 b 和 c 虽 然 以 上 示 例 只 使 用 了 常 量 进 行 初 始 化, 但 是 Java 允 许 在 声 明 变 量 时 使 用 任 何 有 效 的 表 达 式 来 动 态 初 始 化 变 量 下 面 是 一 个 计 算 圆 柱 体 体 积 的 程 序, 其 中 底 圆 半 径 和 圆 柱 体 的 高 已 经 给 出, 代 码 如 下 : class DynInit{ public static void main(string args[]){ double radius = 4, height = 5; double volume = 3.1416 * radius * radius * height; System.out.println(" Volume is "+ volume); 程 序 运 行 结 果 如 图 2-2 所 示 图 2-2 输 出 圆 柱 体 体 积
Java 程 序 设 计 实 践 教 程 这 里 声 明 了 3 个 变 量,radius 和 height 初 始 化 为 常 量, 而 Volume 则 动 态 初 始 化 为 圆 柱 体 体 积 这 里 的 关 键 之 处 在 于 在 初 始 化 表 达 式 时 可 以 使 用 任 何 有 效 的 元 素, 包 括 调 用 方 法 其 他 变 量 和 数 值 在 内 在 赋 值 语 句 中, 左 边 变 量 的 数 据 类 型 必 须 与 右 边 数 值 的 数 据 类 型 兼 容 例 如,int x=1.0 就 是 非 法 的, 因 为 x 的 数 据 类 型 为 整 型 在 没 有 使 用 类 型 转 换 的 情 况 下, 不 能 将 双 精 度 数 值 (1.0) 赋 给 整 型 变 量 数 据 类 型 转 换 将 在 本 章 后 面 讲 到 另 外,Java 赋 值 语 句 使 用 等 号 =, 而 不 是 其 他 语 言 中 常 用 的 := 提 示 Java 中 的 所 有 变 量 都 必 须 在 使 用 前 声 明 因 为 编 译 器 必 须 在 正 确 编 译 使 用 变 量 的 语 句 前 知 道 变 量 的 数 据 类 型 2.2 数 据 类 型 18 数 据 是 程 序 操 作 的 对 象, 具 有 名 称 类 型 和 作 用 域 等 特 性 数 据 由 标 识 符 命 名 ; 数 据 的 类 型 表 示 数 据 的 性 质 占 用 内 存 多 少 以 及 存 放 格 式, 不 同 的 数 据 类 型 执 行 不 同 的 操 作 ; 数 据 的 作 用 域 表 示 数 据 在 程 序 中 可 以 使 用 的 范 围 Java 语 言 的 数 据 类 型 分 为 两 类 : 基 本 数 据 类 型 和 复 合 数 据 类 型 基 本 数 据 类 型 包 括 : boolean( 布 尔 型 ) char( 字 符 型 ) byte( 字 节 型 ) short( 短 整 型 ) int( 整 型 ) long ( 长 整 型 ) float( 单 精 度 浮 点 型 ) double( 双 精 度 浮 点 型 ) 共 8 种, 详 见 表 2-1 所 有 基 本 数 据 类 型 的 大 小 ( 所 占 用 的 字 节 数 ) 都 已 明 确 规 定 好, 在 各 种 不 同 的 平 台 上 都 保 持 一 致, 这 一 特 性 有 助 于 提 高 Java 程 序 的 可 移 植 性 复 合 数 据 类 型 建 立 在 基 本 数 据 类 型 的 基 础 上, 它 包 括 数 组 类 和 接 口 复 合 数 据 类 型 是 由 用 户 自 己 定 义 用 来 限 制 其 他 数 据 的 类 型 另 外,Java 语 言 中 不 支 持 C/C++ 中 的 指 针 类 型 结 构 类 型 联 合 类 型 和 枚 举 类 型 Java 是 一 种 强 制 类 型 的 语 言, 所 有 变 量 都 必 须 先 明 确 定 义 其 数 据 类 型, 然 后 才 能 使 用 Java 中 所 有 的 变 量 表 达 式 和 值 都 必 须 有 自 己 的 类 型, 没 有 无 类 型 变 量 这 样 的 概 念 表 2-1 Java 的 基 本 数 据 类 型 类 型 名 称 关 键 字 占 用 位 数 取 值 范 围 字 节 型 byte 8 128~127 短 整 型 short 16 32768~32767 整 型 int 32 2147483648~2147483647 长 整 型 long 64 9223372036854775808L~9223372036854775807L 单 精 度 浮 点 型 float 32 3.40282347E+38~3.40282347E+38 双 精 度 浮 点 型 double 64 1.79769313486231570E+308~ 1.79769313486231570E+308 字 符 型 char 16 0~65535 或 '\u0000'~'\uffff' 布 尔 型 boolean 8 true 或 false
数 据 类 型 与 运 算 符 第 2 章 上 表 中 的 8 种 基 本 数 据 类 型 又 可 分 为 4 大 类, 即 整 数 类 型 ( 包 括 byte short int 和 long) 浮 点 类 型 ( 包 括 float 和 double) 字 符 类 型 (char) 布 尔 类 型 (boolean) 下 面 我 们 来 分 别 介 绍 这 4 大 类 数 据 类 型 2.2.1 整 数 类 型 整 型 是 那 些 没 有 小 数 部 分 的 数 据 类 型, 包 含 下 列 数 据 类 型 :byte short int 和 long 这 些 不 同 整 数 数 据 类 型 的 区 别 在 于 它 们 所 需 的 内 存 空 间 大 小 不 同, 这 也 确 定 了 它 们 所 能 表 示 数 值 的 范 围 不 同 实 际 上 int 类 型 已 经 提 供 了 足 够 的 数 值 范 围, 大 多 数 情 况 下 用 int 类 就 够 了 1. 整 数 常 量 Java 的 整 型 常 量 有 3 种 形 式 : 十 进 制 整 数, 如 69,58, 25 八 进 制 整 数, 以 0 开 头, 如 010 表 示 十 进 制 的 8, 015 表 示 十 进 制 的 13 十 六 进 制 整 数, 以 0x 或 0X 开 头, 如 0x10 表 示 十 进 制 的 16, 0X15 表 示 十 进 制 的 21 Java 默 认 整 数 常 量 类 型 为 int 类 型, 用 4 个 字 节 表 示 如 果 要 表 示 long 类 型 整 数 需 要 在 整 数 后 加 上 后 缀 L 或 l, 表 示 它 为 长 整 数, 例 如 :6985470L,7941926l 19 2. 整 数 变 量 整 数 变 量 类 型 有 byte short int 和 long 声 明 整 数 类 型 变 量 : int aintvar; long alongvar; short ashortvar; byte abytevar; // 声 明 aintvar 变 量 是 int 类 型 // 声 明 alongvar 变 量 是 int 类 型 // 声 明 ashortvar 变 量 是 int 类 型 // 声 明 abytevar 变 量 是 int 类 型 在 Java 中, 所 有 的 整 数 类 型 都 有 正 负 值 之 分 最 常 用 的 整 数 类 型 是 int int 类 型 的 变 量 常 被 应 用 于 循 环 控 制 数 组 索 引, 以 及 执 行 通 常 目 的 的 整 数 数 学 运 算 当 需 要 的 整 数 范 围 超 过 int 时, 就 需 要 使 用 long 类 型 下 面 是 运 用 long 整 型 变 量 计 算 光 在 指 定 天 数 内 运 行 距 离 的 程 序 代 码 如 下 : class Light{ public static void main(string args[]) { int lightspeed; long days; long seconds; long distance; // 距 离 = 光 速 时 间 ( 以 秒 为 单 位 ) lightspeed = 186000; days = 1000; // 给 出 天 数
Java 程 序 设 计 实 践 教 程 seconds = days * 24 * 60 * 60; // 转 换 成 秒 distance = lightspeed * seconds; // 计 算 距 离 System.out.print("In " + days); System.out.print(" days light will travel about "); System.out.println(distance + " miles."); 上 述 代 码 中, 距 离 的 运 算 语 句 distance=lightspeed*seconds, 程 序 运 行 结 果 如 图 2-3 所 示 从 中 可 以 看 出, 结 果 已 经 超 出 int 变 量 的 范 围 最 小 的 整 数 类 型 是 byte 在 处 理 无 法 直 接 和 Java 的 其 他 内 置 类 型 兼 容 的 原 始 二 进 制 数 据 时,byte 类 型 的 变 量 特 别 有 用 short 类 型 被 定 义 为 高 位 字 节 放 于 前 面 ( 称 图 2-3 输 出 运 行 结 果 为 big-endian 格 式 ) 的 短 整 数, 它 可 能 是 Java 中 使 用 得 最 少 的 类 型 这 种 类 型 主 要 适 用 于 16 位 计 算 机, 现 在 已 经 很 少 见 了 20 2.2.2 浮 点 类 型 浮 点 型 是 带 有 小 数 部 分 的 数 据 类 型, 也 叫 实 型 浮 点 型 有 两 种 :float 和 double, 分 别 代 表 单 精 度 和 双 精 度 数 值 它 们 的 区 别 主 要 是 所 占 用 内 存 的 大 小 不 同 一 个 float 类 型 的 变 量 占 用 4 个 字 节 (32 位 ), 而 double 类 型 的 数 据 则 需 要 8 个 字 节 (64 位 ) Java 默 认 的 浮 点 型 是 double 类 型 例 如,5.0 被 认 为 是 double 类 型, 而 不 是 float 类 型 如 果 要 表 示 float 类 型, 要 在 数 字 后 追 加 字 母 f 或 F; 如 果 要 表 示 double 类 型, 要 在 数 字 后 追 加 d 和 D 例 如, 用 100.2f 或 100.2F 表 示 float 类 型,100.2d 或 100.2D 表 示 double 类 型 这 两 种 类 型 中 最 常 用 的 是 double 型, 因 为 Java 类 库 中 的 所 有 数 学 函 数 都 使 用 double 值 例 如,sqrt() 方 法 ( 由 标 准 Math 类 定 义 ) 返 回 一 个 其 double 参 数 的 平 方 根 的 double 值 下 面 就 是 利 用 sqrt() 方 法, 在 一 个 直 角 三 角 形 中 给 定 两 个 直 角 边 长 度, 求 其 斜 边 的 长 度 代 码 如 下 : import java.lang.*; // java.lang 包 中 包 含 Math 类 class DoubleSqrtDemo{ public static void main(string args[]) { double a = 3.0, b = 4.0; double c = Math.sqrt(a * a + b * b); // 调 用 Math 类 中 的 sqrt() 方 法 System.out.println("Hypotenuse is " + c); 程 序 运 行 结 果 如 图 2-4 所 示 关 于 本 示 例 还 有 一 点 说 明 :sqrt() 是 标 准 Math 类 的 一 个 成 员 注 意 调 用 sqrt() 的 方 式,sqrt() 跟 在 类 名 Math 的 后 面 这 与 System.out 后 面 跟 有 println() 的 方 式 相 似 图 2-4 输 出 斜 边 长 度
数 据 类 型 与 运 算 符 第 2 章 2.2.3 字 符 类 型 Java 的 字 符 使 用 16 位 的 Unicode 编 码 表 示, 它 可 以 支 持 世 界 上 所 有 语 言 一 般 计 算 机 语 言 通 常 使 用 ASCII 码, 用 8 位 表 示 一 个 字 符 ASCII 码 是 Unicode 码 的 一 个 子 集, Unicode 表 示 ASCII 码 时, 其 高 字 节 为 0, 它 是 其 前 255 个 字 符 Unicode 字 符 通 常 用 十 六 进 制 表 示 例 如 :"\u0000"~"\u00ff" 表 示 ASCII 码 集 "\u" 表 示 转 义 字 符, 它 用 来 表 示 其 后 4 个 十 六 进 制 数 字 是 Unicode 代 码 1. 字 符 型 常 量 字 符 型 常 量 就 是 用 两 个 单 引 号 括 起 来 的 一 个 字 符 例 如 :'A','a', '1',' ' 其 中 'A','a' 分 别 表 示 ASCII 码 中 的 字 符 A 和 a;'1' 表 示 字 符 1, 而 不 是 整 数 1;' ' 表 示 空 格 也 是 字 符 2. 字 符 型 变 量 字 符 型 变 量 的 类 型 是 char, 用 于 表 示 单 个 的 字 符 例 如 : char letter='d'; char numchar='4'; 21 第 一 个 语 句 将 字 符 A 赋 给 字 符 型 变 量 letter 第 二 个 语 句 将 数 字 字 符 4 赋 给 字 符 型 变 量 numchar 3. 字 符 串 常 量 一 个 字 符 串 常 量 是 括 在 两 个 双 引 号 之 间 0 个 或 多 个 字 符 组 成 的 序 列 若 两 个 双 引 号 之 间 没 有 任 何 字 符, 则 为 空 串 下 面 是 有 关 字 符 串 的 一 些 例 子 : "This is a string" "JAVA 2" "Hello World!" Java 语 言 把 字 符 串 常 量 当 作 String 类 型 的 一 个 对 象 来 处 理 有 关 字 符 串 的 知 识 在 后 面 章 节 将 详 细 介 绍 我 们 现 在 可 以 使 用 String 类 型 声 明 字 符 串 变 量 例 如 :String message = "Welcome to Java!"; 注 意 字 符 串 必 须 包 含 在 双 引 号 内 包 含 在 单 引 号 内 的 是 单 个 字 符 因 此 "A" 是 字 符 串, 而 'A' 是 字 符 因 为 char 是 无 符 号 16 位 类 型, 所 以 无 法 对 char 变 量 进 行 算 术 运 算 但 增 量 和 减 量
Java 程 序 设 计 实 践 教 程 操 作 符 可 以 用 在 字 符 变 量 中, 以 获 得 该 字 符 的 下 一 个 或 前 一 个 unicode 字 符 下 面 程 序 是 有 关 字 符 变 量 "ch" 的 运 算 操 作 代 码 如 下 : class CharOpDemo{ public static void main(string args[]){ char ch; ch='a'; System.out.println("The first ch is "+ ch); ch++; // 对 ch 进 行 递 增 操 作 System.out.println("The second ch is "+ch); ch=90; // 对 ch 重 新 赋 值 System.out.println("The third ch is "+ch); 22 程 序 运 行 结 果 如 图 2-5 所 示 程 序 中,ch 变 量 首 先 被 赋 值 'A', 接 着 ch 执 行 递 增 操 作, 在 ASCII( 和 Unicode) 中 对 应 的 值 加 1, 即 为 字 符 'B' 的 值 接 着,ch 被 赋 予 新 值 90, 该 值 对 应 于 ASCII( 和 Unicode) 的 字 符 'Z' 由 此 可 见, 尽 管 char 不 是 一 个 整 数 类 型, 但 在 某 些 情 况 下, 可 以 把 它 作 为 整 数 来 处 理 2.2.4 布 尔 类 型 图 2-5 输 出 运 算 结 果 布 尔 类 型 boolean 用 于 对 两 个 数 值 通 过 逻 辑 运 算, 判 断 结 果 是 真 或 是 假 Java 中 用 保 留 字 true 和 false 来 代 表 逻 辑 运 算 中 的 真 和 假 因 此, 一 个 boolean 类 型 的 变 量 或 表 达 式 只 能 是 取 true 和 false 这 两 个 值 中 的 一 个 在 Java 语 言 中, 布 尔 类 型 的 值 不 能 转 换 成 任 何 数 据 类 型,true 常 量 不 等 于 1, 而 false 常 量 也 不 等 于 0 这 两 个 值 只 能 赋 给 声 明 为 boolean 类 型 的 变 量, 或 者 用 于 布 尔 运 算 表 达 中 下 面 是 布 尔 类 型 变 量 的 声 明 : boolean abooleanvar; boolean a =false; // 声 明 变 量 abooleanvar 为 boolean 类 型 // 声 明 变 量 a 为 boolean 类 型, 并 赋 值 为 false 2.2.5 类 型 之 间 的 转 换 用 常 量 变 量 或 表 达 式 赋 值 给 另 一 个 变 量 时, 两 者 的 数 据 类 型 必 须 一 致 如 果 不 一 致, 则 要 进 行 数 据 的 类 型 转 换, 即 从 一 种 数 据 类 型 转 换 到 另 一 种 数 据 类 型 类 型 转 换 有 隐 式 转 换 ( 自 动 类 型 转 换 ) 和 显 式 转 换 ( 强 制 类 型 转 换 ) 两 种 1. 自 动 类 型 转 换 当 占 用 比 特 位 数 较 少 的 数 据 转 换 为 占 用 比 特 位 数 较 多 的 数 据 时, 即 从 低 级 类 型 数 据
数 据 类 型 与 运 算 符 第 2 章 转 换 成 高 级 类 型 数 据,Java 编 译 系 统 自 动 转 换, 不 需 要 程 序 另 作 说 明, 这 叫 做 自 动 类 型 转 换 例 如, 将 整 型 int 转 换 为 长 整 型 long 如 : int i=10; long j=i; 结 果 不 会 出 现 错 误 整 型 实 型 和 字 符 型 数 据 可 以 混 合 运 算 在 运 算 过 程 中, 不 同 类 型 的 数 据 会 自 动 转 换 为 同 一 类 型, 然 后 运 行 运 算 自 动 转 换 按 低 级 类 型 数 据 转 换 成 高 级 类 型 数 据 的 规 则 进 行, 转 换 规 则 为 : byte->short->int->long->float->double char->int 以 上 类 型 从 左 到 右 依 次 自 动 转 换, 最 终 转 换 为 同 一 数 据 类 型 其 中 char 类 型 可 以 直 接 转 换 为 int 类 型 参 与 运 算 2. 强 制 类 型 转 换 当 占 用 比 特 位 数 较 多 的 数 据 转 换 为 占 用 比 特 位 数 较 少 的 数 据 时, 即 高 级 数 据 类 型 要 转 换 成 低 级 数 据 类 型, 叫 做 强 制 类 型 转 换 强 制 类 型 转 换 的 格 式 为 : 23 ( 目 标 数 据 类 型 ) 变 量 名 或 表 达 式 其 中, 目 标 数 据 类 型 是 指 转 换 后 的 数 据 类 型 例 如 : int a=356; byte b; b=(byte)a; // 强 制 转 换 后 丢 失 一 部 分 数 据, 使 得 b 的 值 为 100 提 示 一 般 使 用 强 制 类 型 转 换 可 能 会 导 致 数 据 溢 出 或 精 度 下 降, 应 尽 量 避 免 2.2.6 转 义 序 列 Java 中, 字 符 常 量 是 用 单 引 号 括 起 来 的 单 个 字 符 但 在 应 用 中 可 能 要 用 到 一 些 特 殊 的 字 符, 例 如 回 车 符 换 行 符 单 引 号 双 引 号 等, 这 些 字 符 在 使 用 文 本 编 译 器 时 就 会 遇 到 问 题 此 外, 某 些 字 符 ( 如 单 引 号 双 引 号 ) 在 Java 中 也 有 特 殊 的 意 义 出 于 这 些 原 因,Java 允 许 对 特 殊 的 字 符 使 用 转 义 序 列 转 义 序 列 以 反 斜 杠 (\) 开 始, 后 面 跟 一 个 对 编 译 器 来 说 有 特 殊 意 义 的 字 符 一 些 常 用 的 特 殊 字 符 列 举 见 表 2-2 转 义 序 列 用 单 引 号 括 起 来, 以 "\" 开 始 因 此 也 可 以 看 作 是 一 种 特 殊 的 字 符 常 量 转 义 序 列 在 字 符 串 常 量 中 有 很 重 要 的 作 用
Java 程 序 设 计 实 践 教 程 表 2-2 特 殊 字 符 示 例 描 述 字 符 转 义 序 列 单 引 号 \ 双 引 号 \ 反 斜 杠 \\ 回 车 符 \r 制 表 符 \t 退 格 \b 换 行 符 \n 换 页 符 \f 八 进 制 常 量 符 号 (ddd 是 八 进 制 常 量 ) \ddd 十 六 进 制 常 量 符 号 (xxxx 是 十 六 进 制 常 量 ) \uxxxx 下 面 程 序 演 示 了 转 义 字 符 在 字 符 串 常 量 中 的 应 用 效 果 代 码 如 下 : 24 class StrDemo { public static void main(string args[]) { System.out.println("Displaying a string :"+"\'A\'"); // 输 出 字 符 串 常 量 及 'A' System.out.println("Displaying many string :"+"\"string\""); // 输 出 字 符 串 常 量 及 "string" System.out.println("Displaying a backmark :"+"\\" ); System.out.println("Text separated\t\tby two tabs"); // 输 出 插 入 在 字 符 串 常 量 中 的 两 个 制 表 符 System.out.println("There are two lines\ n\nspaced text"); // 输 出 插 入 在 字 符 串 常 量 中 的 两 个 换 行 符 System.out.println("************\r####"); //l 输 出 * 串 后 将 光 标 移 到 行 首, 然 后 输 出 # 串 // 输 出 字 符 串 常 量 及 \ 符 号 程 序 运 行 结 果 如 图 2-6 所 示 图 2-6 输 出 转 义 字 符 应 用 效 果 2.3 运 算 符 和 表 达 式 数 据 的 类 型 除 了 限 定 数 据 的 存 储 方 式 取 值 范 围 之 外, 还 定 义 了 对 该 数 据 类 型 进 行 的 操 作, 即 运 算 表 示 各 种 不 同 运 算 的 符 号 称 为 运 算 符, 参 与 运 算 的 数 据 称 为 操 作 数 表 达 式 是 由 操 作 数 ( 如 变 量, 常 量 等 ) 和 运 算 符 按 一 定 语 法 形 式 组 成 的 一 个 有 意 义 的 式 子 如 :a+b (a+b)*(a-b) "number="+(p*p) 每 个 表 达 式 经 过 运 算 后 都 会 产 生 一 个 确 定 的 值 一 个 常 量 或 一 个 变 量 是 最 简 单 的 表 达 式 用 运 算 符 连 接 几 个 表 达 式 构 成 的 式 子 仍 是 表 达 式 对 表 达 式 进 行 运 算 后, 得 到 一 个 具 有 确 切 数 值 并 且 是 唯 一 的 数 据 类 型 可 以 按 运 算 符 的 类 型 ( 或 按 表 达 式 结 果 的 数 据
数 据 类 型 与 运 算 符 第 2 章 类 型 ) 将 表 达 式 分 类 运 算 符 指 明 对 操 作 数 的 运 算 方 式 运 算 符 按 其 要 求 的 操 作 数 个 数 分 为 : 一 元 运 算 符 如 ++ -- 二 元 运 算 符 如 + - * / % 三 元 运 算 符 如?: 运 算 符 具 有 结 合 性, 大 多 数 二 元 运 算 符 的 结 合 性 均 为 自 左 向 右, 一 元 运 算 符 为 自 右 向 左 结 合 性 确 定 同 级 运 算 符 的 运 算 顺 序 左 结 合 特 性 规 定, 运 算 数 先 与 左 边 的 运 算 符 结 合, 然 后 与 右 边 的 运 算 符 结 合 如 算 术 运 算 符 具 有 左 结 合 性, 赋 值 运 算 符 具 有 右 结 合 性 运 算 符 按 其 功 能 分 为 8 类 : 算 术 运 算 符 如 ++ -- + * / % 关 系 运 算 符 如 > < >= <= ==!= 逻 辑 运 算 符 如! && ^ 位 运 算 符 条 件 运 算 符 如?: 如 >> << >>> & ^ ~ 赋 值 运 算 符 如 = += = 扩 展 运 算 符, 如 += = *= /= %= 其 他 运 算 符, 如 分 量 运 算 符 下 标 运 算 符 [] 实 例 运 算 符 instanceof 下 面 我 们 按 照 运 算 符 的 功 能 分 别 介 绍 各 种 类 型 的 运 算 符 及 各 个 运 算 符 的 优 先 级 25 2.3.1 算 术 运 算 符 算 术 运 算 符 对 数 值 型 数 据 ( 包 括 整 数 和 实 数 ) 进 行 运 算, 运 算 符 的 类 型 为 byte short long float 和 double 算 术 运 算 符 也 可 以 对 char 类 型 的 数 据 进 行 运 算, 因 为 char 实 际 上 是 int 的 一 个 子 集 但 是 算 术 运 算 符 不 能 对 boolean 类 型 进 行 算 术 运 算 算 术 表 达 式 一 般 只 含 算 术 运 算 符 和 数 值 型 数 据, 计 算 结 果 是 一 个 整 数 或 实 数 Java 定 义 的 算 术 运 算 符 如 表 2-3 所 示 表 2-3 Java 定 义 的 算 术 运 算 符 运 算 符 意 义 运 算 符 意 义 + 加 % 求 余 减 ( 一 元 减 ) ++ 自 增 * 乘 自 减 / 除 1. 基 本 算 术 运 算 符 基 本 算 术 运 算 符 加 减 乘 除 可 以 对 所 有 的 数 字 类 型 操 作 记 住 对 整 数 进 行 / 除 法 运 算 时, 所 有 的 余 数 都 要 被 舍 去 乘 除 和 取 余 运 算 优 先 级 高 于 加 和 减 下 面 是 一 个 基 本 算 术 运 算 符 的 简 单 实 例 代 码 如 下 : class BasicMath{