javac: 负 责 的 是 编 译 的 部 分, 当 执 行 javac 时, 会 启 动 java 的 编 译 器 程 序 对 指 定 扩 展 名 的.java 文 件 进 行 编 译 生 成 了 jvm 可 以 识 别 的 字 节 码 文 件 也 就 是 class 文 件, 也 就 是 ja

Java 基 础 知 识 总 结 一 :java 概 述 : 1,JDK:Java Development Kit,java 的 开 发 和 运 行 环 境,java 的 开 发 工 具 和 jre 2,JRE:Java Runtime Environment,java 程 序 的 运 行 环 境,java 运 行 的 所 需 的 类 库 +JVM(java 虚 拟 机 ) 3, 配 置 环 境 变 量 : 让 java jdk\bin 目 录 下 的 工 具, 可 以 在 任 意 目 录 下 运 行, 原 因 是, 将 该 工 具 所 在 目 录 告 诉 了 系 统, 当 使 用 该 工 具 时, 由 系 统 帮 我 们 去 找 指 定 的 目 录 环 境 变 量 的 配 置 : 1): 永 久 配 置 方 式 :JAVA_HOME=% 安 装 路 径 %\Java\jdk path=%java_home%\bin 2): 临 时 配 置 方 式 :set path=%path%;c:\program Files\Java\jdk\bin 特 点 : 系 统 默 认 先 去 当 前 路 径 下 找 要 执 行 的 程 序, 如 果 没 有, 再 去 path 中 设 置 的 路 径 下 找 classpath 的 配 置 : 1): 永 久 配 置 方 式 :classpath=.;c:\;e:\ 2): 临 时 配 置 方 式 :set classpath=.;c:\;e:\ 注 意 : 在 定 义 classpath 环 境 变 量 时, 需 要 注 意 的 情 况 如 果 没 有 定 义 环 境 变 量 classpath,java 启 动 jvm 后, 会 在 当 前 目 录 下 查 找 要 运 行 的 类 文 件 ; 如 果 指 定 了 classpath, 那 么 会 在 指 定 的 目 录 下 查 找 要 运 行 的 类 文 件 还 会 在 当 前 目 录 找 吗? 两 种 情 况 : CLASSPATH 是 什 么? 它 的 作 用 是 什 么? 它 是 javac 编 译 器 的 一 个 环 境 变 量 它 的 作 用 与 import package 关 键 字 有 关 当 你 写 下 improt java.util.* 时, 编 译 器 面 对 import 关 键 字 时, 就 知 道 你 要 引 入 java.util 这 个 package 中 的 类 ; 但 是 编 译 器 如 何 知 道 你 把 这 个 package 放 在 哪 里 了 呢? 所 以 你 首 先 得 告 诉 编 译 器 这 个 package 的 所 在 位 置 ; 如 何 告 诉 它 呢? 就 是 设 置 CLASSPATH 啦 :) 如 果 java.util 这 个 package 在 c:/jdk/ 目 录 下, 你 得 把 c:/jdk/ 这 个 路 径 设 置 到 CLASSPATH 中 去! 当 编 译 器 面 对 import java.util.* 这 个 语 句 时, 它 先 会 查 找 CLASSPATH 所 指 定 的 目 录, 并 检 视 子 目 录 java/util 是 否 存 在, 然 后 找 出 名 称 吻 合 的 已 编 译 文 件 (.class 文 件 ) 如 果 没 有 找 到 就 会 报 错!CLASSPATH 有 点 像 c/c++ 编 译 器 中 的 INCLUDE 路 径 的 设 置 哦, 是 不 是? 当 c/c++ 编 译 器 遇 到 include 这 样 的 语 句, 它 是 如 何 运 作 的? 哦, 其 实 道 理 都 差 不 多! 搜 索 INCLUDE 路 径, 检 视 文 件! 当 你 自 己 开 发 一 个 package 时, 然 后 想 要 用 这 个 package 中 的 类 ; 自 然, 你 也 得 把 这 个 package 所 在 的 目 录 设 置 到 CLASSPATH 中 去!CLASSPATH 的 设 定, 对 JAVA 的 初 学 者 而 言 是 一 件 棘 手 的 事 所 以 Sun 让 JAVA2 的 JDK 更 聪 明 一 些 你 会 发 现, 在 你 安 装 之 后, 即 使 完 全 没 有 设 定 CLASSPATH, 你 仍 然 能 够 编 译 基 本 的 JAVA 程 序, 并 且 加 以 执 行 PATH 环 境 变 量 PATH 环 境 变 量 作 用 是 指 定 命 令 搜 索 路 径, 在 命 令 行 下 面 执 行 命 令 如 javac 编 译 java 程 序 时, 它 会 到 PATH 变 量 所 指 定 的 路 径 中 查 找 看 是 否 能 找 到 相 应 的 命 令 程 序 我 们 需 要 把 jdk 安 装 目 录 下 的 bin 目 录 增 加 到 现 有 的 PATH 变 量 中, bin 目 录 中 包 含 经 常 要 用 到 的 可 执 行 文 件 如 javac/java/javadoc 等 待, 设 置 好 PATH 变 量 后, 就 可 以 在 任 何 目 录 下 执 行 javac/java 等 工 具 了 4,javac 命 令 和 java 命 令 做 什 么 事 情 呢? 要 知 道 java 是 分 两 部 分 的 : 一 个 是 编 译, 一 个 是 运 行 1 / 31

javac: 负 责 的 是 编 译 的 部 分, 当 执 行 javac 时, 会 启 动 java 的 编 译 器 程 序 对 指 定 扩 展 名 的.java 文 件 进 行 编 译 生 成 了 jvm 可 以 识 别 的 字 节 码 文 件 也 就 是 class 文 件, 也 就 是 java 的 运 行 程 序 java: 负 责 运 行 的 部 分. 会 启 动 jvm. 加 载 运 行 时 所 需 的 类 库, 并 对 class 文 件 进 行 执 行. 一 个 文 件 要 被 执 行, 必 须 要 有 一 个 执 行 的 起 始 点, 这 个 起 始 点 就 是 main 函 数. 二 :java 语 法 基 础 : 1. 标 示 符 : 1), 数 字 不 可 以 开 头 2), 不 可 以 使 用 关 键 字 2. 变 量 的 作 用 域 和 生 存 期 : 变 量 的 作 用 域 : 作 用 域 从 变 量 定 义 的 位 置 开 始, 到 该 变 量 所 在 的 那 对 大 括 号 结 束 ; 生 命 周 期 : 变 量 从 定 义 的 位 置 开 始 就 在 内 存 中 活 了 ; 变 量 到 达 它 所 在 的 作 用 域 的 时 候 就 在 内 存 中 消 失 了 ; 3. 数 据 类 型 : 1): 基 本 数 据 类 型 :byte short int long float double char boolean 简 单 类 型 boolean byte char short int long float double void 二 进 制 位 数 1 8 16 16 32 64 32 64 -- 封 装 器 类 Boolean Byte Character Short Integer Long Float Double Void 4. 运 算 符 号 : 4) 逻 辑 运 算 符 & ^! && 逻 辑 运 算 符 除 了! 外 都 是 用 于 连 接 两 个 boolean 类 型 表 达 式 &: 只 有 两 边 都 为 true 结 果 是 true 否 则 就 是 false : 只 要 两 边 都 为 false 结 果 是 false, 否 则 就 是 true ^: 异 或 : 和 或 有 点 不 一 样 两 边 结 果 一 样, 就 为 false 两 边 结 果 不 一 样, 就 为 true. & 和 && 区 别 : & : 无 论 左 边 结 果 是 什 么, 右 边 都 参 与 运 算 &&: 短 路 与, 如 果 左 边 为 false, 那 么 右 边 不 参 数 与 运 算 和 区 别 : : 两 边 都 运 算 : 短 路 或, 如 果 左 边 为 true, 那 么 右 边 不 参 与 运 算 5) 位 运 算 符 : 用 于 操 作 二 进 制 位 的 运 算 符 2 / 31

& ^ << >> >>>( 无 符 号 右 移 ) 练 习 : 对 两 个 变 量 的 数 据 进 行 互 换 不 需 要 第 三 方 变 量 int a = 3,b = 5;-->b = 3,a = 5; 方 法 一 : a = a + b; a = 8; b = a - b; b = 3; a = a - b; a = 5; 方 法 二 : a = a ^ b;// b = a ^ b;//b = a ^ b ^ b = a a = a ^ b;//a = a ^ b ^ a = b; 练 习 : 高 效 的 算 出 2*8 = 2<<3; 5. 重 载 的 定 义 是 : 在 一 个 类 中, 如 果 出 现 了 两 个 或 者 两 个 以 上 的 同 名 函 数, 只 要 它 们 的 参 数 的 个 数, 或 者 参 数 的 类 型 不 同, 即 可 称 之 为 该 函 数 重 载 了 如 何 区 分 重 载 : 当 函 数 同 名 时, 只 看 参 数 列 表 和 返 回 值 类 型 没 关 系 重 写 : 父 类 与 子 类 之 间 的 多 态 性, 对 父 类 的 函 数 进 行 重 新 定 义 如 果 在 子 类 中 定 义 某 方 法 与 其 父 类 有 相 同 的 名 称 和 参 数, 我 们 说 该 方 法 被 重 写 (Overriding) 6. Java 内 存 管 理 Java 内 存 管 理 : 深 入 Java 内 存 区 域 Java 与 C++ 之 间 有 一 堵 由 内 存 动 态 分 配 和 垃 圾 收 集 技 术 所 围 成 的 高 墙, 墙 外 面 的 人 想 进 去, 墙 里 面 的 人 却 想 出 来 a) 概 述 : 对 于 从 事 C 和 C++ 程 序 开 发 的 开 发 人 员 来 说, 在 内 存 管 理 领 域, 他 们 既 是 拥 有 最 高 权 力 的 皇 帝, 又 是 从 事 最 基 础 工 作 的 劳 动 人 民 既 拥 有 每 一 个 对 象 的 所 有 权, 又 担 负 着 每 一 个 对 象 生 命 开 始 到 终 结 的 维 护 责 任 对 于 Java 程 序 员 来 说, 在 虚 拟 机 的 自 动 内 存 管 理 机 制 的 帮 助 下, 不 再 需 要 为 每 一 个 new 操 作 去 写 配 对 的 delete/free 代 码, 而 且 不 容 易 出 现 内 存 泄 漏 和 内 存 溢 出 问 题, 看 起 来 由 虚 拟 机 管 理 内 存 一 切 都 很 美 好 不 过, 也 正 是 因 为 Java 程 序 员 把 内 存 控 制 的 权 力 交 给 了 Java 虚 拟 机, 一 旦 出 现 内 存 泄 漏 和 溢 出 方 面 的 问 题, 如 果 不 了 解 虚 拟 机 是 怎 样 使 用 内 存 的, 那 排 查 错 误 将 会 成 为 一 项 异 常 艰 难 的 工 作 b) 运 行 时 数 据 区 域 Java 虚 拟 机 在 执 行 Java 程 序 的 过 程 中 会 把 它 所 管 理 的 内 存 划 分 为 若 干 个 不 同 的 数 据 区 域 这 些 区 域 都 有 各 自 的 用 途, 以 及 创 建 和 销 毁 的 时 间, 有 的 区 域 随 着 虚 拟 机 进 程 的 启 动 而 存 在, 有 些 区 域 则 是 依 赖 用 户 线 程 的 启 动 和 结 束 而 建 立 和 销 毁 根 据 Java 虚 拟 机 规 范 ( 第 2 版 ) 的 规 定,Java 虚 拟 机 所 管 理 的 内 存 将 会 包 括 以 下 几 个 运 行 时 数 据 区 域, 如 下 图 所 示 : 3 / 31

c) 程 序 计 数 器 程 序 计 数 器 (Program Counter Register) 是 一 块 较 小 的 内 存 空 间, 它 的 作 用 可 以 看 做 是 当 前 线 程 所 执 行 的 字 节 码 的 行 号 指 示 器 在 虚 拟 机 的 概 念 模 型 里 ( 仅 是 概 念 模 型, 各 种 虚 拟 机 可 能 会 通 过 一 些 更 高 效 的 方 式 去 实 现 ), 字 节 码 解 释 器 工 作 时 就 是 通 过 改 变 这 个 计 数 器 的 值 来 选 取 下 一 条 需 要 执 行 的 字 节 码 指 令, 分 支 循 环 跳 转 异 常 处 理 线 程 恢 复 等 基 础 功 能 都 需 要 依 赖 这 个 计 数 器 来 完 成 由 于 Java 虚 拟 机 的 多 线 程 是 通 过 线 程 轮 流 切 换 并 分 配 处 理 器 执 行 时 间 的 方 式 来 实 现 的, 在 任 何 一 个 确 定 的 时 刻, 一 个 处 理 器 ( 对 于 多 核 处 理 器 来 说 是 一 个 内 核 ) 只 会 执 行 一 条 线 程 中 的 指 令 因 此, 为 了 线 程 切 换 后 能 恢 复 到 正 确 的 执 行 位 置, 每 条 线 程 都 需 要 有 一 个 独 立 的 程 序 计 数 器, 各 条 线 程 之 间 的 计 数 器 互 不 影 响, 独 立 存 储, 我 们 称 这 类 内 存 区 域 为 线 程 私 有 的 内 存 如 果 线 程 正 在 执 行 的 是 一 个 Java 方 法, 这 个 计 数 器 记 录 的 是 正 在 执 行 的 虚 拟 机 字 节 码 指 令 的 地 址 ; 如 果 正 在 执 行 的 是 Natvie 方 法, 这 个 计 数 器 值 则 为 空 (Undefined) 此 内 存 区 域 是 唯 一 一 个 在 Java 虚 拟 机 规 范 中 没 有 规 定 任 何 OutOfMemoryError 情 况 的 区 域 d) Java 虚 拟 机 栈 与 程 序 计 数 器 一 样,Java 虚 拟 机 栈 (Java Virtual Machine Stacks) 也 是 线 程 私 有 的, 它 的 生 命 周 期 与 线 程 相 同 虚 拟 机 栈 描 述 的 是 Java 方 法 执 行 的 内 存 模 型 : 每 个 方 法 被 执 行 的 时 候 都 会 同 时 创 建 一 个 栈 帧 (Stack Frame) 用 于 存 储 局 部 变 量 表 操 作 栈 动 态 链 接 方 法 出 口 等 信 息 每 一 个 方 法 被 调 用 直 至 执 行 完 成 的 过 程, 就 对 应 着 一 个 栈 帧 在 虚 拟 机 栈 中 从 入 栈 到 出 栈 的 过 程 经 常 有 人 把 Java 内 存 区 分 为 堆 内 存 (Heap) 和 栈 内 存 (Stack), 这 种 分 法 比 较 粗 糙,Java 内 存 区 域 的 划 分 实 际 上 远 比 这 复 杂 这 种 划 分 方 式 的 流 行 只 能 说 明 大 多 数 程 序 员 最 关 注 的 与 对 象 内 存 分 配 关 系 最 密 切 的 内 存 区 域 是 这 两 块 其 中 所 指 的 堆 在 后 面 会 专 门 讲 述, 而 所 指 的 栈 就 是 现 在 讲 的 虚 拟 机 栈, 或 者 说 是 虚 拟 机 栈 中 的 局 部 变 量 表 部 分 局 部 变 量 表 存 放 了 编 译 期 可 知 的 各 种 基 本 数 据 类 型 (boolean byte char short int float long double) 对 象 引 用 (reference 类 型 ), 它 不 等 同 于 对 象 本 身, 根 据 不 同 的 虚 拟 机 实 现, 它 可 能 是 一 个 指 向 4 / 31

对 象 起 始 地 址 的 引 用 指 针, 也 可 能 指 向 一 个 代 表 对 象 的 句 柄 或 者 其 他 与 此 对 象 相 关 的 位 置 ) 和 returnaddress 类 型 ( 指 向 了 一 条 字 节 码 指 令 的 地 址 ) 其 中 64 位 长 度 的 long 和 double 类 型 的 数 据 会 占 用 2 个 局 部 变 量 空 间 (Slot), 其 余 的 数 据 类 型 只 占 用 1 个 局 部 变 量 表 所 需 的 内 存 空 间 在 编 译 期 间 完 成 分 配, 当 进 入 一 个 方 法 时, 这 个 方 法 需 要 在 帧 中 分 配 多 大 的 局 部 变 量 空 间 是 完 全 确 定 的, 在 方 法 运 行 期 间 不 会 改 变 局 部 变 量 表 的 大 小 在 Java 虚 拟 机 规 范 中, 对 这 个 区 域 规 定 了 两 种 异 常 状 况 : 如 果 线 程 请 求 的 栈 深 度 大 于 虚 拟 机 所 允 许 的 深 度, 将 抛 出 StackOverflowError 异 常 ; 如 果 虚 拟 机 栈 可 以 动 态 扩 展 ( 当 前 大 部 分 的 Java 虚 拟 机 都 可 动 态 扩 展, 只 不 过 Java 虚 拟 机 规 范 中 也 允 许 固 定 长 度 的 虚 拟 机 栈 ), 当 扩 展 时 无 法 申 请 到 足 够 的 内 存 时 会 抛 出 OutOfMemoryError 异 常 e) 本 地 方 法 栈 本 地 方 法 栈 (Native Method Stacks) 与 虚 拟 机 栈 所 发 挥 的 作 用 是 非 常 相 似 的, 其 区 别 不 过 是 虚 拟 机 栈 为 虚 拟 机 执 行 Java 方 法 ( 也 就 是 字 节 码 ) 服 务, 而 本 地 方 法 栈 则 是 为 虚 拟 机 使 用 到 的 Native 方 法 服 务 虚 拟 机 规 范 中 对 本 地 方 法 栈 中 的 方 法 使 用 的 语 言 使 用 方 式 与 数 据 结 构 并 没 有 强 制 规 定, 因 此 具 体 的 虚 拟 机 可 以 自 由 实 现 它 甚 至 有 的 虚 拟 机 ( 譬 如 Sun HotSpot 虚 拟 机 ) 直 接 就 把 本 地 方 法 栈 和 虚 拟 机 栈 合 二 为 一 与 虚 拟 机 栈 一 样, 本 地 方 法 栈 区 域 也 会 抛 出 StackOverflowError 和 OutOfMemoryError 异 常 f) Java 堆 对 于 大 多 数 应 用 来 说,Java 堆 (Java Heap) 是 Java 虚 拟 机 所 管 理 的 内 存 中 最 大 的 一 块 Java 堆 是 被 所 有 线 程 共 享 的 一 块 内 存 区 域, 在 虚 拟 机 启 动 时 创 建 此 内 存 区 域 的 唯 一 目 的 就 是 存 放 对 象 实 例, 几 乎 所 有 的 对 象 实 例 都 在 这 里 分 配 内 存 这 一 点 在 Java 虚 拟 机 规 范 中 的 描 述 是 : 所 有 的 对 象 实 例 以 及 数 组 都 要 在 堆 上 分 配, 但 是 随 着 JIT 编 译 器 的 发 展 与 逃 逸 分 析 技 术 的 逐 渐 成 熟, 栈 上 分 配 标 量 替 换 优 化 技 术 将 会 导 致 一 些 微 妙 的 变 化 发 生, 所 有 的 对 象 都 分 配 在 堆 上 也 渐 渐 变 得 不 是 那 么 绝 对 了 Java 堆 是 垃 圾 收 集 器 管 理 的 主 要 区 域, 因 此 很 多 时 候 也 被 称 做 GC 堆 (Garbage Collected Heap, 幸 好 国 内 没 翻 译 成 垃 圾 堆 ) 如 果 从 内 存 回 收 的 角 度 看, 由 于 现 在 收 集 器 基 本 都 是 采 用 的 分 代 收 集 算 法, 所 以 Java 堆 中 还 可 以 细 分 为 : 新 生 代 和 老 年 代 ; 再 细 致 一 点 的 有 Eden 空 间 From Survivor 空 间 To Survivor 空 间 等 如 果 从 内 存 分 配 的 角 度 看, 线 程 共 享 的 Java 堆 中 可 能 划 分 出 多 个 线 程 私 有 的 分 配 缓 冲 区 (Thread Local Allocation Buffer,TLAB) 不 过, 无 论 如 何 划 分, 都 与 存 放 内 容 无 关, 无 论 哪 个 区 域, 存 储 的 都 仍 然 是 对 象 实 例, 进 一 步 划 分 的 目 的 是 为 了 更 好 地 回 收 内 存, 或 者 更 快 地 分 配 内 存 在 本 章 中, 我 们 仅 仅 针 对 内 存 区 域 的 作 用 进 行 讨 论,Java 堆 中 的 上 述 各 个 区 域 的 分 配 和 回 收 等 细 节 将 会 是 下 一 章 的 主 题 根 据 Java 虚 拟 机 规 范 的 规 定,Java 堆 可 以 处 于 物 理 上 不 连 续 的 内 存 空 间 中, 只 要 逻 辑 上 是 连 续 的 即 可, 就 像 我 们 的 磁 盘 空 间 一 样 在 实 现 时, 既 可 以 实 现 成 固 定 大 小 的, 也 可 以 是 可 扩 展 的, 不 过 当 前 主 流 的 虚 拟 机 都 是 按 照 可 扩 展 来 实 现 的 ( 通 过 -Xmx 和 -Xms 控 制 ) 如 果 在 堆 中 没 有 内 存 完 成 实 例 分 配, 并 且 堆 也 无 法 再 扩 展 时, 将 会 抛 出 OutOfMemoryError 异 常 g) 方 法 区 方 法 区 (Method Area) 与 Java 堆 一 样, 是 各 个 线 程 共 享 的 内 存 区 域, 它 用 于 存 储 已 被 虚 拟 机 加 载 的 类 信 息 常 量 静 态 变 量 即 时 编 译 器 编 译 后 的 代 码 等 数 据 虽 然 Java 虚 拟 机 规 范 把 方 法 区 描 述 为 堆 的 一 个 逻 辑 部 分, 但 是 它 却 有 一 个 别 名 叫 做 Non-Heap( 非 堆 ), 目 的 应 该 是 与 Java 堆 区 分 开 来 5 / 31

对 于 习 惯 在 HotSpot 虚 拟 机 上 开 发 和 部 署 程 序 的 开 发 者 来 说, 很 多 人 愿 意 把 方 法 区 称 为 永 久 代 Permanent Generation), 本 质 上 两 者 并 不 等 价, 仅 仅 是 因 为 HotSpot 虚 拟 机 的 设 计 团 队 选 择 把 GC 分 代 收 集 扩 展 至 方 法 区, 或 者 说 使 用 永 久 代 来 实 现 方 法 区 而 已 对 于 其 他 虚 拟 机 ( 如 BEA JRockit IBM J9 等 ) 来 说 是 不 存 在 永 久 代 的 概 念 的 即 使 是 HotSpot 虚 拟 机 本 身, 根 据 官 方 发 布 的 路 线 图 信 息, 现 在 也 有 放 弃 永 久 代 并 搬 家 至 Native Memory 来 实 现 方 法 区 的 规 划 了 Java 虚 拟 机 规 范 对 这 个 区 域 的 限 制 非 常 宽 松, 除 了 和 Java 堆 一 样 不 需 要 连 续 的 内 存 和 可 以 选 择 固 定 大 小 或 者 可 扩 展 外, 还 可 以 选 择 不 实 现 垃 圾 收 集 相 对 而 言, 垃 圾 收 集 行 为 在 这 个 区 域 是 比 较 少 出 现 的, 但 并 非 数 据 进 入 了 方 法 区 就 如 永 久 代 的 名 字 一 样 永 久 存 在 了 这 个 区 域 的 内 存 回 收 目 标 主 要 是 针 对 常 量 池 的 回 收 和 对 类 型 的 卸 载, 一 般 来 说 这 个 区 域 的 回 收 成 绩 比 较 难 以 令 人 满 意, 尤 其 是 类 型 的 卸 载, 条 件 相 当 苛 刻, 但 是 这 部 分 区 域 的 回 收 确 实 是 有 必 要 的 在 Sun 公 司 的 BUG 列 表 中, 曾 出 现 过 的 若 干 个 严 重 的 BUG 就 是 由 于 低 版 本 的 HotSpot 虚 拟 机 对 此 区 域 未 完 全 回 收 而 导 致 内 存 泄 漏 根 据 Java 虚 拟 机 规 范 的 规 定, 当 方 法 区 无 法 满 足 内 存 分 配 需 求 时, 将 抛 出 OutOfMemoryError 异 常 h) 运 行 时 常 量 池 运 行 时 常 量 池 (Runtime Constant Pool) 是 方 法 区 的 一 部 分 Class 文 件 中 除 了 有 类 的 版 本 字 段 方 法 接 口 等 描 述 等 信 息 外, 还 有 一 项 信 息 是 常 量 池 (Constant Pool Table), 用 于 存 放 编 译 期 生 成 的 各 种 字 面 量 和 符 号 引 用, 这 部 分 内 容 将 在 类 加 载 后 存 放 到 方 法 区 的 运 行 时 常 量 池 中 Java 虚 拟 机 对 Class 文 件 的 每 一 部 分 ( 自 然 也 包 括 常 量 池 ) 的 格 式 都 有 严 格 的 规 定, 每 一 个 字 节 用 于 存 储 哪 种 数 据 都 必 须 符 合 规 范 上 的 要 求, 这 样 才 会 被 虚 拟 机 认 可 装 载 和 执 行 但 对 于 运 行 时 常 量 池,Java 虚 拟 机 规 范 没 有 做 任 何 细 节 的 要 求, 不 同 的 提 供 商 实 现 的 虚 拟 机 可 以 按 照 自 己 的 需 要 来 实 现 这 个 内 存 区 域 不 过, 一 般 来 说, 除 了 保 存 Class 文 件 中 描 述 的 符 号 引 用 外, 还 会 把 翻 译 出 来 的 直 接 引 用 也 存 储 在 运 行 时 常 量 池 中 运 行 时 常 量 池 相 对 于 Class 文 件 常 量 池 的 另 外 一 个 重 要 特 征 是 具 备 动 态 性,Java 语 言 并 不 要 求 常 量 一 定 只 能 在 编 译 期 产 生, 也 就 是 并 非 预 置 入 Class 文 件 中 常 量 池 的 内 容 才 能 进 入 方 法 区 运 行 时 常 量 池, 运 行 期 间 也 可 能 将 新 的 常 量 放 入 池 中, 这 种 特 性 被 开 发 人 员 利 用 得 比 较 多 的 便 是 String 类 的 intern() 方 法 既 然 运 行 时 常 量 池 是 方 法 区 的 一 部 分, 自 然 会 受 到 方 法 区 内 存 的 限 制, 当 常 量 池 无 法 再 申 请 到 内 存 时 会 抛 出 OutOfMemoryError 异 常 7. 对 象 访 问 介 绍 完 Java 虚 拟 机 的 运 行 时 数 据 区 之 后, 我 们 就 可 以 来 探 讨 一 个 问 题 : 在 Java 语 言 中, 对 象 访 问 是 如 何 进 行 的? 对 象 访 问 在 Java 语 言 中 无 处 不 在, 是 最 普 通 的 程 序 行 为, 但 即 使 是 最 简 单 的 访 问, 也 会 却 涉 及 Java 栈 Java 堆 方 法 区 这 三 个 最 重 要 内 存 区 域 之 间 的 关 联 关 系, 如 下 面 的 这 句 代 码 : Object obj = new Object(); 假 设 这 句 代 码 出 现 在 方 法 体 中, 那 Object obj 这 部 分 的 语 义 将 会 反 映 到 Java 栈 的 本 地 变 量 表 中, 作 为 一 个 reference 类 型 数 据 出 现 而 new Object() 这 部 分 的 语 义 将 会 反 映 到 Java 堆 中, 形 成 一 块 存 储 了 Object 类 型 所 有 实 例 数 据 值 (Instance Data, 对 象 中 各 个 实 例 字 段 的 数 据 ) 的 结 构 化 内 存, 根 据 具 体 类 型 以 及 虚 拟 机 实 现 的 对 象 内 存 布 局 (Object Memory Layout) 的 不 同, 这 块 内 存 的 长 度 是 不 固 定 的 另 外, 在 Java 堆 中 还 必 须 包 含 能 查 找 到 此 对 象 类 型 数 据 ( 如 对 象 类 型 父 类 实 现 的 接 口 方 法 等 ) 的 地 址 信 息, 这 些 类 型 数 据 则 存 储 在 方 法 区 中 6 / 31

由 于 reference 类 型 在 Java 虚 拟 机 规 范 里 面 只 规 定 了 一 个 指 向 对 象 的 引 用, 并 没 有 定 义 这 个 引 用 应 该 通 过 哪 种 方 式 去 定 位, 以 及 访 问 到 Java 堆 中 的 对 象 的 具 体 位 置, 因 此 不 同 虚 拟 机 实 现 的 对 象 访 问 方 式 会 有 所 不 同, 主 流 的 访 问 方 式 有 两 种 : 使 用 句 柄 和 直 接 指 针 如 果 使 用 句 柄 访 问 方 式,Java 堆 中 将 会 划 分 出 一 块 内 存 来 作 为 句 柄 池,reference 中 存 储 的 就 是 对 象 的 句 柄 地 址, 而 句 柄 中 包 含 了 对 象 实 例 数 据 和 类 型 数 据 各 自 的 具 体 地 址 信 息, 如 下 图 所 示 : 如 果 使 用 的 是 直 接 指 针 访 问 方 式,Java 堆 对 象 的 布 局 中 就 必 须 考 虑 如 何 放 置 访 问 类 型 数 据 的 相 关 信 息, reference 中 直 接 存 储 的 就 是 对 象 地 址, 如 下 图 所 示 : 这 两 种 对 象 的 访 问 方 式 各 有 优 势, 使 用 句 柄 访 问 方 式 的 最 大 好 处 就 是 reference 中 存 储 的 是 稳 定 的 句 柄 地 址, 在 对 象 被 移 动 ( 垃 圾 收 集 时 移 动 对 象 是 非 常 普 遍 的 行 为 ) 时 只 会 改 变 句 柄 中 的 实 例 数 据 指 针, 而 reference 7 / 31

本 身 不 需 要 被 修 改 使 用 直 接 指 针 访 问 方 式 的 最 大 好 处 就 是 速 度 更 快, 它 节 省 了 一 次 指 针 定 位 的 时 间 开 销, 由 于 对 象 的 访 问 在 Java 中 非 常 频 繁, 因 此 这 类 开 销 积 少 成 多 后 也 是 一 项 非 常 可 观 的 执 行 成 本 就 本 书 讨 论 的 主 要 虚 拟 机 Sun HotSpot 而 言, 它 是 使 用 第 二 种 方 式 进 行 对 象 访 问 的, 但 从 整 个 软 件 开 发 的 范 围 来 看, 各 种 语 言 和 框 架 使 用 句 柄 来 访 问 的 情 况 也 十 分 常 见 三 : 面 向 对 象 : 类 匿 名 对 象 使 用 场 景 : 1: 当 对 方 法 只 进 行 一 次 调 用 的 时 候, 可 以 使 用 匿 名 对 象 2: 当 对 象 对 成 员 进 行 多 次 调 用 时, 不 能 使 用 匿 名 对 象 必 须 给 对 象 起 名 字 类 中 怎 么 没 有 定 义 主 函 数 呢? 注 意 : 主 函 数 的 存 在, 仅 为 该 类 是 否 需 要 独 立 运 行, 如 果 不 需 要, 主 函 数 是 不 用 定 义 的 主 函 数 的 解 释 : 保 证 所 在 类 的 独 立 运 行, 是 程 序 的 入 口, 被 jvm 调 用 成 员 变 量 和 局 部 变 量 的 区 别 : 1: 成 员 变 量 直 接 定 义 在 类 中 局 部 变 量 定 义 在 方 法 中, 参 数 上, 语 句 中 2: 成 员 变 量 在 这 个 类 中 有 效 局 部 变 量 只 在 自 己 所 属 的 大 括 号 内 有 效, 大 括 号 结 束, 局 部 变 量 失 去 作 用 域 3: 成 员 变 量 存 在 于 堆 内 存 中, 随 着 对 象 的 产 生 而 存 在, 消 失 而 消 失 局 部 变 量 存 在 于 栈 内 存 中, 随 着 所 属 区 域 的 运 行 而 存 在, 结 束 而 释 放 构 造 函 数 : 用 于 给 对 象 进 行 初 始 化, 是 给 与 之 对 应 的 对 象 进 行 初 始 化, 它 具 有 针 对 性, 函 数 中 的 一 种 特 点 : 1: 该 函 数 的 名 称 和 所 在 类 的 名 称 相 同 2: 不 需 要 定 义 返 回 值 类 型 3: 该 函 数 没 有 具 体 的 返 回 值 记 住 : 所 有 对 象 创 建 时, 都 需 要 初 始 化 才 可 以 使 用 注 意 事 项 : 一 个 类 在 定 义 时, 如 果 没 有 定 义 过 构 造 函 数, 那 么 该 类 中 会 自 动 生 成 一 个 空 参 数 的 构 造 函 数, 为 了 方 便 该 类 创 建 对 象, 完 成 初 始 化 如 果 在 类 中 自 定 义 了 构 造 函 数, 那 么 默 认 的 构 造 函 数 就 没 有 了 一 个 类 中, 可 以 有 多 个 构 造 函 数, 因 为 它 们 的 函 数 名 称 都 相 同, 所 以 只 能 通 过 参 数 列 表 来 区 分 所 以, 一 个 类 中 如 果 出 现 多 个 构 造 函 数 它 们 的 存 在 是 以 重 载 体 现 的 构 造 代 码 块 和 构 造 函 数 有 什 么 区 别? 构 造 代 码 块 : 是 给 所 有 的 对 象 进 行 初 始 化, 也 就 是 说, 所 有 的 对 象 都 会 调 用 一 个 代 码 块 只 要 对 象 一 建 立 就 会 调 用 这 个 代 码 块 8 / 31

构 造 函 数 : 是 给 与 之 对 应 的 对 象 进 行 初 始 化 它 具 有 针 对 性 1. 执 行 顺 序 :( 优 先 级 从 高 到 低 ) 静 态 代 码 块 >mian 方 法 > 构 造 代 码 块 > 构 造 方 法 其 中 静 态 代 码 块 只 执 行 一 次 构 造 代 码 块 在 每 次 创 建 对 象 是 都 会 执 行 2. 静 态 代 码 块 的 作 用 : 比 如 我 们 在 调 用 C 语 言 的 动 态 库 时 会 可 把.so 文 件 放 在 此 处 3. 构 造 代 码 块 的 功 能 :( 可 以 把 不 同 构 造 方 法 中 相 同 的 共 性 的 东 西 写 在 它 里 面 ) 例 如 : 比 如 不 论 任 何 机 型 的 电 脑 都 有 开 机 这 个 功 能, 此 时 我 们 就 可 以 把 这 个 功 能 定 义 在 构 造 代 码 块 内 Person p = new Person(); 创 建 一 个 对 象 都 在 内 存 中 做 了 什 么 事 情? 1: 先 将 硬 盘 上 指 定 位 置 的 Person.class 文 件 加 载 进 内 存 2: 执 行 main 方 法 时, 在 栈 内 存 中 开 辟 了 main 方 法 的 空 间 ( 压 栈 - 进 栈 ), 然 后 在 main 方 法 的 栈 区 分 配 了 一 个 变 量 p 3: 在 堆 内 存 中 开 辟 一 个 实 体 空 间, 分 配 了 一 个 内 存 首 地 址 值 new 4: 在 该 实 体 空 间 中 进 行 属 性 的 空 间 分 配, 并 进 行 了 默 认 初 始 化 5: 对 空 间 中 的 属 性 进 行 显 示 初 始 化 6: 进 行 实 体 的 构 造 代 码 块 初 始 化 7: 调 用 该 实 体 对 应 的 构 造 函 数, 进 行 构 造 函 数 初 始 化 () 8: 将 首 地 址 赋 值 给 p,p 变 量 就 引 用 了 该 实 体 ( 指 向 了 该 对 象 ) 封 装 ( 面 向 对 象 特 征 之 一 ): 是 指 隐 藏 对 象 的 属 性 和 实 现 细 节, 仅 对 外 提 供 公 共 访 问 方 式 好 处 : 将 变 化 隔 离 ; 便 于 使 用 ; 提 高 重 用 性 ; 安 全 性 封 装 原 则 : 将 不 需 要 对 外 提 供 的 内 容 都 隐 藏 起 来, 把 属 性 都 隐 藏, 提 供 公 共 方 法 对 其 访 问 this: 代 表 对 象 就 是 所 在 函 数 所 属 对 象 的 引 用 this 到 底 代 表 什 么 呢? 哪 个 对 象 调 用 了 this 所 在 的 函 数,this 就 代 表 哪 个 对 象, 就 是 哪 个 对 象 的 引 用 开 发 时, 什 么 时 候 使 用 this 呢? 在 定 义 功 能 时, 如 果 该 功 能 内 部 使 用 到 了 调 用 该 功 能 的 对 象, 这 时 就 用 this 来 表 示 这 个 对 象 this 还 可 以 用 于 构 造 函 数 间 的 调 用 9 / 31

调 用 格 式 :this( 实 际 参 数 ); this 对 象 后 面 跟 上. 调 用 的 是 成 员 属 性 和 成 员 方 法 ( 一 般 方 法 ); this 对 象 后 面 跟 上 () 调 用 的 是 本 类 中 的 对 应 参 数 的 构 造 函 数 注 意 : 用 this 调 用 构 造 函 数, 必 须 定 义 在 构 造 函 数 的 第 一 行 因 为 构 造 函 数 是 用 于 初 始 化 的, 所 以 初 始 化 动 作 一 定 要 执 行 否 则 编 译 失 败 static: 关 键 字, 是 一 个 修 饰 符, 用 于 修 饰 成 员 ( 成 员 变 量 和 成 员 函 数 ) 特 点 : 1 static 变 量 按 照 是 否 静 态 的 对 类 成 员 变 量 进 行 分 类 可 分 两 种 : 一 种 是 被 static 修 饰 的 变 量, 叫 静 态 变 量 或 类 变 量 ; 另 一 种 是 没 有 被 static 修 饰 的 变 量, 叫 实 例 变 量 两 者 的 区 别 是 : 对 于 静 态 变 量 在 内 存 中 只 有 一 个 拷 贝 ( 节 省 内 存 ),JVM 只 为 静 态 分 配 一 次 内 存, 在 加 载 类 的 过 程 中 完 成 静 态 变 量 的 内 存 分 配, 可 用 类 名 直 接 访 问 ( 方 便 ), 当 然 也 可 以 通 过 对 象 来 访 问 ( 但 是 这 是 不 推 荐 的 ) 对 于 实 例 变 量, 没 创 建 一 个 实 例, 就 会 为 实 例 变 量 分 配 一 次 内 存, 实 例 变 量 可 以 在 内 存 中 有 多 个 拷 贝, 互 不 影 响 ( 灵 活 ) 2 静 态 方 法 静 态 方 法 可 以 直 接 通 过 类 名 调 用, 任 何 的 实 例 也 都 可 以 调 用, 因 此 静 态 方 法 中 不 能 用 this 和 super 关 键 字, 不 能 直 接 访 问 所 属 类 的 实 例 变 量 和 实 例 方 法 ( 就 是 不 带 static 的 成 员 变 量 和 成 员 成 员 方 法 ), 只 能 访 问 所 属 类 的 静 态 成 员 变 量 和 成 员 方 法 因 为 实 例 成 员 与 特 定 的 对 象 关 联! 这 个 需 要 去 理 解, 想 明 白 其 中 的 道 理, 不 是 记 忆!!! 因 为 static 方 法 独 立 于 任 何 实 例, 因 此 static 方 法 必 须 被 实 现, 而 不 能 是 抽 象 的 abstract 3 static 代 码 块 static 代 码 块 也 叫 静 态 代 码 块, 是 在 类 中 独 立 于 类 成 员 的 static 语 句 块, 可 以 有 多 个, 位 置 可 以 随 便 放, 它 不 在 任 何 的 方 法 体 内,JVM 加 载 类 时 会 执 行 这 些 静 态 的 代 码 块, 如 果 static 代 码 块 有 多 个,JVM 将 按 照 它 们 在 类 中 出 现 的 先 后 顺 序 依 次 执 行 它 们, 每 个 代 码 块 只 会 被 执 行 一 次 4 static 和 final 一 块 用 表 示 什 么 static final 用 来 修 饰 成 员 变 量 和 成 员 方 法, 可 简 单 理 解 为 全 局 常 量! 对 于 变 量, 表 示 一 旦 给 值 就 不 可 修 改, 并 且 通 过 类 名 可 以 访 问 对 于 方 法, 表 示 不 可 覆 盖, 并 且 可 以 通 过 类 名 直 接 访 问 备 注 : 1, 有 些 数 据 是 对 象 特 有 的 数 据, 是 不 可 以 被 静 态 修 饰 的 因 为 那 样 的 话, 特 有 数 据 会 变 成 对 象 的 共 享 数 据 这 样 对 事 物 的 描 述 就 出 了 问 题 所 以, 在 定 义 静 态 时, 必 须 要 明 确, 这 个 数 据 是 否 是 被 对 象 所 共 享 的 2, 静 态 方 法 只 能 访 问 静 态 成 员, 不 可 以 访 问 非 静 态 成 员 ( 这 句 话 是 针 对 同 一 个 类 环 境 下 的, 比 如 说, 一 个 类 有 多 个 成 员 ( 属 性, 方 法, 字 段 ), 静 态 方 法 A, 那 么 可 以 访 问 同 类 名 下 其 他 静 态 成 员, 你 如 果 访 问 非 静 态 成 员 就 不 行 ) 因 为 静 态 方 法 加 载 时, 优 先 于 对 象 存 在, 所 以 没 有 办 法 访 问 对 象 中 的 成 员 3, 静 态 方 法 中 不 能 使 用 this,super 关 键 字 因 为 this 代 表 对 象, 而 静 态 在 时, 有 可 能 没 有 对 象, 所 以 this 无 法 使 用 4, 主 函 数 是 静 态 的 成 员 变 量 和 静 态 变 量 的 区 别 : 1, 成 员 变 量 所 属 于 对 象 所 以 也 称 为 实 例 变 量 静 态 变 量 所 属 于 类 所 以 也 称 为 类 变 量 10 / 31

2, 成 员 变 量 存 在 于 堆 内 存 中 静 态 变 量 存 在 于 方 法 区 中 3, 成 员 变 量 随 着 对 象 创 建 而 存 在 随 着 对 象 被 回 收 而 消 失 静 态 变 量 随 着 类 的 加 载 而 存 在 随 着 类 的 消 失 而 消 失 4, 成 员 变 量 只 能 被 对 象 所 调 用 静 态 变 量 可 以 被 对 象 调 用, 也 可 以 被 类 名 调 用 所 以, 成 员 变 量 可 以 称 为 对 象 的 特 有 数 据, 静 态 变 量 称 为 对 象 的 共 享 数 据 静 态 代 码 块 : 就 是 一 个 有 静 态 关 键 字 标 示 的 一 个 代 码 块 区 域 定 义 在 类 中 作 用 : 可 以 完 成 类 的 初 始 化 静 态 代 码 块 随 着 类 的 加 载 而 执 行, 而 且 只 执 行 一 次 (new 多 个 对 象 就 只 执 行 一 次 ) 如 果 和 主 函 数 在 同 一 类 中, 优 先 于 主 函 数 执 行 final 根 据 程 序 上 下 文 环 境,Java 关 键 字 final 有 这 是 无 法 改 变 的 或 者 终 态 的 含 义, 它 可 以 修 饰 非 抽 象 类 非 抽 象 类 成 员 方 法 和 变 量 你 可 能 出 于 两 种 理 解 而 需 要 阻 止 改 变 设 计 或 效 率 final 类 不 能 被 继 承, 没 有 子 类,final 类 中 的 方 法 默 认 是 final 的 final 方 法 不 能 被 子 类 的 方 法 覆 盖, 但 可 以 被 继 承 final 成 员 变 量 表 示 常 量, 只 能 被 赋 值 一 次, 赋 值 后 值 不 再 改 变 final 不 能 用 于 修 饰 构 造 方 法 注 意 : 父 类 的 private 成 员 方 法 是 不 能 被 子 类 方 法 覆 盖 的, 因 此 private 类 型 的 方 法 默 认 是 final 类 型 的 1 final 类 final 类 不 能 被 继 承, 因 此 final 类 的 成 员 方 法 没 有 机 会 被 覆 盖, 默 认 都 是 final 的 在 设 计 类 时 候, 如 果 这 个 类 不 需 要 有 子 类, 类 的 实 现 细 节 不 允 许 改 变, 并 且 确 信 这 个 类 不 会 载 被 扩 展, 那 么 就 设 计 为 final 类 2 final 方 法 如 果 一 个 类 不 允 许 其 子 类 覆 盖 某 个 方 法, 则 可 以 把 这 个 方 法 声 明 为 final 方 法 使 用 final 方 法 的 原 因 有 二 : 第 一 把 方 法 锁 定, 防 止 任 何 继 承 类 修 改 它 的 意 义 和 实 现 第 二 高 效 编 译 器 在 遇 到 调 用 final 方 法 时 候 会 转 入 内 嵌 机 制, 大 大 提 高 执 行 效 率 3 final 变 量 ( 常 量 ) 用 final 修 饰 的 成 员 变 量 表 示 常 量, 值 一 旦 给 定 就 无 法 改 变! final 修 饰 的 变 量 有 三 种 : 静 态 变 量 实 例 变 量 和 局 部 变 量, 分 别 表 示 三 种 类 型 的 常 量 从 下 面 的 例 子 中 可 以 看 出, 一 旦 给 final 变 量 初 值 后, 值 就 不 能 再 改 变 了 另 外,final 变 量 定 义 的 时 候, 可 以 先 声 明, 而 不 给 初 值, 这 中 变 量 也 称 为 final 空 白, 无 论 什 么 情 况, 编 译 器 都 确 保 空 白 final 在 使 用 之 前 必 须 被 初 始 化 但 是,final 空 白 在 final 关 键 字 final 的 使 用 上 提 供 了 更 大 的 灵 活 性, 为 此, 一 个 类 中 的 final 数 据 成 员 就 可 以 实 现 依 对 象 而 有 所 不 同, 却 有 保 持 其 恒 定 不 变 的 特 征 4 final 参 数 当 函 数 参 数 为 final 类 型 时, 你 可 以 读 取 使 用 该 参 数, 但 是 无 法 改 变 该 参 数 的 值 生 成 Java 帮 助 文 档 : 命 令 格 式 :javadoc d 文 件 夹 名 auther version *.java /** // 格 式 * 类 描 述 *@author 作 者 名 *@version 版 本 号 11 / 31

*/ /** * 方 法 描 述 *@param 参 数 描 述 *@return 返 回 值 描 述 */ 继 承 ( 面 向 对 象 特 征 之 一 ) java 中 对 于 继 承,java 只 支 持 单 继 承 java 虽 然 不 直 接 支 持 多 继 承, 但 是 可 实 现 多 接 口 1: 成 员 变 量 当 子 父 类 中 出 现 一 样 的 属 性 时, 子 类 类 型 的 对 象, 调 用 该 属 性, 值 是 子 类 的 属 性 值 如 果 想 要 调 用 父 类 中 的 属 性 值, 需 要 使 用 一 个 关 键 字 :super This: 代 表 是 本 类 类 型 的 对 象 引 用 Super: 代 表 是 子 类 所 属 的 父 类 中 的 内 存 空 间 引 用 注 意 : 子 父 类 中 通 常 是 不 会 出 现 同 名 成 员 变 量 的, 因 为 父 类 中 只 要 定 义 了, 子 类 就 不 用 在 定 义 了, 直 接 继 承 过 来 用 就 可 以 了 2: 成 员 函 数 当 子 父 类 中 出 现 了 一 模 一 样 的 方 法 时, 建 立 子 类 对 象 会 运 行 子 类 中 的 方 法 好 像 父 类 中 的 方 法 被 覆 盖 掉 一 样 所 以 这 种 情 况, 是 函 数 的 另 一 个 特 性 : 重 写 3: 构 造 函 数 发 现 子 类 构 造 函 数 运 行 时, 先 运 行 了 父 类 的 构 造 函 数 为 什 么 呢? 原 因 : 子 类 的 所 有 构 造 函 数 中 的 第 一 行, 其 实 都 有 一 条 隐 身 的 语 句 super(); super(): 表 示 父 类 的 构 造 函 数, 并 会 调 用 于 参 数 相 对 应 的 父 类 中 的 构 造 函 数 而 super(): 是 在 调 用 父 类 中 空 参 数 的 构 造 函 数 为 什 么 子 类 对 象 初 始 化 时, 都 需 要 调 用 父 类 中 的 函 数?( 为 什 么 要 在 子 类 构 造 函 数 的 第 一 行 加 入 这 个 super()?) 因 为 子 类 继 承 父 类, 会 继 承 到 父 类 中 的 数 据, 所 以 必 须 要 看 父 类 是 如 何 对 自 己 的 数 据 进 行 初 始 化 的 所 以 子 类 在 进 行 对 象 初 始 化 时, 先 调 用 父 类 的 构 造 函 数, 这 就 是 子 类 的 实 例 化 过 程 注 意 : 子 类 中 所 有 的 构 造 函 数 都 会 默 认 访 问 父 类 中 的 空 参 数 的 构 造 函 数, 因 为 每 一 个 子 类 构 造 内 第 一 行 都 有 默 认 的 语 句 super(); 如 果 父 类 中 没 有 空 参 数 的 构 造 函 数, 那 么 子 类 的 构 造 函 数 内, 必 须 通 过 super 语 句 指 定 要 访 问 的 父 类 中 的 构 造 函 数 如 果 子 类 构 造 函 数 中 用 this 来 指 定 调 用 子 类 自 己 的 构 造 函 数, 那 么 被 调 用 的 构 造 函 数 也 一 样 会 访 问 父 类 中 的 构 造 函 数 问 题 : super() 和 this() 是 否 可 以 同 时 出 现 的 构 造 函 数 中? 两 个 语 句 只 能 有 一 个 定 义 在 第 一 行, 所 以 只 能 出 现 其 中 一 个 super() 或 者 this(): 为 什 么 一 定 要 定 义 在 第 一 行? 因 为 super() 或 者 this() 都 是 调 用 构 造 函 数, 构 造 函 数 用 于 初 始 化, 所 以 初 始 化 的 动 作 要 先 完 成 12 / 31

在 方 法 覆 盖 时, 注 意 两 点 : 1: 子 类 覆 盖 父 类 时, 必 须 要 保 证, 子 类 方 法 的 权 限 必 须 大 于 等 于 父 类 方 法 权 限 可 以 实 现 继 承 否 则, 编 译 失 败 ( 举 个 例 子, 在 父 类 中 是 public 的 方 法, 如 果 子 类 中 将 其 降 低 访 问 权 限 为 private, 那 么 子 类 中 重 写 以 后 的 方 法 对 于 外 部 对 象 就 不 可 访 问 了, 这 个 就 破 坏 了 继 承 的 含 义 ) 2: 覆 盖 时, 要 么 都 静 态, 要 么 都 不 静 态 ( 静 态 只 能 覆 盖 静 态, 或 者 被 静 态 覆 盖 ) 继 承 的 一 个 弊 端 : 打 破 了 封 装 性 对 于 一 些 类, 或 者 类 中 功 能, 是 需 要 被 继 承, 或 者 复 写 的 这 时 如 何 解 决 问 题 呢? 介 绍 一 个 关 键 字,final final 特 点 :( 详 细 解 释 见 前 面 ) 1: 这 个 关 键 字 是 一 个 修 饰 符, 可 以 修 饰 类, 方 法, 变 量 2: 被 final 修 饰 的 类 是 一 个 最 终 类, 不 可 以 被 继 承 3: 被 final 修 饰 的 方 法 是 一 个 最 终 方 法, 不 可 以 被 覆 盖 4: 被 final 修 饰 的 变 量 是 一 个 常 量, 只 能 赋 值 一 次 抽 象 类 : abstract 抽 象 类 的 特 点 : 1: 抽 象 方 法 只 能 定 义 在 抽 象 类 中, 抽 象 类 和 抽 象 方 法 必 须 由 abstract 关 键 字 修 饰 ( 可 以 描 述 类 和 方 法, 不 可 以 描 述 变 量 ) 2: 抽 象 方 法 只 定 义 方 法 声 明, 并 不 定 义 方 法 实 现 3: 抽 象 类 不 可 以 被 创 建 对 象 ( 实 例 化 ) 4: 只 有 通 过 子 类 继 承 抽 象 类 并 覆 盖 了 抽 象 类 中 的 所 有 抽 象 方 法 后, 该 子 类 才 可 以 实 例 化 否 则, 该 子 类 还 是 一 个 抽 象 类 抽 象 类 的 细 节 : 1: 抽 象 类 中 是 否 有 构 造 函 数? 有, 用 于 给 子 类 对 象 进 行 初 始 化 2: 抽 象 类 中 是 否 可 以 定 义 非 抽 象 方 法? 可 以 其 实, 抽 象 类 和 一 般 类 没 有 太 大 的 区 别, 都 是 在 描 述 事 物, 只 不 过 抽 象 类 在 描 述 事 物 时, 有 些 功 能 不 具 体 所 以 抽 象 类 和 一 般 类 在 定 义 上, 都 是 需 要 定 义 属 性 和 行 为 的 只 不 过, 比 一 般 类 多 了 一 个 抽 象 函 数 而 且 比 一 般 类 少 了 一 个 创 建 对 象 的 部 分 3: 抽 象 关 键 字 abstract 和 哪 些 不 可 以 共 存?final, private, static 4: 抽 象 类 中 可 不 可 以 不 定 义 抽 象 方 法? 可 以 抽 象 方 法 目 的 仅 仅 为 了 不 让 该 类 创 建 对 象 接 口 : 1: 是 用 关 键 字 interface 定 义 的 2: 接 口 中 包 含 的 成 员, 最 常 见 的 有 全 局 常 量 抽 象 方 法 注 意 : 接 口 中 的 成 员 都 有 固 定 的 修 饰 符 成 员 变 量 :public static final 成 员 方 法 :public abstract interface Inter{ public static final int x = 3; public abstract void show(); 13 / 31

3: 接 口 中 有 抽 象 方 法, 说 明 接 口 不 可 以 实 例 化 接 口 的 子 类 必 须 实 现 了 接 口 中 所 有 的 抽 象 方 法 后, 该 子 类 才 可 以 实 例 化 否 则, 该 子 类 还 是 一 个 抽 象 类 4: 类 与 类 之 间 存 在 着 继 承 关 系, 类 与 接 口 中 间 存 在 的 是 实 现 关 系 继 承 用 extends ; 实 现 用 implements ; 5: 接 口 和 类 不 一 样 的 地 方, 就 是, 接 口 可 以 被 多 实 现, 这 就 是 多 继 承 改 良 后 的 结 果 java 将 多 继 承 机 制 通 过 多 现 实 来 体 现 6: 一 个 类 在 继 承 另 一 个 类 的 同 时, 还 可 以 实 现 多 个 接 口 所 以 接 口 的 出 现 避 免 了 单 继 承 的 局 限 性 还 可 以 将 类 进 行 功 能 的 扩 展 7: 其 实 java 中 是 有 多 继 承 的 接 口 与 接 口 之 间 存 在 着 继 承 关 系, 接 口 可 以 多 继 承 接 口 java 类 是 单 继 承 的 classb Extends classa java 接 口 可 以 多 继 承 Interface3 Extends Interface0, Interface1, interface 不 允 许 类 多 重 继 承 的 主 要 原 因 是, 如 果 A 同 时 继 承 B 和 C, 而 b 和 c 同 时 有 一 个 D 方 法,A 如 何 决 定 该 继 承 那 一 个 呢? 但 接 口 不 存 在 这 样 的 问 题, 接 口 全 都 是 抽 象 方 法 继 承 谁 都 无 所 谓, 所 以 接 口 可 以 继 承 多 个 接 口 抽 象 类 与 接 口 : 抽 象 类 : 一 般 用 于 描 述 一 个 体 系 单 元, 将 一 组 共 性 内 容 进 行 抽 取, 特 点 : 可 以 在 类 中 定 义 抽 象 内 容 让 子 类 实 现, 可 以 定 义 非 抽 象 内 容 让 子 类 直 接 使 用 它 里 面 定 义 的 都 是 一 些 体 系 中 的 基 本 内 容 接 口 : 一 般 用 于 定 义 对 象 的 扩 展 功 能, 是 在 继 承 之 外 还 需 这 个 对 象 具 备 的 一 些 功 能 抽 象 类 和 接 口 的 共 性 : 都 是 不 断 向 上 抽 取 的 结 果 抽 象 类 和 接 口 的 区 别 : 1: 抽 象 类 只 能 被 继 承, 而 且 只 能 单 继 承 接 口 需 要 被 实 现, 而 且 可 以 多 实 现 2: 抽 象 类 中 可 以 定 义 非 抽 象 方 法, 子 类 可 以 直 接 继 承 使 用 接 口 中 都 是 抽 象 方 法, 需 要 子 类 去 实 现 3: 抽 象 类 使 用 的 是 is a 关 系 接 口 使 用 的 like a 关 系 4: 抽 象 类 的 成 员 修 饰 符 可 以 自 定 义 接 口 中 的 成 员 修 饰 符 是 固 定 的 全 都 是 public 的 多 态 多 态 ( 面 向 对 象 特 征 之 一 ): 函 数 本 身 就 具 备 多 态 性, 某 一 种 事 物 有 不 同 的 具 体 的 体 现 体 现 : 父 类 引 用 或 者 接 口 的 引 用 指 向 了 自 己 的 子 类 对 象 //Animal a = new Cat(); 父 类 可 以 调 用 子 类 中 覆 写 过 的 ( 父 类 中 有 的 方 法 ) 多 态 的 好 处 : 提 高 了 程 序 的 扩 展 性 继 承 的 父 类 或 接 口 一 般 是 类 库 中 的 东 西,( 如 果 要 修 改 某 个 方 法 的 具 体 实 现 方 式 ) 只 有 通 过 子 类 去 覆 写 要 改 变 的 某 一 个 方 法, 这 样 在 通 过 将 父 类 的 应 用 指 向 子 类 的 实 例 去 调 用 覆 写 过 的 方 法 就 行 了! 多 态 的 弊 端 : 当 父 类 引 用 指 向 子 类 对 象 时, 虽 然 提 高 了 扩 展 性, 但 是 只 能 访 问 父 类 中 具 备 的 方 法, 不 可 以 访 问 子 类 中 特 有 的 方 法 ( 前 期 不 能 使 用 后 期 产 生 的 功 能, 即 访 问 的 局 限 性 ) 14 / 31

多 态 的 前 提 : 1: 必 须 要 有 关 系, 比 如 继 承 或 者 实 现 2: 通 常 会 有 覆 盖 操 作 如 果 想 用 子 类 对 象 的 特 有 方 法, 如 何 判 断 对 象 是 哪 个 具 体 的 子 类 类 型 呢? 可 以 可 以 通 过 一 个 关 键 字 instanceof ;// 判 断 对 象 是 否 实 现 了 指 定 的 接 口 或 继 承 了 指 定 的 类 格 式 :< 对 象 instanceof 类 型 >, 判 断 一 个 对 象 是 否 所 属 于 指 定 的 类 型 Student instanceof Person = true;//student 继 承 了 person 类 ------------------------------------------------------------------------------------- java.lang.object Object: 所 有 类 的 直 接 或 者 间 接 父 类,Java 认 为 所 有 的 对 象 都 具 备 一 些 基 本 的 共 性 内 容, 这 些 内 容 可 以 不 断 的 向 上 抽 取, 最 终 就 抽 取 到 了 一 个 最 顶 层 的 类 中 的, 该 类 中 定 义 的 就 是 所 有 对 象 都 具 备 的 功 能 具 体 方 法 : 1, boolean equals(object obj): 用 于 比 较 两 个 对 象 是 否 相 等, 其 实 内 部 比 较 的 就 是 两 个 对 象 地 址 2, String tostring() : 将 对 象 变 成 字 符 串 ; 默 认 返 回 的 格 式 : 类 名 @ 哈 希 值 = getclass().getname() + '@' + Integer.toHexString(hashCode()) 为 了 对 象 对 应 的 字 符 串 内 容 有 意 义, 可 以 通 过 复 写, 建 立 该 类 对 象 自 己 特 有 的 字 符 串 表 现 形 式 public String tostring(){ return "person : "+age; 3,Class getclass(): 获 取 任 意 对 象 运 行 时 的 所 属 字 节 码 文 件 对 象 4,int hashcode(): 返 回 该 对 象 的 哈 希 码 值 支 持 此 方 法 是 为 了 提 高 哈 希 表 的 性 能 将 该 对 象 的 内 部 地 址 转 换 成 一 个 整 数 来 实 现 的 通 常 equals,tostring,hashcode, 在 应 用 中 都 会 被 复 写, 建 立 具 体 对 象 的 特 有 的 内 容 ------------------------------------------------------------------------------------- 内 部 类 : 如 果 A 类 需 要 直 接 访 问 B 类 中 的 成 员, 而 B 类 又 需 要 建 立 A 类 的 对 象 这 时, 为 了 方 便 设 计 和 访 问, 直 接 将 A 类 定 义 在 B 类 中 就 可 以 了 A 类 就 称 为 内 部 类 内 部 类 可 以 直 接 访 问 外 部 类 中 的 成 员 而 外 部 类 想 要 访 问 内 部 类, 必 须 要 建 立 内 部 类 的 对 象 ----------------------------------------------------- class Outer{ int num = 4; class Inner { void show(){ System.out.println("inner show run "+num); public void method(){ Inner in = new Inner();// 创 建 内 部 类 的 对 象 in.show();// 调 用 内 部 类 的 方 法 // 内 部 类 直 接 访 问 外 部 类 成 员, 用 自 己 的 实 例 对 象 ; // 外 部 类 访 问 内 部 类 要 定 义 内 部 类 的 对 象 ; 15 / 31

------------------------------------------------------- 当 内 部 类 定 义 在 外 部 类 中 的 成 员 位 置 上, 可 以 使 用 一 些 成 员 修 饰 符 修 饰 private static 1: 默 认 修 饰 符 直 接 访 问 内 部 类 格 式 : 外 部 类 名. 内 部 类 名 变 量 名 = 外 部 类 对 象. 内 部 类 对 象 ; Outer.Inner in = new Outer.new Inner();// 这 种 形 式 很 少 用 但 是 这 种 应 用 不 多 见, 因 为 内 部 类 之 所 以 定 义 在 内 部 就 是 为 了 封 装 想 要 获 取 内 部 类 对 象 通 常 都 通 过 外 部 类 的 方 法 来 获 取 这 样 可 以 对 内 部 类 对 象 进 行 控 制 2: 私 有 修 饰 符 通 常 内 部 类 被 封 装, 都 会 被 私 有 化, 因 为 封 装 性 不 让 其 他 程 序 直 接 访 问 3: 静 态 修 饰 符 如 果 内 部 类 被 静 态 修 饰, 相 当 于 外 部 类, 会 出 现 访 问 局 限 性, 只 能 访 问 外 部 类 中 的 静 态 成 员 注 意 ; 如 果 内 部 类 中 定 义 了 静 态 成 员, 那 么 该 内 部 类 必 须 是 静 态 的 内 部 类 编 译 后 的 文 件 名 为 : 外 部 类 名 $ 内 部 类 名.java ; 为 什 么 内 部 类 可 以 直 接 访 问 外 部 类 中 的 成 员 呢? 那 是 因 为 内 部 中 都 持 有 一 个 外 部 类 的 引 用 这 个 是 引 用 是 外 部 类 名.this 内 部 类 可 以 定 义 在 外 部 类 中 的 成 员 位 置 上, 也 可 以 定 义 在 外 部 类 中 的 局 部 位 置 上 当 内 部 类 被 定 义 在 局 部 位 置 上, 只 能 访 问 局 部 中 被 final 修 饰 的 局 部 变 量 匿 名 内 部 类 ( 对 象 ): 没 有 名 字 的 内 部 类 就 是 内 部 类 的 简 化 形 式 一 般 只 用 一 次 就 可 以 用 这 种 形 式 匿 名 内 部 类 其 实 就 是 一 个 匿 名 子 类 对 象 想 要 定 义 匿 名 内 部 类 : 需 要 前 提, 内 部 类 必 须 继 承 一 个 类 或 者 实 现 接 口 匿 名 内 部 类 的 格 式 :new 父 类 名 & 接 口 名 (){ 定 义 子 类 成 员 或 者 覆 盖 父 类 方 法. 方 法 匿 名 内 部 类 的 使 用 场 景 : 当 函 数 的 参 数 是 接 口 类 型 引 用 时, 如 果 接 口 中 的 方 法 不 超 过 3 个 可 以 通 过 匿 名 内 部 类 来 完 成 参 数 的 传 递 其 实 就 是 在 创 建 匿 名 内 部 类 时, 该 类 中 的 封 装 的 方 法 不 要 过 多, 最 好 两 个 或 者 两 个 以 内 -------------------------------------------------------- // 面 试 //1 new Object(){ void show(){ System.out.println("show run");.show(); // 写 法 和 编 译 都 没 问 题 //2 Object obj = new Object(){ void show(){ System.out.println("show run"); ; obj.show(); // 写 法 正 确, 编 译 会 报 错 16 / 31

1 和 2 的 写 法 正 确 吗? 有 区 别 吗? 说 出 原 因 写 法 是 正 确,1 和 2 都 是 在 通 过 匿 名 内 部 类 建 立 一 个 Object 类 的 子 类 对 象 区 别 : 第 一 个 可 是 编 译 通 过, 并 运 行 第 二 个 编 译 失 败, 因 为 匿 名 内 部 类 是 一 个 子 类 对 象, 当 用 Object 的 obj 引 用 指 向 时, 就 被 提 升 为 了 Object 类 型, 而 编 译 时 会 检 查 Object 类 中 是 否 有 show 方 法, 此 时 编 译 失 败 异 常 : --java.lang.throwable: Throwable: 可 抛 出 的 --Error: 错 误, 一 般 情 况 下, 不 编 写 针 对 性 的 代 码 进 行 处 理, 通 常 是 jvm 发 生 的, 需 要 对 程 序 进 行 修 正 --Exception: 异 常, 可 以 有 针 对 性 的 处 理 方 式 这 个 体 系 中 的 所 有 类 和 对 象 都 具 备 一 个 独 有 的 特 点 ; 就 是 可 抛 性 可 抛 性 的 体 现 : 就 是 这 个 体 系 中 的 类 和 对 象 都 可 以 被 throws 和 throw 两 个 关 键 字 所 操 作 throw 与 throws 区 别 : throws 是 用 来 声 明 一 个 方 法 可 能 抛 出 的 所 有 异 常 信 息, 而 throw 则 是 指 抛 出 的 一 个 具 体 的 异 常 类 型 此 外 throws 是 将 异 常 声 明 但 是 不 处 理, 而 是 将 异 常 往 上 传, 谁 调 用 我 就 交 给 谁 处 理 throw 用 于 抛 出 异 常 对 象, 后 面 跟 的 是 异 常 对 象 ;throw 用 在 函 数 内 throws 用 于 抛 出 异 常 类, 后 面 跟 的 异 常 类 名, 可 以 跟 多 个, 用 逗 号 隔 开 throws 用 在 函 数 上 throws 格 式 : 方 法 名 ( 参 数 )throws 异 常 类 1, 异 常 类 2,... throw: 就 是 自 己 进 行 异 常 处 理, 处 理 的 时 候 有 两 种 方 式, 要 么 自 己 捕 获 异 常 ( 也 就 是 try catch 进 行 捕 捉 ), 要 么 声 明 抛 出 一 个 异 常 ( 就 是 throws 异 常 ~~) 处 理 方 式 有 两 种 :1 捕 捉 ;2 抛 出 对 于 捕 捉 :java 有 针 对 性 的 语 句 块 进 行 处 理 try { 需 要 被 检 测 的 代 码 ; catch( 异 常 类 变 量 名 ){ 异 常 处 理 代 码 ; fianlly{ 一 定 会 执 行 的 代 码 ; 定 义 异 常 处 理 时, 什 么 时 候 定 义 try, 什 么 时 候 定 义 throws 呢? 功 能 内 部 如 果 出 现 异 常, 如 果 内 部 可 以 处 理, 就 用 try; 如 果 功 能 内 部 处 理 不 了, 就 必 须 声 明 出 来, 让 调 用 者 处 理 使 用 throws 抛 出, 交 给 调 用 者 处 理 谁 调 用 了 这 个 功 能 谁 就 是 调 用 者 ; 17 / 31

自 定 义 异 常 的 步 骤 : 1: 定 义 一 个 子 类 继 承 Exception 或 RuntimeException, 让 该 类 具 备 可 抛 性 ( 既 可 以 使 用 throw 和 throws 去 调 用 此 类 ) 2: 通 过 throw 或 者 throws 进 行 操 作 异 常 的 转 换 思 想 : 当 出 现 的 异 常 是 调 用 者 处 理 不 了 的, 就 需 要 将 此 异 常 转 换 为 一 个 调 用 者 可 以 处 理 的 异 常 抛 出 try catch finally 的 几 种 结 合 方 式 : 1, try catch finally 2, try catch 3, try finally 这 种 情 况, 如 果 出 现 异 常, 并 不 处 理, 但 是 资 源 一 定 关 闭, 所 以 try finally 集 合 只 为 关 闭 资 源 记 住 :finally 很 有 用, 主 要 用 户 关 闭 资 源 无 论 是 否 发 生 异 常, 资 源 都 必 须 进 行 关 闭 System.exit(0); // 退 出 jvm, 只 有 这 种 情 况 finally 不 执 行 注 意 : 如 果 父 类 或 者 接 口 中 的 方 法 没 有 抛 出 过 异 常, 那 么 子 类 是 不 可 以 抛 出 异 常 的, 如 果 子 类 的 覆 盖 的 方 法 中 出 现 了 异 常, 只 能 try 不 能 throws 如 果 这 个 异 常 子 类 无 法 处 理, 已 经 影 响 了 子 类 方 法 的 具 体 运 算, 这 时 可 以 在 子 类 方 法 中, 通 过 throw 抛 出 RuntimeException 异 常 或 者 其 子 类, 这 样, 子 类 的 方 法 上 是 不 需 要 throws 声 明 的 多 线 程 : 返 回 当 前 线 程 的 名 称 :Thread.currentThread().getName() 线 程 的 名 称 是 由 :Thread- 编 号 定 义 的 编 号 从 0 开 始 线 程 要 运 行 的 代 码 都 统 一 存 放 在 了 run 方 法 中 线 程 要 运 行 必 须 要 通 过 类 中 指 定 的 方 法 开 启 start 方 法 ( 启 动 后, 就 多 了 一 条 执 行 路 径 ) start 方 法 :1) 启 动 了 线 程 ;2) 让 jvm 调 用 了 run 方 法 Thread 类 中 run() 和 start() 方 法 的 区 别 : start(): 用 start 方 法 来 启 动 线 程, 真 正 实 现 了 多 线 程 运 行, 这 时 无 需 等 待 run 方 法 体 代 码 执 行 完 毕 而 直 接 继 续 执 行 下 面 的 代 码 通 过 调 用 Thread 类 的 start() 方 法 来 启 动 一 个 线 程, 这 时 此 线 程 处 于 就 绪 ( 可 运 行 ) 状 态, 并 没 有 运 行, 一 旦 得 到 cpu 时 间 片, 就 开 始 执 行 run() 方 法, 这 里 方 法 run() 称 为 线 程 体, 它 包 含 了 要 执 行 的 这 个 线 程 的 内 容,Run 方 法 运 行 结 束, 此 线 程 随 即 终 止 run():run() 方 法 只 是 类 的 一 个 普 通 方 法 而 已, 如 果 直 接 调 用 Run 方 法, 程 序 中 依 然 只 有 主 线 程 这 一 个 线 程, 其 程 序 执 行 路 径 还 是 只 有 一 条, 还 是 要 顺 序 执 行, 还 是 要 等 待 run 方 法 体 执 行 完 毕 后 才 可 继 续 执 行 下 面 的 代 码, 这 样 就 没 有 达 到 写 线 程 的 目 的 总 结 :start() 方 法 最 本 质 的 功 能 是 从 CPU 中 申 请 另 一 个 线 程 空 间 来 执 行 run() 方 法 中 的 代 码, 18 / 31

它 和 当 前 的 线 程 是 两 条 线, 在 相 对 独 立 的 线 程 空 间 运 行, 也 就 是 说, 如 果 你 直 接 调 用 线 程 对 象 的 run() 方 法, 当 然 也 会 执 行, 但 那 是 在 当 前 线 程 中 执 行,run() 方 法 执 行 完 成 后 继 续 执 行 下 面 的 代 码. 而 调 用 start() 方 法 后,run() 方 法 的 代 码 会 和 当 前 线 程 并 发 ( 单 CPU) 或 并 行 ( 多 CPU) 执 行 所 以 请 记 住 一 句 话 : 调 用 线 程 对 象 的 run 方 法 不 会 产 生 一 个 新 的 线 程, 虽 然 可 以 达 到 相 同 的 执 行 结 果, 但 执 行 过 程 和 执 行 效 率 不 同 创 建 线 程 的 第 一 种 方 式 : 继 承 Thread, 由 子 类 复 写 run 方 法 步 骤 : 1, 定 义 类 继 承 Thread 类 ; 2, 目 的 是 复 写 run 方 法, 将 要 让 线 程 运 行 的 代 码 都 存 储 到 run 方 法 中 ; 3, 通 过 创 建 Thread 类 的 子 类 对 象, 创 建 线 程 对 象 ; 4, 调 用 线 程 的 start 方 法, 开 启 线 程, 并 执 行 run 方 法 线 程 状 态 : 被 创 建 :start() 运 行 : 具 备 执 行 资 格, 同 时 具 备 执 行 权 ; 冻 结 :sleep(time),wait() notify() 唤 醒 ; 线 程 释 放 了 执 行 权, 同 时 释 放 执 行 资 格 ; 临 时 阻 塞 状 态 : 线 程 具 备 cpu 的 执 行 资 格, 没 有 cpu 的 执 行 权 ; 消 亡 :stop() 创 建 线 程 的 第 二 种 方 式 : 实 现 一 个 接 口 Runnable 步 骤 : 1, 定 义 类 实 现 Runnable 接 口 2, 覆 盖 接 口 中 的 run 方 法 ( 用 于 封 装 线 程 要 运 行 的 代 码 ) 3, 通 过 Thread 类 创 建 线 程 对 象 ; 4, 将 实 现 了 Runnable 接 口 的 子 类 对 象 作 为 实 际 参 数 传 递 给 Thread 类 中 的 构 造 函 数 为 什 么 要 传 递 呢? 因 为 要 让 线 程 对 象 明 确 要 运 行 的 run 方 法 所 属 的 对 象 5, 调 用 Thread 对 象 的 start 方 法 开 启 线 程, 并 运 行 Runnable 接 口 子 类 中 的 run 方 法 Ticket t = new Ticket(); /* 直 接 创 建 Ticket 对 象, 并 不 是 创 建 线 程 对 象 因 为 创 建 对 象 只 能 通 过 new Thread 类, 或 者 new Thread 类 的 子 类 才 可 以 所 以 最 终 想 要 创 建 线 程 既 然 没 有 了 Thread 类 的 子 类, 就 只 能 用 Thread 类 19 / 31

法 */ Thread t1 = new Thread(t); // 创 建 线 程 /* 只 要 将 t 作 为 Thread 类 的 构 造 函 数 的 实 际 参 数 传 入 即 可 完 成 线 程 对 象 和 t 之 间 的 关 联 为 什 么 要 将 t 传 给 Thread 类 的 构 造 函 数 呢? 其 实 就 是 为 了 明 确 线 程 要 运 行 的 代 码 run 方 */ t1.start(); 为 什 么 要 有 Runnable 接 口 的 出 现? 1: 通 过 继 承 Thread 类 的 方 式, 可 以 完 成 多 线 程 的 建 立 但 是 这 种 方 式 有 一 个 局 限 性, 如 果 一 个 类 已 经 有 了 自 己 的 父 类, 就 不 可 以 继 承 Thread 类, 因 为 java 单 继 承 的 局 限 性 可 是 该 类 中 的 还 有 部 分 代 码 需 要 被 多 个 线 程 同 时 执 行 这 时 怎 么 办 呢? 只 有 对 该 类 进 行 额 外 的 功 能 扩 展,java 就 提 供 了 一 个 接 口 Runnable 这 个 接 口 中 定 义 了 run 方 法, 其 实 run 方 法 的 定 义 就 是 为 了 存 储 多 线 程 要 运 行 的 代 码 所 以, 通 常 创 建 线 程 都 用 第 二 种 方 式 因 为 实 现 Runnable 接 口 可 以 避 免 单 继 承 的 局 限 性 2: 其 实 是 将 不 同 类 中 需 要 被 多 线 程 执 行 的 代 码 进 行 抽 取 将 多 线 程 要 运 行 的 代 码 的 位 置 单 独 定 义 到 接 口 中 为 其 他 类 进 行 功 能 扩 展 提 供 了 前 提 所 以 Thread 类 在 描 述 线 程 时, 内 部 定 义 的 run 方 法, 也 来 自 于 Runnable 接 口 实 现 Runnable 接 口 可 以 避 免 单 继 承 的 局 限 性 而 且, 继 承 Thread, 是 可 以 对 Thread 类 中 的 方 法, 进 行 子 类 复 写 的 但 是 不 需 要 做 这 个 复 写 动 作 的 话, 只 为 定 义 线 程 代 码 存 放 位 置, 实 现 Runnable 接 口 更 方 便 一 些 所 以 Runnable 接 口 将 线 程 要 执 行 的 任 务 封 装 成 了 对 象 ------------------------------------------------------- // 面 试 new Thread(new Runnable(){ // 匿 名 public void run(){ System.out.println("runnable run"); ) { public void run(){ System.out.println("subthread run");.start(); // 结 果 :subthread run --------------------------------------------------------- synchronized 关 键 字 ( 一 ) 一 当 两 个 并 发 线 程 访 问 同 一 个 对 象 object 中 的 这 个 synchronized(this) 同 步 代 码 块 时, 一 个 时 间 内 只 能 有 一 个 线 程 得 到 执 行 另 一 个 线 程 必 须 等 待 当 前 线 程 执 行 完 这 个 代 码 块 以 后 才 能 执 行 该 代 码 块 二 然 而, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 另 一 个 线 程 仍 然 可 以 访 问 该 object 中 的 非 synchronized(this) 同 步 代 码 块 三 尤 其 关 键 的 是, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 其 他 线 程 对 object 中 所 有 其 它 synchronized(this) 同 步 代 码 块 的 访 问 将 被 阻 塞 20 / 31

四 第 三 个 例 子 同 样 适 用 其 它 同 步 代 码 块 也 就 是 说, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 它 就 获 得 了 这 个 object 的 对 象 锁 结 果, 其 它 线 程 对 该 object 对 象 所 有 同 步 代 码 部 分 的 访 问 都 被 暂 时 阻 塞 五 以 上 规 则 对 其 它 对 象 锁 同 样 适 用. package ths; public class Thread1 implements Runnable { public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName()+"synchronized loop " + i); synchronized 关 键 字 ( 二 ) synchronized 关 键 字, 它 包 括 两 种 用 法 :synchronized 方 法 和 synchronized 块 1. synchronized 方 法 : 通 过 在 方 法 声 明 中 加 入 synchronized 关 键 字 来 声 明 synchronized 方 法 如 : public synchronized void accessval(int newval); synchronized 方 法 控 制 对 类 成 员 变 量 的 访 问 : 每 个 类 实 例 对 应 一 把 锁, 每 个 synchronized 方 法 都 必 须 获 得 调 用 该 方 法 的 类 实 例 的 锁 方 能 执 行, 否 则 所 属 线 程 阻 塞, 方 法 一 旦 执 行, 就 独 占 该 锁, 直 到 从 该 方 法 返 回 时 才 将 锁 释 放, 此 后 被 阻 塞 的 线 程 方 能 获 得 该 锁, 重 新 进 入 可 执 行 状 态 这 种 机 制 确 保 了 同 一 时 刻 对 于 每 一 个 类 实 例, 其 所 有 声 明 为 synchronized 的 成 员 函 数 中 至 多 只 有 一 个 处 于 可 执 行 状 态 ( 因 为 至 多 只 有 一 个 能 够 获 得 该 类 实 例 对 应 的 锁 ), 从 而 有 效 避 免 了 类 成 员 变 量 的 访 问 冲 突 ( 只 要 所 有 可 能 访 问 类 成 员 变 量 的 方 法 均 被 声 明 为 synchronized) 在 Java 中, 不 光 是 类 实 例, 每 一 个 类 也 对 应 一 把 锁, 这 样 我 们 也 可 将 类 的 静 态 成 员 函 数 声 明 为 synchronized, 以 控 制 其 对 类 的 静 态 成 员 变 量 的 访 问 synchronized 方 法 的 缺 陷 : 若 将 一 个 大 的 方 法 声 明 为 synchronized 将 会 大 大 影 响 效 率, 典 型 地, 若 将 线 程 类 的 方 法 run() 声 明 为 synchronized, 由 于 在 线 程 的 整 个 生 命 期 内 它 一 直 在 运 行, 因 此 将 导 致 它 对 本 类 任 何 synchronized 方 法 的 调 用 都 永 远 不 会 成 功 当 然 我 们 可 以 通 过 将 访 问 类 成 员 变 量 的 代 码 放 到 专 门 的 方 法 中, 将 其 声 明 为 synchronized, 并 在 主 方 法 中 调 用 来 解 决 这 一 问 题, 但 是 Java 为 我 们 提 供 了 更 好 的 解 决 办 法, 那 就 是 synchronized 块 2. synchronized 块 : 通 过 synchronized 关 键 字 来 声 明 synchronized 块 语 法 如 下 : synchronized(syncobject) { // 允 许 访 问 控 制 的 代 码 synchronized 块 是 这 样 一 个 代 码 块, 其 中 的 代 码 必 须 获 得 对 象 syncobject ( 如 前 所 述, 可 以 是 类 实 例 或 类 ) 的 锁 方 能 执 行, 具 体 机 制 同 前 所 述 由 于 可 以 针 对 任 意 代 码 块, 且 可 任 意 指 定 上 锁 的 对 象, 故 灵 活 性 较 高 对 synchronized(this) 的 一 些 理 解 一 当 两 个 并 发 线 程 访 问 同 一 个 对 象 object 中 的 这 个 synchronized(this) 同 步 代 码 块 时, 一 个 时 间 内 只 能 有 一 个 线 程 得 到 执 行 另 一 个 线 程 必 须 等 待 当 前 线 程 执 行 完 这 个 代 码 块 以 后 才 能 执 行 该 代 码 块 二 然 而, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 另 一 个 线 程 仍 21 / 31

然 可 以 访 问 该 object 中 的 非 synchronized(this) 同 步 代 码 块 三 尤 其 关 键 的 是, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 其 他 线 程 对 object 中 所 有 其 它 synchronized(this) 同 步 代 码 块 的 访 问 将 被 阻 塞 四 第 三 个 例 子 同 样 适 用 其 它 同 步 代 码 块 也 就 是 说, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 它 就 获 得 了 这 个 object 的 对 象 锁 结 果, 其 它 线 程 对 该 object 对 象 所 有 同 步 代 码 部 分 的 访 问 都 被 暂 时 阻 塞 五 以 上 规 则 对 其 它 对 象 锁 同 样 适 用 解 决 安 全 问 题 的 原 理 : 只 要 将 操 作 共 享 数 据 的 语 句 在 某 一 时 段 让 一 个 线 程 执 行 完, 在 执 行 过 程 中, 其 他 线 程 不 能 进 来 执 行 就 可 以 解 决 这 个 问 题 如 何 保 障 共 享 数 据 的 线 程 安 全 呢? java 中 提 供 了 一 个 解 决 方 式 : 就 是 同 步 代 码 块 格 式 : synchronized( 对 象 ) { // 任 意 对 象 都 可 以 这 个 对 象 就 是 共 享 数 据 需 要 被 同 步 的 代 码 ; --------------------------------------------------------------- 同 步 : 好 处 : 解 决 了 线 程 安 全 问 题 Synchronized 弊 端 : 相 对 降 低 性 能, 因 为 判 断 锁 需 要 消 耗 资 源, 产 生 了 死 锁 同 步 的 第 二 种 表 现 形 式 : // 对 共 享 资 源 的 方 法 定 义 同 步 同 步 函 数 : 其 实 就 是 将 同 步 关 键 字 定 义 在 函 数 上, 让 函 数 具 备 了 同 步 性 同 步 函 数 是 用 的 哪 个 锁 呢? //synchronized(this) 用 以 定 义 需 要 进 行 同 步 的 某 一 部 分 代 码 块 通 过 验 证, 函 数 都 有 自 己 所 属 的 对 象 this, 所 以 同 步 函 数 所 使 用 的 锁 就 是 this 锁 This. 方 法 名 当 同 步 函 数 被 static 修 饰 时, 这 时 的 同 步 用 的 是 哪 个 锁 呢? 静 态 函 数 在 加 载 时 所 属 于 类, 这 时 有 可 能 还 没 有 该 类 产 生 的 对 象, 但 是 该 类 的 字 节 码 文 件 加 载 进 内 存 就 已 经 被 封 装 成 了 对 象, 这 个 对 象 就 是 该 类 的 字 节 码 文 件 对 象 所 以 静 态 加 载 时, 只 有 一 个 对 象 存 在, 那 么 静 态 同 步 函 数 就 使 用 的 这 个 对 象 这 个 对 象 就 是 类 名.class 同 步 代 码 块 和 同 步 函 数 的 区 别? 同 步 代 码 块 使 用 的 锁 可 以 是 任 意 对 象 同 步 函 数 使 用 的 锁 是 this, 静 态 同 步 函 数 的 锁 是 该 类 的 字 节 码 文 件 对 象 在 一 个 类 中 只 有 一 个 同 步 的 话, 可 以 使 用 同 步 函 数 如 果 有 多 同 步, 必 须 使 用 同 步 代 码 块, 来 确 定 不 同 的 锁 所 以 同 步 代 码 块 相 对 灵 活 一 些 ------------------------------------------------------- 考 点 问 题 : 请 写 一 个 延 迟 加 载 的 单 例 模 式? 写 懒 汉 式 ; 当 出 现 多 线 程 访 问 时 怎 么 解 决? 加 同 步, 解 决 安 全 问 题 ; 效 率 高 吗? 不 高 ; 怎 样 解 决? 通 过 双 重 判 断 的 形 式 解 决 // 懒 汉 式 : 延 迟 加 载 方 式 当 多 线 程 访 问 懒 汉 式 时, 因 为 懒 汉 式 的 方 法 内 对 共 性 数 据 进 行 多 条 语 句 的 操 作 所 以 容 易 出 现 线 程 安 全 问 题 为 了 解 决, 加 入 同 步 机 制, 解 决 安 全 问 题 但 是 却 带 来 了 效 率 降 低 22 / 31

为 了 效 率 问 题, 通 过 双 重 判 断 的 形 式 解 决 class Single{ private static Single s = null; private Single(){ public static Single getinstance(){ // 锁 是 谁? 字 节 码 文 件 对 象 ; if(s == null){ synchronized(single.class){ if(s == null) s = new Single(); return s; --------------------------------------------------------- 等 待 唤 醒 机 制 : 涉 及 的 方 法 : wait: 将 同 步 中 的 线 程 处 于 冻 结 状 态 释 放 了 执 行 权, 释 放 了 资 格 同 时 将 线 程 对 象 存 储 到 线 程 池 中 notify: 唤 醒 线 程 池 中 某 一 个 等 待 线 程 notifyall: 唤 醒 的 是 线 程 池 中 的 所 有 线 程 注 意 : 1: 这 些 方 法 都 需 要 定 义 在 同 步 中 2: 因 为 这 些 方 法 必 须 要 标 示 所 属 的 锁 你 要 知 道 A 锁 上 的 线 程 被 wait 了, 那 这 个 线 程 就 相 当 于 处 于 A 锁 的 线 程 池 中, 只 能 A 锁 的 notify 唤 醒 3: 这 三 个 方 法 都 定 义 在 Object 类 中 为 什 么 操 作 线 程 的 方 法 定 义 在 Object 类 中? 因 为 这 三 个 方 法 都 需 要 定 义 同 步 内, 并 标 示 所 属 的 同 步 锁, 既 然 被 锁 调 用, 而 锁 又 可 以 是 任 意 对 象, 那 么 能 被 任 意 对 象 调 用 的 方 法 一 定 定 义 在 Object 类 中 wait 和 sleep 区 别 : 分 析 这 两 个 方 法 : 从 执 行 权 和 锁 上 来 分 析 : wait: 可 以 指 定 时 间 也 可 以 不 指 定 时 间 不 指 定 时 间, 只 能 由 对 应 的 notify 或 者 notifyall 来 唤 醒 sleep: 必 须 指 定 时 间, 时 间 到 自 动 从 冻 结 状 态 转 成 运 行 状 态 ( 临 时 阻 塞 状 态 ) wait: 线 程 会 释 放 执 行 权, 而 且 线 程 会 释 放 锁 sleep: 线 程 会 释 放 执 行 权, 但 不 是 不 释 放 锁 线 程 的 停 止 : 通 过 stop 方 法 就 可 以 停 止 线 程 但 是 这 个 方 式 过 时 了 停 止 线 程 : 原 理 就 是 : 让 线 程 运 行 的 代 码 结 束, 也 就 是 结 束 run 方 法 怎 么 结 束 run 方 法? 一 般 run 方 法 里 肯 定 定 义 循 环 所 以 只 要 结 束 循 环 即 可 第 一 种 方 式 : 定 义 循 环 的 结 束 标 记 第 二 种 方 式 : 如 果 线 程 处 于 了 冻 结 状 态, 是 不 可 能 读 到 标 记 的, 这 时 就 需 要 通 过 Thread 类 中 的 interrupt 方 法, 将 其 冻 结 状 态 强 制 清 除 让 线 程 恢 复 具 备 执 行 资 格 的 状 态, 让 线 程 可 以 读 到 标 记, 并 结 束 ---------< java.lang.thread >---------- interrupt(): 中 断 线 程 23 / 31

setpriority(int newpriority): 更 改 线 程 的 优 先 级 getpriority(): 返 回 线 程 的 优 先 级 tostring(): 返 回 该 线 程 的 字 符 串 表 示 形 式, 包 括 线 程 名 称 优 先 级 和 线 程 组 Thread.yield(): 暂 停 当 前 正 在 执 行 的 线 程 对 象, 并 执 行 其 他 线 程 setdaemon(true): 将 该 线 程 标 记 为 守 护 线 程 或 用 户 线 程 将 该 线 程 标 记 为 守 护 线 程 或 用 户 线 程 当 正 在 运 行 的 线 程 都 是 守 护 线 程 时,Java 虚 拟 机 退 出 该 方 法 必 须 在 启 动 线 程 前 调 用 join: 临 时 加 入 一 个 线 程 的 时 候 可 以 使 用 join 方 法 当 A 线 程 执 行 到 了 B 线 程 的 join 方 式 A 线 程 处 于 冻 结 状 态, 释 放 了 执 行 权,B 开 始 执 行 A 什 么 时 候 执 行 呢? 只 有 当 B 线 程 运 行 结 束 后,A 才 从 冻 结 状 态 恢 复 运 行 状 态 执 行 LOCK 的 出 现 替 代 了 同 步 :lock.lock(); lock.unlock(); Lock 接 口 : 多 线 程 在 JDK1.5 版 本 升 级 时, 推 出 一 个 接 口 Lock 接 口 解 决 线 程 安 全 问 题 使 用 同 步 的 形 式,( 同 步 代 码 块, 要 么 同 步 函 数 ) 其 实 最 终 使 用 的 都 是 锁 机 制 到 了 后 期 版 本, 直 接 将 锁 封 装 成 了 对 象 线 程 进 入 同 步 就 是 具 备 了 锁, 执 行 完, 离 开 同 步, 就 是 释 放 了 锁 在 后 期 对 锁 的 分 析 过 程 中, 发 现, 获 取 锁, 或 者 释 放 锁 的 动 作 应 该 是 锁 这 个 事 物 更 清 楚 所 以 将 这 些 动 作 定 义 在 了 锁 当 中, 并 把 锁 定 义 成 对 象 所 以 同 步 是 隐 示 的 锁 操 作, 而 Lock 对 象 是 显 示 的 锁 操 作, 它 的 出 现 就 替 代 了 同 步 在 之 前 的 版 本 中 使 用 Object 类 中 wait notify notifyall 的 方 式 来 完 成 的 那 是 因 为 同 步 中 的 锁 是 任 意 对 象, 所 以 操 作 锁 的 等 待 唤 醒 的 方 法 都 定 义 在 Object 类 中 而 现 在 锁 是 指 定 对 象 Lock 所 以 查 找 等 待 唤 醒 机 制 方 式 需 要 通 过 Lock 接 口 来 完 成 而 Lock 接 口 中 并 没 有 直 接 操 作 等 待 唤 醒 的 方 法, 而 是 将 这 些 方 式 又 单 独 封 装 到 了 一 个 对 象 中 这 个 对 象 就 是 Condition, 将 Object 中 的 三 个 方 法 进 行 单 独 的 封 装 并 提 供 了 功 能 一 致 的 方 法 await() signal() signalall() 体 现 新 版 本 对 象 的 好 处 < java.util.concurrent.locks > Condition 接 口 :await() signal() signalall(); -------------------------------------------------------- class BoundedBuffer { final Lock lock = new ReentrantLock(); final Condition notfull = lock.newcondition(); final Condition notempty = lock.newcondition(); final Object[] items = new Object[100]; int putptr, takeptr, count; public void put(object x) throws InterruptedException { lock.lock(); try { while (count == items.length) notfull.await(); items[putptr] = x; if (++putptr == items.length) putptr = 0; ++count; notempty.signal(); 24 / 31

finally { lock.unlock(); public Object take() throws InterruptedException { lock.lock(); try { while (count == 0) notempty.await(); Object x = items[takeptr]; if (++takeptr == items.length) takeptr = 0; --count; notfull.signal(); return x; finally { lock.unlock(); 集 合 框 架 集 合 框 架 :, 用 于 存 储 数 据 的 容 器 对 于 集 合 容 器, 有 很 多 种 因 为 每 一 个 容 器 的 自 身 特 点 不 同, 其 实 原 理 在 于 每 个 容 器 的 内 部 数 据 结 构 不 同 集 合 容 器 在 不 断 向 上 抽 取 过 程 中 出 现 了 集 合 体 系 在 使 用 一 个 体 系 时, 原 则 : 参 阅 顶 层 内 容 建 立 底 层 对 象 25 / 31

------------------------------------------------------------ --< java.util >-- List 接 口 : List 本 身 是 Collection 接 口 的 子 接 口, 具 备 了 Collection 的 所 有 方 法 现 在 学 习 List 体 系 特 有 的 共 性 方 法, 查 阅 方 法 发 现 List 的 特 有 方 法 都 有 索 引, 这 是 该 集 合 最 大 的 特 点 List: 有 序 ( 元 素 存 入 集 合 的 顺 序 和 取 出 的 顺 序 一 致 ), 元 素 都 有 索 引 元 素 可 以 重 复 --ArrayList: 底 层 的 数 据 结 构 是 数 组, 线 程 不 同 步,ArrayList 替 代 了 Vector, 查 询 元 素 的 速 度 非 常 快 --LinkedList: 底 层 的 数 据 结 构 是 链 表, 线 程 不 同 步, 增 删 元 素 的 速 度 非 常 快 --Vector: 底 层 的 数 据 结 构 就 是 数 组, 线 程 同 步 的,Vector 无 论 查 询 和 增 删 都 巨 慢 可 变 长 度 数 组 的 原 理 : 当 元 素 超 出 数 组 长 度, 会 产 生 一 个 新 数 组, 将 原 数 组 的 数 据 复 制 到 新 数 组 中, 再 将 新 的 元 素 添 加 到 新 数 组 中 ArrayList: 是 按 照 原 数 组 的 50% 延 长 构 造 一 个 初 始 容 量 为 10 的 空 列 表 Vector: 是 按 照 原 数 组 的 100% 延 长 ------------------------------------------------------------ --< java.util >-- Set 接 口 : 数 据 结 构 : 数 据 的 存 储 方 式 ; Set 接 口 中 的 方 法 和 Collection 中 方 法 一 致 的 Set 接 口 取 出 方 式 只 有 一 种, 迭 代 器 --HashSet: 底 层 数 据 结 构 是 哈 希 表, 线 程 是 不 同 步 的 无 序, 高 效 ; HashSet 集 合 保 证 元 素 唯 一 性 : 通 过 元 素 的 hashcode 方 法, 和 equals 方 法 完 成 的 当 元 素 的 hashcode 值 相 同 时, 才 继 续 判 断 元 素 的 equals 是 否 为 true 如 果 为 true, 那 么 视 为 相 同 元 素, 不 存 如 果 为 false, 那 么 存 储 如 果 hashcode 值 不 同, 那 么 不 判 断 equals, 从 而 提 高 对 象 比 较 的 速 度 --LinkedHashSet: 有 序,hashset 的 子 类 --TreeSet: 对 Set 集 合 中 的 元 素 的 进 行 指 定 顺 序 的 排 序 不 同 步 TreeSet 底 层 的 数 据 结 构 就 是 二 叉 树 对 于 ArrayList 集 合, 判 断 元 素 是 否 存 在, 或 者 删 元 素 底 层 依 据 都 是 equals 方 法 对 于 HashSet 集 合, 判 断 元 素 是 否 存 在, 或 者 删 除 元 素, 底 层 依 据 的 是 hashcode 方 法 和 equals 方 法 ------------------------------------------------------------ Map 集 合 : --Hashtable: 底 层 是 哈 希 表 数 据 结 构, 是 线 程 同 步 的 不 可 以 存 储 null 键,null 值 --HashMap: 底 层 是 哈 希 表 数 据 结 构, 是 线 程 不 同 步 的 可 以 存 储 null 键,null 值 替 代 了 Hashtable. --TreeMap: 底 层 是 二 叉 树 结 构, 可 以 对 map 集 合 中 的 键 进 行 指 定 顺 序 的 排 序 Map 集 合 存 储 和 Collection 有 着 很 大 不 同 : Collection 一 次 存 一 个 元 素 ;Map 一 次 存 一 对 元 素 Collection 是 单 列 集 合 ;Map 是 双 列 集 合 Map 中 的 存 储 的 一 对 元 素 : 一 个 是 键, 一 个 是 值, 键 与 值 之 间 有 对 应 ( 映 射 ) 关 系 特 点 : 要 保 证 map 集 合 中 键 的 唯 一 性 26 / 31

5, 想 要 获 取 map 中 的 所 有 元 素 : 原 理 :map 中 是 没 有 迭 代 器 的,collection 具 备 迭 代 器, 只 要 将 map 集 合 转 成 Set 集 合, 可 以 使 用 迭 代 器 了 之 所 以 转 成 set, 是 因 为 map 集 合 具 备 着 键 的 唯 一 性, 其 实 set 集 合 就 来 自 于 map, set 集 合 底 层 其 实 用 的 就 是 map 的 方 法 把 map 集 合 转 成 set 的 方 法 : Set keyset(); Set entryset();// 取 的 是 键 和 值 的 映 射 关 系 Entry 就 是 Map 接 口 中 的 内 部 接 口 ; 为 什 么 要 定 义 在 map 内 部 呢?entry 是 访 问 键 值 关 系 的 入 口, 是 map 的 入 口, 访 问 的 是 map 中 的 键 值 对 --------------------------------------------------------- 取 出 map 集 合 中 所 有 元 素 的 方 式 一 :keyset() 方 法 可 以 将 map 集 合 中 的 键 都 取 出 存 放 到 set 集 合 中 对 set 集 合 进 行 迭 代 迭 代 完 成, 再 通 过 get 方 法 对 获 取 到 的 键 进 行 值 的 获 取 Set keyset = map.keyset(); Iterator it = keyset.iterator(); while(it.hasnext()) { Object key = it.next(); Object value = map.get(key); System.out.println(key+":"+value); -------------------------------------------------------- 取 出 map 集 合 中 所 有 元 素 的 方 式 二 :entryset() 方 法 Set entryset = map.entryset(); Iterator it = entryset.iterator(); while(it.hasnext()) { Map.Entry me = (Map.Entry)it.next(); System.out.println(me.getKey()+"::::"+me.getValue()); -------------------------------------------------------- 将 非 同 步 集 合 转 成 同 步 集 合 的 方 法 :Collections 中 的 XXX synchronizedxxx(xxx); List synchronizedlist(list); Map synchronizedmap(map); public static <K,V> Map<K,V> synchronizedmap(map<k,v> m) { return new SynchronizedMap<K,V>(m); 原 理 : 定 义 一 个 类, 将 集 合 所 有 的 方 法 加 同 一 把 锁 后 返 回 List list = Collections.synchronizedList(new ArrayList()); Map<String,String> synmap = Collections.synchronizedMap(map); Collection 和 Collections 的 区 别 : Collections 是 个 java.util 下 的 类, 是 针 对 集 合 类 的 一 个 工 具 类, 提 供 一 系 列 静 态 方 法, 实 现 对 集 合 的 查 找 排 序 替 换 线 程 安 全 化 ( 将 非 同 步 的 集 合 转 换 成 同 步 的 ) 等 操 作 Collection 是 个 java.util 下 的 接 口, 它 是 各 种 集 合 结 构 的 父 接 口, 继 承 于 它 的 接 口 主 要 有 Set 和 List, 提 供 了 关 于 集 合 的 一 些 操 作, 如 插 入 删 除 判 断 一 个 元 素 是 否 其 成 员 遍 历 等 ------------------------------------------------------- 27 / 31

自 动 拆 装 箱 :java 中 数 据 类 型 分 为 两 种 : 基 本 数 据 类 型 引 用 数 据 类 型 ( 对 象 ) 在 java 程 序 中 所 有 的 数 据 都 需 要 当 做 对 象 来 处 理, 针 对 8 种 基 本 数 据 类 型 提 供 了 包 装 类, 如 下 : int --> Integer byte --> Byte short --> Short long --> Long char --> Character double --> Double float --> Float boolean --> Boolean jdk5 以 前 基 本 数 据 类 型 和 包 装 类 之 间 需 要 互 转 : 基 本 --- 引 用 Integer x = new Integer(x); 引 用 --- 基 本 int num = x.intvalue(); 1) Integer x = 1; x = x + 1; 经 历 了 什 么 过 程? 装 箱 拆 箱 装 箱 ; 2) 为 了 优 化, 虚 拟 机 为 包 装 类 提 供 了 缓 冲 池,Integer 池 的 大 小 -128~127 一 个 字 节 的 大 小 ; 3) String 池 :Java 为 了 优 化 字 符 串 操 作 提 供 了 一 个 缓 冲 池 ; ---------------------------------------------------------- 泛 型 :jdk1.5 版 本 以 后 出 现 的 一 个 安 全 机 制 表 现 格 式 :< > 好 处 : 1: 将 运 行 时 期 的 问 题 ClassCastException 问 题 转 换 成 了 编 译 失 败, 体 现 在 编 译 时 期, 程 序 员 就 可 以 解 决 问 题 2: 避 免 了 强 制 转 换 的 麻 烦 泛 型 中 的 通 配 符 : 可 以 解 决 当 具 体 类 型 不 确 定 的 时 候, 这 个 通 配 符 就 是? ; 当 操 作 类 型 时, 不 需 要 使 用 类 型 的 具 体 功 能 时, 只 使 用 Object 类 中 的 功 能 那 么 可 以 用? 通 配 符 来 表 未 知 类 型 ------------------------------------------------------------------------------------------------------------------------------- 反 射 技 术 反 射 技 术 : 其 实 就 是 动 态 加 载 一 个 指 定 的 类, 并 获 取 该 类 中 的 所 有 的 内 容 并 将 字 节 码 文 件 中 的 内 容 都 封 装 成 对 象, 这 样 便 于 操 作 这 些 成 员 简 单 说 : 反 射 技 术 可 以 对 一 个 类 进 行 解 剖 反 射 的 好 处 : 大 大 的 增 强 了 程 序 的 扩 展 性 反 射 的 基 本 步 骤 : 1 获 得 Class 对 象, 就 是 获 取 到 指 定 的 名 称 的 字 节 码 文 件 对 象 2 实 例 化 对 象, 获 得 类 的 属 性 方 法 或 构 造 函 数 3 访 问 属 性 调 用 方 法 调 用 构 造 函 数 创 建 对 象 获 取 这 个 Class 对 象, 有 三 种 方 式 : 1: 通 过 每 个 对 象 都 具 备 的 方 法 getclass 来 获 取 弊 端 : 必 须 要 创 建 该 类 对 象, 才 可 以 调 用 getclass 方 法 2: 每 一 个 数 据 类 型 ( 基 本 数 据 类 型 和 引 用 数 据 类 型 ) 都 有 一 个 静 态 的 属 性 class 弊 端 : 必 须 要 先 明 确 该 类 28 / 31

前 两 种 方 式 不 利 于 程 序 的 扩 展, 因 为 都 需 要 在 程 序 使 用 具 体 的 类 来 完 成 3: 使 用 的 Class 类 中 的 方 法, 静 态 的 forname 方 法 指 定 什 么 类 名, 就 获 取 什 么 类 字 节 码 文 件 对 象, 这 种 方 式 的 扩 展 性 最 强, 只 要 将 类 名 的 字 符 串 传 入 即 可 // 1. 根 据 给 定 的 类 名 来 获 得 用 于 类 加 载 String classname = "cn.itcast.reflect.person";// 来 自 配 置 文 件 Class clazz = Class.forName(classname);// 此 对 象 代 表 Person.class // 2. 如 果 拿 到 了 对 象, 不 知 道 是 什 么 类 型 用 于 获 得 对 象 的 类 型 Object obj = new Person(); Class clazz1 = obj.getclass();// 获 得 对 象 具 体 的 类 型 // 3. 如 果 是 明 确 地 获 得 某 个 类 的 Class 对 象 主 要 用 于 传 参 Class clazz2 = Person.class; 反 射 的 用 法 : 1) 需 要 获 得 java 类 的 各 个 组 成 部 分, 首 先 需 要 获 得 类 的 Class 对 象, 获 得 Class 对 象 的 三 种 方 式 : Class.forName(classname) 用 于 做 类 加 载 obj.getclass() 用 于 获 得 对 象 的 类 型 类 名.class 用 于 获 得 指 定 的 类 型, 传 参 用 2) 反 射 类 的 成 员 方 法 : Class clazz = Person.class; Method method = clazz.getmethod(methodname, new Class[]{paramClazz1, paramclazz2); method.invoke(); 3) 反 射 类 的 构 造 函 数 : Constructor con = clazz.getconstructor(new Class[]{paramClazz1, paramclazz2,...) con.newinstance(params...) 4) 反 射 类 的 属 性 : Field field = clazz.getfield(fieldname); field.setaccessible(true); field.setobject(value); 获 取 了 字 节 码 文 件 对 象 后, 最 终 都 需 要 创 建 指 定 类 的 对 象 : 创 建 对 象 的 两 种 方 式 ( 其 实 就 是 对 象 在 进 行 实 例 化 时 的 初 始 化 方 式 ): 1, 调 用 空 参 数 的 构 造 函 数 : 使 用 了 Class 类 中 的 newinstance() 方 法 2, 调 用 带 参 数 的 构 造 函 数 : 先 要 获 取 指 定 参 数 列 表 的 构 造 函 数 对 象, 然 后 通 过 该 构 造 函 数 的 对 象 的 newinstance( 实 际 参 数 ) 进 行 对 象 的 初 始 化 综 上 所 述, 第 二 种 方 式, 必 须 要 先 明 确 具 体 的 构 造 函 数 的 参 数 类 型, 不 便 于 扩 展 所 以 一 般 情 况 下, 被 反 射 的 类, 内 部 通 常 都 会 提 供 一 个 公 有 的 空 参 数 的 构 造 函 数 ------------------------------------------------------ // 如 何 生 成 获 取 到 字 节 码 文 件 对 象 的 实 例 对 象 Class clazz = Class.forName("cn.itcast.bean.Person");// 类 加 载 // 直 接 获 得 指 定 的 类 型 clazz = Person.class; 29 / 31