上 一 讲， 我 们 介 绍 了Java 产 生 的 背 景， 即 什 么 是Java、Java 的 来 龙 去 脉、Java 产 生 的 意 义 以 及 它 的 优 势， 读 者 应 该 对 它 有 一 个 模 糊 的 认 识。 本 讲， 我 们 将 主 要 介 绍Java 语 言 的 特 点，Java 的 原 始 开 发 工 具JDK， 并 用 一 个 小 例 子 简 单 介 绍 如 何 编 写 使 用Java Applet。
一、Java 语 言 特 点
上 一 讲， 我 们 提 到Java 是 一 种 跨 平 台， 适 合 于 分 布 式 计 算 环 境 的 面 向 对 象 编 程 语 言。 具 体 来 说， 它 具 有 如 下 特 性： 简 单 性、 面 向 对 象、 分 布 式、 解 释 型、 可 靠、 安 全、 平 台 无 关、 可 移 植、 高 性 能、 多 线 程、 动 态 性 等。 下 面 我 们 将 重 点 介 绍Java 语 言 的 面 向 对 象、 平 台 无 关、 分 布 式、 多 线 程、 可 靠 和 安 全 等 特 性。
1 ? 面 向 对 象
面 向 对 象 其 实 是 现 实 世 界 模 型 的 自 然 延 伸。 现 实 世 界 中 任 何 实 体 都 可 以 看 作 是 对 象。 对 象 之 间 通 过 消 息 相 互 作 用。 另 外， 现 实 世 界 中 任 何 实 体 都 可 归 属 于 某 类 事 物， 任 何 对 象 都 是 某 一 类 事 物 的 实 例。 如 果 说 传 统 的 过 程 式 编 程 语 言 是 以 过 程 为 中 心 以 算 法 为 驱 动 的 话， 面 向 对 象 的 编 程 语 言 则 是 以 对 象 为 中 心 以 消 息 为 驱 动。 用 公 式 表 示， 过 程 式 编 程 语 言 为： 程 序= 算 法+ 数 据； 面 向 对 象 编 程 语 言 为： 程 序= 对 象+ 消 息。
所 有 面 向 对 象 编 程 语 言 都 支 持 三 个 概 念： 封 装、 多 态 性 和 继 承，Java 也 不 例 外。 现 实 世 界 中 的 对 象 均 有 属 性 和 行 为， 映 射 到 计 算 机 程 序 上， 属 性 则 表 示 对 象 的 数 据， 行 为 表 示 对 象 的 方 法（ 其 作 用 是 处 理 数 据 或 同 外 界 交 互）。 所 谓 封 装， 就 是 用 一 个 自 主 式 框 架 把 对 象 的 数 据 和 方 法 联 在 一 起 形 成 一 个 整 体。 可 以 说， 对 象 是 支 持 封 装 的 手 段， 是 封 装 的 基 本 单 位。Java 语 言 的 封 装 性 较 强， 因 为Java 无 全 程 变 量， 无 主 函 数， 在Java 中 绝 大 部 分 成 员 是 对 象， 只 有 简 单 的 数 字 类 型、 字 符 类 型 和 布 尔 类 型 除 外。 而 对 于 这 些 类 型，Java 也 提 供 了 相 应 的 对 象 类 型 以 便 与 其 他 对 象 交 互 操 作。
多 态 性 就 是 多 种 表 现 形 式， 具 体 来 说， 可 以 用“ 一 个 对 外 接 口， 多 个 内 在 实 现 方 法” 表 示。 举 一 个 例 子， 计 算 机 中 的 堆 栈 可 以 存 储 各 种 格 式 的 数 据， 包 括 整 型， 浮 点 或 字 符。 不 管 存 储 的 是 何 种 数 据， 堆 栈 的 算 法 实 现 是 一 样 的。 针 对 不 同 的 数 据 类 型， 编 程 人 员 不 必 手 工 选 择， 只 需 使 用 统 一 接 口 名， 系 统 可 自 动 选 择。 运 算 符 重 载（operator overload) 一 直 被 认 为 是 一 种 优 秀 的 多 态 机 制 体 现， 但 由 于 考 虑 到 它 会 使 程 序 变 得 难 以 理 解， 所 以Java 最 后 还 是 把 它 取 消 了。
继 承 是 指 一 个 对 象 直 接 使 用 另 一 对 象 的 属 性 和 方 法。 事 实 上， 我 们 遇 到 的 很 多 实 体 都 有 继 承 的 含 义。 例 如， 若 把 汽 车 看 成 一 个 实 体， 它 可 以 分 成 多 个 子 实 体， 如： 卡 车、 公 共 汽 车 等。 这 些 子 实 体 都 具 有 汽 车 的 特 性， 因 此， 汽 车 是 它 们 的“ 父 亲”， 而 这 些 子 实 体 则 是 汽 车 的“ 孩 子”。Java 提 供 给 用 户 一 系 列 类（class），Java 的 类 有 层 次 结 构， 子 类 可 以 继 承 父 类 的 属 性 和 方 法。 与 另 外 一 些 面 向 对 象 编 程 语 言 不 同，Java 只 支 持 单 一 继 承。
2 ? 平 台 无 关 性
Java 是 平 台 无 关 的 语 言 是 指 用Java 写 的 应 用 程 序 不 用 修 改 就 可 在 不 同 的 软 硬 件 平 台 上 运 行。 平 台 无 关 有 两 种： 源 代 码 级 和 目 标 代 码 级。C 和C++ 具 有 一 定 程 度 的 源 代 码 级 平 台 无 关， 表 明 用C 或C++ 写 的 应 用 程 序 不 用 修 改 只 需 重 新 编 译 就 可 以 在 不 同 平 台 上 运 行。
Java 主 要 靠Java 虚 拟 机（JVM） 在 目 标 码 级 实 现 平 台 无 关 性。JVM 是 一 种 抽 象 机 器， 它 附 着 在 具 体 操 作 系 统 之 上， 本 身 具 有 一 套 虚 机 器 指 令， 并 有 自 己 的 栈、 寄 存 器 组 等。 但JVM 通 常 是 在 软 件 上 而 不 是 在 硬 件 上 实 现。（ 目 前，SUN 系 统 公 司 已 经 设 计 实 现 了Java 芯 片， 主 要 使 用 在 网 络 计 算 机NC 上。 另 外，Java 芯 片 的 出 现 也 会 使Java 更 容 易 嵌 入 到 家 用 电 器 中。）JVM 是Java 平 台 无 关 的 基 础， 在JVM 上， 有 一 个Java 解 释 器 用 来 解 释Java 编 译 器 编 译 后 的 程 序。Java 编 程 人 员 在 编 写 完 软 件 后， 通 过Java 编 译 器 将Java 源 程 序 编 译 为JVM 的 字 节 代 码。 任 何 一 台 机 器 只 要 配 备 了Java 解 释 器， 就 可 以 运 行 这 个 程 序， 而 不 管 这 种 字 节 码 是 在 何 种 平 台 上 生 成 的（ 过 程 如 图1 所 示）。 另 外，Java 采 用 的 是 基 于IEEE 标 准 的 数 据 类 型。 通 过JVM 保 证 数 据 类 型 的 一 致 性， 也 确 保 了Java 的 平 台 无 关 性。
Java 的 平 台 无 关 性 具 有 深 远 意 义。 首 先， 它 使 得 编 程 人 员 所 梦 寐 以 求 的 事 情（ 开 发 一 次 软 件 在 任 意 平 台 上 运 行） 变 成 事 实， 这 将 大 大 加 快 和 促 进 软 件 产 品 的 开 发。 其 次Java 的 平 台 无 关 性 正 好 迎 合 了“ 网 络 计 算 机” 思 想。 如 果 大 量 常 用 的 应 用 软 件（ 如 字 处 理 软 件 等） 都 用Java 重 新 编 写， 并 且 放 在 某 个Internet 服 务 器 上， 那 么 具 有NC 的 用 户 将 不 需 要 占 用 大 量 空 间 安 装 软 件， 他 们 只 需 要 一 个Java 解 释 器， 每 当 需 要 使 用 某 种 应 用 软 件 时， 下 载 该 软 件 的 字 节 代 码 即 可， 运 行 结 果 也 可 以 发 回 服 务 器。 目 前， 已 有 数 家 公 司 开 始 使 用 这 种 新 型 的 计 算 模 式 构 筑 自 己 的 企 业 信 息 系 统。
3 ? 分 布 式
分 布 式 包 括 数 据 分 布 和 操 作 分 布。 数 据 分 布 是 指 数 据 可 以 分 散 在 网 络 的 不 同 主 机 上， 操 作 分 布 是 指 把 一 个 计 算 分 散 在 不 同 主 机 上 处 理。
Java 支 持WWW 客 户 机/ 服 务 器 计 算 模 式， 因 此， 它 支 持 这 两 种 分 布 性。 对 于 前 者，Java 提 供 了 一 个 叫 作URL 的 对 象， 利 用 这 个 对 象， 你 可 以 打 开 并 访 问 具 有 相 同URL 地 址 上 的 对 象， 访 问 方 式 与 访 问 本 地 文 件 系 统 相 同。 对 于 后 者，Java 的applet 小 程 序 可 以 从 服 务 器 下 载 到 客 户 端， 即 部 分 计 算 在 客 户 端 进 行， 提 高 系 统 执 行 效 率。
Java 提 供 了 一 整 套 网 络 类 库， 开 发 人 员 可 以 利 用 类 库 进 行 网 络 程 序 设 计， 方 便 得 实 现Java 的 分 布 式 特 性。
4 ? 可 靠 性 和 安 全 性
Java 最 初 设 计 目 的 是 应 用 于 电 子 类 消 费 产 品， 因 此 要 求 较 高 的 可 靠 性。Java 虽 然 源 于C++， 但 它 消 除 了 许 多C++ 不 可 靠 因 素， 可 以 防 止 许 多 编 程 错 误。 首 先，Java 是 强 类 型 的 语 言， 要 求 显 式 的 方 法 声 明， 这 保 证 了 编 译 器 可 以 发 现 方 法 调 用 错 误， 保 证 程 序 更 加 可 靠； 其 次，Java 不 支 持 指 针， 这 杜 绝 了 内 存 的 非 法 访 问； 第 三，Java 的 自 动 单 元 收 集 防 止 了 内 存 丢 失 等 动 态 内 存 分 配 导 致 的 问 题； 第 四，Java 解 释 器 运 行 时 实 施 检 查， 可 以 发 现 数 组 和 字 符 串 访 问 的 越 界， 最 后，Java 提 供 了 异 常 处 理 机 制， 程 序 员 可 以 把 一 组 错 误 代 码 放 在 一 个 地 方， 这 样 可 以 简 化 错 误 处 理 任 务 便 于 恢 复。
由 于Java 主 要 用 于 网 络 应 用 程 序 开 发， 因 此 对 安 全 性 有 较 高 的 要 求。 如 果 没 有 安 全 保 证， 用 户 从 网 络 下 载 程 序 执 行 就 非 常 危 险。Java 通 过 自 己 的 安 全 机 制 防 止 了 病 毒 程 序 的 产 生 和 下 载 程 序 对 本 地 系 统 的 威 胁 破 坏。 当Java 字 节 码 进 入 解 释 器 时， 首 先 必 须 经 过 字 节 码 校 验 器 的 检 查， 然 后，Java 解 释 器 将 决 定 程 序 中 类 的 内 存 布 局， 随 后， 类 装 载 器 负 责 把 来 自 网 络 的 类 装 载 到 单 独 的 内 存 区 域， 避 免 应 用 程 序 之 间 相 互 干 扰 破 坏。 最 后， 客 户 端 用 户 还 可 以 限 制 从 网 络 上 装 载 的 类 只 能 访 问 某 些 文 件 系 统。 上 述 几 种 机 制 结 合 起 来， 使 得Java 成 为 安 全 的 编 程 语 言。
5 ? 多 线 程
线 程 是 操 作 系 统 的 一 种 新 概 念， 它 又 被 称 作 轻 量 进 程， 是 比 传 统 进 程 更 小 的 可 并 发 执 行 的 单 位。C 和C++ 采 用 单 线 程 体 系 结 构， 而Java 却 提 供 了 多 线 程 支 持。
Java 在 两 方 面 支 持 多 线 程。 一 方 面，Java 环 境 本 身 就 是 多 线 程 的。 若 干 个 系 统 线 程 运 行 负 责 必 要 的 无 用 单 元 回 收， 系 统 维 护 等 系 统 级 操 作； 另 一 方 面，Java 语 言 内 置 多 线 程 控 制， 可 以 大 大 简 化 多 线 程 应 用 程 序 开 发。Java 提 供 了 一 个 类Thread， 由 它 负 责 启 动 运 行， 终 止 线 程， 并 可 检 查 线 程 状 态。Java 的 线 程 还 包 括 一 组 同 步 原 语。 这 些 原 语 负 责 对 线 程 实 行 并 发 控 制。 利 用Java 的 多 线 程 编 程 接 口， 开 发 人 员 可 以 方 便 得 写 出 支 持 多 线 程 的 应 用 程 序， 提 高 程 序 执 行 效 率。 必 须 注 意 地 是，Java 的 多 线 程 支 持 在 一 定 程 度 上 受 运 行 时 支 持 平 台 的 限 制。 例 如， 如 果 操 作 系 统 本 身 不 支 持 多 线 程，Java 的 多 线 程 特 性 可 能 就 表 现 不 出 来。
二、 Java 小 程 序 和 应 用 程 序
用Java 可 以 写 两 种 类 型 的 程 序： 小 程 序（ 又 叫Java Applet） 和 应 用 程 序（Java Application）。 小 程 序 是 嵌 入 在HTML 文 档 中 的Java 程 序； 而Java 应 用 程 序 是 从 命 令 行 运 行 的 程 序。 对Java 而 言，Java 小 程 序 的 大 小 和 复 杂 性 都 没 有 限 制。 事 实 上，Java 小 程 序 有 些 方 面 比Java 应 用 程 序 更 强 大。 但 是 由 于 目 前Internet 通 讯 速 度 有 限， 因 此 大 多 数 小 程 序 规 模 较 小。 小 程 序 和 应 用 程 序 之 间 的 技 术 差 别 在 于 运 行 环 境。Java 应 用 程 序 运 行 在 最 简 单 的 环 境 中， 它 的 唯 一 外 部 输 入 就 是 命 令 行 参 数。 另 一 方 面，Java 小 程 序 则 需 要 来 自Web 浏 览 器 的 大 量 信 息： 它 需 要 知 道 何 时 启 动， 何 时 放 入 浏 览 器 窗 口， 何 处， 何 时 激 活 关 闭。 由 于 这 两 种 不 同 的 执 行 环 境， 小 程 序 和 应 用 程 序 的 最 低 要 求 不 同。
由 于WWW 使 小 程 序 的 发 布 十 分 便 利， 因 此 小 程 序 更 适 合 作 为Internet 上 的 应 用 程 序。 相 反， 非 网 络 系 统 和 内 存 较 小 的 系 统 更 适 合 用Java 应 用 程 序 而 较 少 用Java 小 程 序 实 现。 另 外，Java 应 用 程 序 也 很 容 易 以Internet 为 基 础 环 境， 事 实 上 有 些 优 秀 的Java 应 用 程 序 正 是 如 此。
例 如，HotJava（ 用Java 语 言 编 写 的WWW 浏 览 器）。 下 表 显 示 出 小 程 序 与 应 用 程 序 之 间 的 差 别 。
附 表 小 程 序 与 应 用 程 序 的 差 别
应 用 程 序 小 程 序
使 用 图 形 可 选 固 定 用 图 形
发 布 主 要 从 文 件 系 统 装 入 通 过HTML 链 接
内 存 要 求 最 低Java 应 用 程 序 要 求 Java 程 序 加web 浏 览 器 要 求
环 境 输 入 命 令 行 参 数 嵌 入HTML 文 档 的 参 数
VM 所 要 过 程 主 函 数 启 动 过 程 init 初 始 化 过 程
sta
rt 启 动 过 程
stop 暂 停/ 关 闭 过 程
destory 终 止 过 程
paint 绘 图 过 程
三、 Java 开 发 工 具JDK
Java 开 发 工 具（JDK） 是 许 多Java 专 家 最 初 使 用 的 开 发 环 境。 尽 管 许 多 编 程 人 员 已 经 使 用 第 三 方 的 开 发 工 具， 但JDK 仍 被 当 作Java 开 发 的 重 要 工 具。
JDK 由 一 个 标 准 类 库 和 一 组 建 立， 测 试 及 建 立 文 档 的Java 实 用 程 序 组 成。 其 核 心Java API 是 一 些 预 定 义 的 类 库， 开 发 人 员 需 要 用 这 些 类 来 访 问Java 语 言 的 功 能。Java API 包 括 一 些 重 要 的 语 言 结 构 以 及 基 本 图 形， 网 络 和 文 件I/O。 一 般 来 说，Java API 的 非I/O 部 分 对 于 运 行Java 的 所 有 平 台 是 相 同 的， 而I/O 部 分 则 仅 在 通 用Java 环 境 中 实 现。
作 为JDK 实 用 程 序， 工 具 库 中 有 七 种 主 要 程 序。
Javac： Java 编 译 器， 将Java 源 代 码 转 换 成 字 节 码。
Java： Java 解 释 器， 直 接 从 类 文 件 执 行Java 应 用 程 序 字 节 代 码。
appletviewer： 小 程 序 浏 览 器， 一 种 执 行HTML 文 件 上 的Java 小 程 序 的Java 浏 览 器。
Javadoc： 根 据Java 源 码 及 说 明 语 句 生 成HTML 文 档。
Jdb：Java 调 试 器， 可 以 逐 行 执 行 程 序， 设 置 断 点 和 检 查 变 量。
Javah： 产 生 可 以 调 用Java 过 程 的C 过 程， 或 建 立 能 被Java 程 序 调 用 的C 过 程 的 头 文 件。
Javap：Java 反 汇 编 器， 显 示 编 译 类 文 件 中 的 可 访 问 功 能 和 数 据， 同 时 显 示 字 节 代 码 含 义。
四、 用JDK 建 立 小 程 序
下 面 我 们 用 一 个 例 子 来 说 明 如 何 用JDK 建 立 小 程 序， 这 个 小 程 序 非 常 简 单 只 在 运 行 时 输出 字 串 向 你 指 定 的 人 问 候。 小 程 序 代 码 如 下：
importjava.awt.*;
importjava.applet.Applet;
public class OutputHello extends Applet{
String s;
public void init(){
String temps;
temps=getParameter("name");
s="everyone";
if (temps!=null){
s=temps;
}
}
public void paint(Graphics g){
g. drawString("Hello "+s,size().width/2,size().height/2);
}
}
这 个 小 程 序 定 义 了 一 个 类OutputHello， 它 是 从Applet 父 类 中 派 生 得 到。 它 包 括 有 一 个 数 据 成 员 和 两 个 成 员 函 数。 数 据 成 员s 存 放 外 部 输 入 的 参 数 即 姓 名。 成 员 函 数init() 和paint() 都 是 重 载 了 父 类 的 成 员 函 数， 前 者 完 成 小 程 序 初 始 化， 主 要 是 读 取 参 数 值， 后 者 主 要 是 输 出 结 果。 将 小 程 序 存 为OutputHello.java， 并 使 用Javac 编 译 这 个 程 序。
JavacOutputHello.java
如 果 程 序 被 编 译 器 接 受， 则 不 显 示 信 息， 并 生 成OutputHello.class 文 件。 如 果 有 错 误 信 息， 则 必 须 修 改 源 代 码 重 新 编 译， 直 到 通 过 为 止。 在 运 行 小 程 序 前， 我 们 还 必 须 生 成 一 个HTML 文 档 来 放 置 它。HTML 文 档 中 有 多 种 标 识， 与Java Applet 有 关 的 标 识 为：
APPLET CODE=applet 文 件 名.classWIDTH= 宽 度 HEIGHT= 高 度
PARAMNAME= 参 数 名VALUE= 值
其 中CODE，WIDTH 和HEIGHT 是 必 须 有 的 属 性。CODE 属 性 是applet 编 译 后 类 文 件 名，WIDTH 和HETGHT 分 别 为 小 程 序 运 行 时 的 长 度 和 宽 度。 ［ ］ 表 示 可 选 属 性， 标 签 表 示 小 程 序 输 入 的 参 数，NAME 为 参 数 名，VALUE 为 参 数 值。 一 个 小 程 序 可 以 有 多 个 输 入 参 数。 这 里 只 列 出 最 常 用 的 一 些 标 识， 还 有 一 些 可 选 属 性 项 未 来 列 出。 本 程 序 对 应HTML 文 档 如 下：
< html > < head >< /head >
< body >
< appletcode="outputhello.class" WIDTH="200HEIGHT=60" >
< paramname=namevalue="world" >
< /applet >
< /body >
< /html >
将 文 件 存 为OutputHello.html。
运 行 小 程 序 可 以 使 用appletviewer 或 任 何 一 种 支 持Java Applet 的 浏 览 器 如Netscape， 如 果 用appletviewer 则 输 入 如 下 语 句：
appletviewerOutputHello.html
运 行 后 在appletviewer 窗 口 输 出Hello world。
自 己 编 写applet 对 于 一 般 用 户 来 说 可 能 是 件 困 难 的 事。 因 此， 大 多 数 人 可 以 上 网 下 载 一 些 其 他 人 编 写 的 现 有 小 程 序， 嵌 入 到 自 己 的 网 页 中。 嵌 入 小 程 序 的 过 程 同 上 面 的 例 子 一 样， 即 在 主 页 中 合 适 的 位 置 加 入 标 识， 并 输 入 文 件 名、 长 和 宽。 如 果 小 程 序 有 参 数， 则 再 加 入 属 性 即 可。
本 讲 主 要 介 绍Java 语 言 的 特 性， 简 单 介 绍 了 两 种 类 型 的Java 程 序： 小 程 序 和 应 用 程 序， 开 发 工 具JDK， 并 在 最 后 用 一 个 例 子 说 明 如 何 用JDK 工 具 开 发 使 用Java Applet。
