二 Synchronized 1. Java 语 言 的 关 键 字, 当 它 用 来 修 饰 一 个 方 法 或 者 一 个 代 码 块 的 时 候, 能 够 保 证 在 同 一 时 刻 最 多 只 有 一 个 线 程 执 行 该 段 代 码 2. 当 两 个 并 发 线 程 访 问 同 一 个

Java 基 础 包 括 多 线 程 (Thread 和 Runable 的 区 别 ) 同 步 异 步 (Synchronized) 线 程 池 集 合 序 列 化 反 射 实 例 化 过 程 JDBC 常 用 类 IBatis Java 类 生 命 周 期 Java Web 生 命 周 期 Tomcat 出 去 Http 请 求 过 程 Java 垃 圾 回 收 机 制 Java 性 能 优 化 一 Thread 和 Runable 的 区 别 1. Thread 是 基 类, 子 类 必 继 承 他 实 现 其 run 方 法 其 也 是 实 现 了 Runable 接 口 Thread 是 普 通 的 类, 并 非 抽 象 类 或 者 密 封 类 等 2. Runnable 是 接 口, 子 类 必 须 实 现 run 方 法, 该 接 口 就 只 有 唯 一 的 抽 象 方 法 run 3. 由 于 Java 单 继 承, 所 以 Thead 通 过 类 继 承 方 式 实 现 接 口, 存 在 扩 展 性 问 题 4. 他 们 都 是 通 过 start 方 法 来 启 动, 可 以 达 到 异 步 操 作, 如 果 用 run 方 法 启 动 其 将 是 同 步 方 法, 失 去 多 线 程 的 意 义 5. Runnable, 的 实 现 类 可 以 实 现 资 源 共 享, 多 个 调 用 只 需 要 实 例 化 Runnable 的 一 个 实 例, 然 后 将 其 放 到 new Thread(new Runnable 实 现 类 ).start 方 法 ( 可 以 new 多 个 一 样 的 即 表 示 多 个 线 程 ), 启 动 6. 实 验 发 现 在 实 现 Runnable 的 多 线 程 中, 如 果 同 时 启 动 的 实 例 过 多 会 在 第 一 次 执 行 的 时 候 出 现 多 线 程 并 发, 主 要 出 现 在 开 始, 有 肯 能 是 程 序 启 动 加 载 资 源 导 致, 大 多 度 数 时 候 还 是 稳 定 的 比 如 实 现 的 run 方 法 控 制 了 10 个 实 际 new 的 个 数 太 多 久 会 出 现, 但 是 频 率 不 高 7. 可 以 在 Thread 中 实 现 匿 名 方 法 也 可 以 实 现 多 线 程 异 步 华 8. 主 线 程 结 束, 子 线 程 可 以 继 续 执 行 9. 在 java 中, 每 次 程 序 运 行 至 少 启 动 2 个 线 程 一 个 是 main 线 程, 一 个 是 垃 圾 收 集 线 程

二 Synchronized 1. Java 语 言 的 关 键 字, 当 它 用 来 修 饰 一 个 方 法 或 者 一 个 代 码 块 的 时 候, 能 够 保 证 在 同 一 时 刻 最 多 只 有 一 个 线 程 执 行 该 段 代 码 2. 当 两 个 并 发 线 程 访 问 同 一 个 对 象 object 中 的 这 个 synchronized(this) 同 步 代 码 块 时, 一 个 时 间 内 只 能 有 一 个 线 程 得 到 执 行 另 一 个 线 程 必 须 等 待 当 前 线 程 执 行 完 这 个 代 码 块 以 后 才 能 执 行 该 代 码 块 3. 然 而, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 另 一 个 线 程 仍 然 可 以 访 问 该 object 中 的 非 synchronized(this) 同 步 代 码 块 4. 尤 其 关 键 的 是, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 其 他 线 程 对 object 中 所 有 其 它 synchronized(this) 同 步 代 码 块 的 访 问 将 被 阻 塞 5. 第 三 个 例 子 同 样 适 用 其 它 同 步 代 码 块 也 就 是 说, 当 一 个 线 程 访 问 object 的 一 个 synchronized(this) 同 步 代 码 块 时, 它 就 获 得 了 这 个 object 的 对 象 锁 结 果, 其 它 线 程 对 该 object 对 象 所 有 同 步 代 码 部 分 的 访 问 都 被 暂 时 阻 塞 6. 以 上 规 则 对 其 它 对 象 锁 同 样 适 用 三 线 程 池 concurrent 工 具 包 中 也 提 供 了 线 程 池, 而 且 使 用 非 常 方 便 concurrent 工 具 包 中 的 线 程 池 分 为 3 类 :ScheduledThreadPool FixedThreadPool 和 CachedThreadPool 1. ScheduledThreadPool

这 和 我 们 平 时 使 用 的 ScheduledTask 比 较 类 似, 或 者 说 很 像 Timer, 它 可 以 使 得 一 个 线 程 在 指 定 的 一 段 时 间 内 开 始 运 行, 并 且 在 间 隔 另 外 一 段 时 间 后 再 次 运 行, 直 到 线 程 池 关 闭 2. FixedThreadPool 这 是 一 个 指 定 容 量 的 线 程 池, 即 我 们 可 以 指 定 在 同 一 时 间, 线 程 池 中 最 多 有 多 个 线 程 在 运 行, 超 出 的 线 程, 需 要 等 线 程 池 中 有 空 闲 线 程 时, 才 能 有 机 会 运 行 3. CachedThreadPool 这 是 另 外 一 种 线 程 池, 它 不 需 要 指 定 容 量, 只 要 有 需 要, 它 就 会 创 建 新 的 线 程 四 集 合

Collection 概 述 Java 集 合 中 的 List 和 Set 都 从 Collection 出 来, 它 是 一 个 学 习 集 合 很 不 错 的 入 口, 它 包 含 了 集 合 中 通 常 需 要 有 的 操 作 : 添 加 元 素 :add/addall 清 空 集 合 :clear 删 除 元 素 :remove/removeall 判 断 集 合 中 是 否 包 含 某 元 素 :contains/containsall 判 断 集 合 是 否 为 空 :isempty 计 算 集 合 中 元 素 的 个 数 :size 将 集 合 转 换 为 数 组 :toarray 获 取 迭 代 器 :iterator List Java 中 的 List 是 对 数 组 的 有 效 扩 展, 它 是 这 样 一 种 结 构, 如 果 不 使 用 泛 型, 它 可 以 容 纳 任 何 类 型 的 元 素, 如 果 使 用 泛 型, 那 么 它 只 能 容 纳 泛 型 指 定 的 类 型 的 元 素 和 数 组 相 比,List 的 容 量 是 可 以 动 态 扩 展 的 List 中 的 元 素 是 可 以 重 复 的, 里 面 的 元 素 是 有 序 的, 这 里 的 有 序, 并 不 是 排 序 的 意 思, 而 是 说 我 们 可 以 对 某 个 元 素 在 集 合 中 的 位 置 进 行 指 定 List 中 常 用 的 集 合 对 象 包 括 :ArrayList Vector 和 LinkedList, 其 中 前 两 者 是 基 于 数 组 来 进 行 存 储, 后 者 是 基 于 链 表 进 行 存 储 其 中 Vector 是 线 程 安 全 的, 其 余 两 个 不 是 线 程 安 全 的 List 中 是 可 以 包 括 null 的, 即 使 是 使 用 了 泛 型

ArrayList 可 能 是 我 们 平 时 用 到 的 最 多 的 集 合 对 象 了, 在 上 述 的 示 例 代 码 中, 我 们 也 是 使 用 它 来 实 例 化 一 个 Collection 对 象, 在 此 不 再 赘 述 Vector Vector 的 示 例 如 下, 首 先 我 们 看 如 何 生 成 和 输 出 Vector: LinkedList LinkedList 使 用 链 表 来 存 储 数 据 Set Set 和 List 类 似, 都 是 用 来 存 储 单 个 元 素, 单 个 元 素 的 数 量 不 确 定 但 Set 不 能 包 含 重 复 元 素, 如 果 向 Set 中 插 入 两 个 相 同 元 素, 那 么 后 一 个 元 素 不 会 被 插 入 Set 可 以 大 致 分 为 两 类 : 不 排 序 Set 和 排 序 Set, 不 排 序 Set 包 括 HashSet 和 LinkedHashSet, 排 序 Set 主 要 指 TreeSet 其 中 HashSet 和 LinkedHashSet 可 以 包 含 null HashSet HashSet 是 由 Hash 表 支 持 的 一 种 集 合, 它 不 是 线 程 安 全 的 TreeSet TreeSet 是 支 持 排 序 的 一 种 Set, 它 的 父 接 口 是 SortedSet TreeSet 中 的 元 素, 一 般 都 实 现 了 Comparable 接 口, 默 认 情 况 下, 对 于 Integer 来 说, SortedList 是 采 用 升 序 来 存 储 的, 我 们 也 可 以 自 定 义 Compare 方 式

Map Map 中 存 储 的 是 键 值 对, 和 Set 类 似,Java 中 的 Map 也 有 两 种 : 排 序 的 和 不 排 序 的, 不 排 序 的 包 括 HashMap Hashtable 和 LinkedHashMap, 排 序 的 包 括 TreeMap 非 排 序 Map HashMap 和 Hashtable 都 是 采 取 Hash 表 的 方 式 进 行 存 储,HashMap 不 是 线 程 安 全 的, Hashtable 是 线 程 安 全 的, 我 们 可 以 把 HashMap 看 做 是 简 化 版 的 Hashtable HashMap 是 可 以 存 储 null 的, 无 论 是 对 Key 还 是 对 Value Hashtable 是 不 可 以 存 储 null 的 无 论 HashMap 还 是 Hashtable, 我 们 观 察 它 的 构 造 函 数, 就 会 发 现 它 可 以 有 两 个 参 数 : initialcapacity 和 loadfactor, 默 认 情 况 下,initialCapacity 等 于 16,loadFactor 等 于 0.75 这 和 Hash 表 中 可 以 存 放 的 元 素 数 目 有 关 系, 当 元 素 数 目 超 过 initialcapacity*loadfacto r 时, 会 触 发 rehash 方 法, 对 hash 表 进 行 扩 容 如 果 我 们 需 要 向 其 中 插 入 过 多 元 素, 需 要 适 当 调 整 这 两 个 参 数 HashTable: 继 承 自 Dictionary 类, 并 且 实 现 了 Map<K,V>, Cloneable, java.io.serializable 3 个 接 口, Cloneable, java.io.serializable 这 2 个 是 空 接 口 排 序 Map 排 序 Map 主 要 是 指 TreeMap, 它 对 元 素 增 删 查 操 作 时 的 时 间 复 杂 度 都 是 O(log(n)) 它 不 是 线 程 安 全 的 它 的 特 点 和 TreeSet 非 常 像, 这 里 不 再 赘 述

五 序 列 化 1. 实 现 Serializable 接 口 必 须 定 义 serialversionuid( 可 以 有 固 定 值 或 者 Jvm 计 算 ), 否 则 在 类 增 加 了 属 性 以 后, 以 前 已 经 被 的 序 列 化 的 数 据 将 不 能 被 反 序 列 化 回 来 2. 在 有 继 承 层 次 的 业 务 对 象, 进 行 序 列 化 时, 如 果 父 类 没 有 实 现 Serializable 接 口, 那 么 父 类 必 须 提 供 默 认 构 造 函 数 3. 在 有 继 承 层 次 的 业 务 对 象 进 行 序 列 化 时, 父 类 也 应 该 实 现 Serializable 接 口 4. transient 关 键 字 来 处 理 这 种 情 况, 针 对 那 些 敏 感 的 属 性, 我 们 只 需 使 用 该 关 键 字 进 行 修 饰, 那 么 在 序 列 化 时, 对 应 的 属 性 值 就 不 会 被 保 存 六 反 射 1. 我 们 可 以 使 用 class.netinstance 的 方 式 来 创 建 一 个 对 象, 执 行 方 法 : 2. 我 们 可 以 通 过 方 法 的 名 称 以 及 参 数 类 型 构 建 一 个 Method 实 例, 然 后 调 用 Method 的 invoke 方 法, 来 触 发 方 法

3. 可 以 对 Field 的 值 进 行 修 改 4. Annotation 探 索 一 开 始 我 们 提 到, 反 射 是 很 多 技 术 的 基 础,Annotation 就 是 这 样 的, 我 们 可 以 把 Annotation 看 做 是 C# 中 的 Attribute, 它 可 以 对 类 型 方 法 属 性 字 段 方 法 参 数 等 信 息 进 行 修 饰 我 们 可 以 使 用 @+Annotation 名 的 方 式 来 使 用 Annotation 七 类 实 例 化 过 程 父 类 静 态 成 员 / 父 类 静 态 初 始 化 块 -> 子 类 静 态 成 员 / 子 类 静 态 初 始 化 块 -> 父 类 成 员 变 量 / 父 类 初 始 化 块 -> 父 类 构 造 函 数 -> 子 类 成 员 变 量 / 子 类 初 始 化 块 -> 子 类 构 造 函 数 八 JDBC JDBC 中 常 用 的 对 象 包 括 : ConnectionManager Connection Statement CallableStatement PreparedStatement ResultSet SavePoint

九 IBatis 首 先 Hiberante,iBatis,MyBatis 都 是 对 数 据 访 问 的 封 装, 最 终 都 是 生 成 sql 语 句 访 问 数 据 库 只 不 过 Hibernate 封 装 得 比 较 全 面,IBatis 只 是 局 部 封 装, 懂 Jdbc 的 程 序 员 可 以 快 速 上 手, 而 mybatis 是 近 来 流 行 的 一 种 新 的 IBatis 是 对 IBatis 的 升 级, 可 以 看 着 是 升 级 版

十 Java 类 生 命 周 期 首 先 来 了 解 一 下 jvm(java 虚 拟 机 ) 中 的 几 个 比 较 重 要 的 内 存 区 域, 这 几 个 区 域 在 java 类 的 生 命 周 期 中 扮 演 着 比 较 重 要 的 角 色 : 方 法 区 : 在 java 的 虚 拟 机 中 有 一 块 专 门 用 来 存 放 已 经 加 载 的 类 信 息 常 量 静 态 变 量 以 及 方 法 代 码 的 内 存 区 域, 叫 做 方 法 区 常 量 池 : 常 量 池 是 方 法 区 的 一 部 分, 主 要 用 来 存 放 常 量 和 类 中 的 符 号 引 用 等 信 息 堆 区 : 用 于 存 放 类 的 对 象 实 例 栈 区 : 也 叫 java 虚 拟 机 栈, 是 由 一 个 一 个 的 栈 帧 组 成 的 后 进 先 出 的 栈 式 结 构, 栈 桢 中 存 放 方 法 运 行 时 产 生 的 局 部 变 量 方 法 出 口 等 信 息 当 调 用 一 个 方 法 时, 虚 拟 机 栈 中 就 会 创 建 一 个 栈 帧 存 放 这 些 数 据, 当 方 法 调 用 完 成 时, 栈 帧 消 失, 如 果 方 法 中 调 用 了 其 他 方 法, 则 继 续 在 栈 顶 创 建 新 的 栈 桢

除 了 以 上 四 个 内 存 区 域 之 外,jvm 中 的 运 行 时 内 存 区 域 还 包 括 本 地 方 法 栈 和 程 序 计 数 器, 这 两 个 区 域 与 java 类 的 生 命 周 期 关 系 不 是 很 大, 在 这 里 就 不 说 了, 感 兴 趣 的 朋 友 可 以 自 己 百 度 一 下 类 的 生 命 周 期 当 我 们 编 写 一 个 java 的 源 文 件 后, 经 过 编 译 会 生 成 一 个 后 缀 名 为 class 的 文 件, 这 种 文 件 叫 做 字 节 码 文 件, 只 有 这 种 字 节 码 文 件 才 能 够 在 java 虚 拟 机 中 运 行,java 类 的 生 命 周 期 就 是 指 一 个 class 文 件 从 加 载 到 卸 载 的 全 过 程 一 个 java 类 的 完 整 的 生 命 周 期 会 经 历 加 载 连 接 初 始 化 使 用 和 卸 载 五 个 阶 段, 当 然 也 有 在 加 载 或 者 连 接 之 后 没 有 被 初 始 化 就 直 接 被 使 用 的 情 况, 如 图 所 示 : 下 面 我 们 就 依 次 来 说 一 说 这 五 个 阶 段 加 载 在 java 中, 我 们 经 常 会 接 触 到 一 个 词 类 加 载, 它 和 这 里 的 加 载 并 不 是 一 回 事, 通 常 我 们 说 类 加 载 指 的 是 类 的 生 命 周 期 中 加 载 连 接 初 始 化 三 个 阶 段 在 加 载 阶 段,java 虚 拟 机 会 做 什 么 工 作 呢? 其 实 很 简 单, 就 是 找 到 需 要 加 载 的 类 并 把 类 的 信 息 加 载 到 jvm 的 方 法 区 中, 然 后 在 堆 区 中 实 例 化 一 个 java.lang.class 对 象, 作 为 方 法 区 中 这 个 类 的 信 息 的 入 口 类 的 加 载 方 式 比 较 灵 活, 我 们 最 常 用 的 加 载 方 式 有 两 种, 一 种 是 根 据 类 的 全 路 径 名 找 到 相 应 的 class 文 件, 然 后 从 class 文 件 中 读 取 文 件 内 容 ; 另 一 种 是 从 jar 文 件 中 读 取 另 外, 还 有 下 面 几 种 方 式 也 比 较 常 用 : 从 网 络 中 获 取 : 比 如 10 年 前 十 分 流 行 的 Applet 根 据 一 定 的 规 则 实 时 生 成, 比 如 设 计 模 式 中 的 动 态 代 理 模 式, 就 是 根 据 相 应 的 类 自 动 生 成 它 的 代 理 类 从 非 class 文 件 中 获 取, 其 实 这 与 直 接 从 class 文 件 中 获 取 的 方 式 本 质 上 是 一 样 的, 这 些 非 class 文 件 在 jvm 中 运 行 之 前 会 被 转 换 为 可 被 jvm 所 识 别 的 字 节 码 文 件 对 于 加 载 的 时 机, 各 个 虚 拟 机 的 做 法 并 不 一 样, 但 是 有 一 个 原 则, 就 是 当 jvm 预 期 到 一 个 类 将 要 被 使 用 时, 就 会 在 使 用 它 之 前 对 这 个 类 进 行 加 载 比 如 说, 在 一 段 代 码 中 出 现 了

一 个 类 的 名 字,jvm 在 执 行 这 段 代 码 之 前 并 不 能 确 定 这 个 类 是 否 会 被 使 用 到, 于 是, 有 些 jvm 会 在 执 行 前 就 加 载 这 个 类, 而 有 些 则 在 真 正 需 要 用 的 时 候 才 会 去 加 载 它, 这 取 决 于 具 体 的 jvm 实 现 我 们 常 用 的 hotspot 虚 拟 机 是 采 用 的 后 者, 就 是 说 当 真 正 用 到 一 个 类 的 时 候 才 对 它 进 行 加 载 加 载 阶 段 是 类 的 生 命 周 期 中 的 第 一 个 阶 段, 加 载 阶 段 之 后, 是 连 接 阶 段 有 一 点 需 要 注 意, 就 是 有 时 连 接 阶 段 并 不 会 等 加 载 阶 段 完 全 完 成 之 后 才 开 始, 而 是 交 叉 进 行, 可 能 一 个 类 只 加 载 了 一 部 分 之 后, 连 接 阶 段 就 已 经 开 始 了 但 是 这 两 个 阶 段 总 的 开 始 时 间 和 完 成 时 间 总 是 固 定 的 : 加 载 阶 段 总 是 在 连 接 阶 段 之 前 开 始, 连 接 阶 段 总 是 在 加 载 阶 段 完 成 之 后 完 成 连 接 连 接 阶 段 比 较 复 杂, 一 般 会 跟 加 载 阶 段 和 初 始 化 阶 段 交 叉 进 行, 这 个 阶 段 的 主 要 任 务 就 是 做 一 些 加 载 后 的 验 证 工 作 以 及 一 些 初 始 化 前 的 准 备 工 作, 可 以 细 分 为 三 个 步 骤 : 验 证 准 备 和 解 析 1. 验 证 : 当 一 个 类 被 加 载 之 后, 必 须 要 验 证 一 下 这 个 类 是 否 合 法, 比 如 这 个 类 是 不 是 符 合 字 节 码 的 格 式 变 量 与 方 法 是 不 是 有 重 复 数 据 类 型 是 不 是 有 效 继 承 与 实 现 是 否 合 乎 标 准 等 等 总 之, 这 个 阶 段 的 目 的 就 是 保 证 加 载 的 类 是 能 够 被 jvm 所 运 行 2. 准 备 : 准 备 阶 段 的 工 作 就 是 为 类 的 静 态 变 量 分 配 内 存 并 设 为 jvm 默 认 的 初 值, 对 于 非 静 态 的 变 量, 则 不 会 为 它 们 分 配 内 存 有 一 点 需 要 注 意, 这 时 候, 静 态 变 量 的 初 值 为 jvm 默 认 的 初 值, 而 不 是 我 们 在 程 序 中 设 定 的 初 值 jvm 默 认 的 初 值 是 这 样 的 : o 基 本 类 型 (int long short char byte boolean float double) 的 默 认 值 为 0 o 引 用 类 型 的 默 认 值 为 null o 常 量 的 默 认 值 为 我 们 程 序 中 设 定 的 值, 比 如 我 们 在 程 序 中 定 义 final static int a = 100, 则 准 备 阶 段 中 a 的 初 值 就 是 100 3. 解 析 : 这 一 阶 段 的 任 务 就 是 把 常 量 池 中 的 符 号 引 用 转 换 为 直 接 引 用 那 么 什 么 是 符 号 引 用, 什 么 又 是 直 接 引 用 呢? 我 们 来 举 个 例 子 : 我 们 要 找 一 个 人, 我 们 现 有 的 信 息 是 这 个 人 的 身 份 证 号 是 1234567890 只 有 这 个 信 息 我 们 显 然 找 不 到 这 个 人, 但 是 通 过 公 安 局 的 身 份 系 统, 我 们 输 入 1234567890 这 个 号 之 后, 就 会 得 到 它 的 全 部 信 息 : 比 如 安 徽 省 黄 山 市 余 暇 村 18 号 张 三, 通 过 这 个 信 息 我 们 就 能 找 到 这 个 人 了 这 里,123456790 就 好 比 是 一 个 符 号 引 用, 而 安 徽 省 黄 山 市 余 暇 村 18 号 张 三 就 是 直 接 引 用 在 内 存 中 也 是 一 样, 比 如 我 们 要 在 内 存 中 找 一 个 类 里 面 的 一 个 叫 做 show 的 方 法, 显 然 是 找 不 到 但 是 在 解 析 阶 段,jvm 就 会 把 show 这 个 名 字 转 换 为 指 向 方 法 区 的 的 一 块 内 存 地 址, 比 如 c17164, 通 过 c17164 就 可 以 找 到 show 这 个 方 法 具 体 分 配 在 内 存 的 哪 一 个 区 域 了 这 里 show 就 是 符 号 引 用, 而 c17164 就 是 直 接 引

用 在 解 析 阶 段,jvm 会 将 所 有 的 类 或 接 口 名 字 段 名 方 法 名 转 换 为 具 体 的 内 存 地 址 初 始 化 连 接 阶 段 完 成 之 后 会 根 据 使 用 的 情 况 ( 直 接 引 用 还 是 被 动 引 用 ) 来 选 择 是 否 对 类 进 行 初 始 化 如 果 一 个 类 被 直 接 引 用, 就 会 触 发 类 的 初 始 化 在 java 中, 直 接 引 用 的 情 况 有 : 通 过 new 关 键 字 实 例 化 对 象 读 取 或 设 置 类 的 静 态 变 量 调 用 类 的 静 态 方 法 通 过 反 射 方 式 执 行 以 上 三 种 行 为 初 始 化 子 类 的 时 候, 会 触 发 父 类 的 初 始 化 作 为 程 序 入 口 直 接 运 行 时 ( 也 就 是 直 接 调 用 main 方 法 ) 除 了 以 上 四 种 情 况, 其 他 使 用 类 的 方 式 叫 做 被 动 引 用, 而 被 动 引 用 不 会 触 发 类 的 初 始 化 请 看 主 动 引 用 的 示 例 代 码 : [java] view plainc opy 1. import java.lang.reflect.field; 2. import java.lang.reflect.method; 3. 4. class InitClass{ 5. static { 6. System.out.println(" 初 始 化 InitClass"); 7. } 8. public static String a = null; 9. public static void method(){} 10. } 11. 12. class SubInitClass extends InitClass{} 13. 14. public class Test1 { 15. 16. /** 17. * 主 动 引 用 引 起 类 的 初 始 化 的 第 四 种 情 况 就 是 运 行 Test1 的 main 方 法 时 18. * 导 致 Test1 初 始 化, 这 一 点 很 好 理 解, 就 不 特 别 演 示 了 19. * 本 代 码 演 示 了 前 三 种 情 况, 以 下 代 码 都 会 引 起 InitClass 的 初 始 化, 20. * 但 由 于 初 始 化 只 会 进 行 一 次, 运 行 时 请 将 注 解 去 掉, 依 次 运 行 查 看 结 果 21. * @param args 22. * @throws Exception 23. */

24. public static void main(string[] args) throws Exception{ 25. // 主 动 引 用 引 起 类 的 初 始 化 一 : new 对 象 读 取 或 设 置 类 的 静 态 变 量 调 用 类 的 静 态 方 法 26. // new InitClass(); 27. // InitClass.a = ""; 28. // String a = InitClass.a; 29. // InitClass.method(); 30. 31. // 主 动 引 用 引 起 类 的 初 始 化 二 : 通 过 反 射 实 例 化 对 象 读 取 或 设 置 类 的 静 态 变 量 调 用 类 的 静 态 方 法 32. // Class cls = InitClass.class; 33. // cls.newinstance(); 34. 35. // Field f = cls.getdeclaredfield("a"); 36. // f.get(null); 37. // f.set(null, "s"); 38. 39. // Method md = cls.getdeclaredmethod("method"); 40. // md.invoke(null, null); 41. 42. // 主 动 引 用 引 起 类 的 初 始 化 三 : 实 例 化 子 类, 引 起 父 类 初 始 化 43. // new SubInitClass(); 44. 45. } 46. } 上 面 的 程 序 演 示 了 主 动 引 用 触 发 类 的 初 始 化 的 四 种 情 况 类 的 初 始 化 过 程 是 这 样 的 : 按 照 顺 序 自 上 而 下 运 行 类 中 的 变 量 赋 值 语 句 和 静 态 语 句, 如 果 有 父 类, 则 首 先 按 照 顺 序 运 行 父 类 中 的 变 量 赋 值 语 句 和 静 态 语 句 先 看 一 个 例 子, 首 先 建 两 个 类 用 来 显 示 赋 值 操 作 : [java] view plainc opy 1. public class Field1{ 2. public Field1(){ 3. System.out.println("Field1 构 造 方 法 "); 4. } 5. } 6. public class Field2{ 7. public Field2(){ 8. System.out.println("Field2 构 造 方 法 "); 9. } 10. }

下 面 是 演 示 初 始 化 顺 序 的 代 码 : [java] view plainc opy 1. class InitClass2{ 2. static{ 3. System.out.println(" 运 行 父 类 静 态 代 码 "); 4. } 5. public static Field1 f1 = new Field1(); 6. public static Field1 f2; 7. } 8. 9. class SubInitClass2 extends InitClass2{ 10. static{ 11. System.out.println(" 运 行 子 类 静 态 代 码 "); 12. } 13. public static Field2 f2 = new Field2(); 14. } 15. 16. public class Test2 { 17. public static void main(string[] args) throws ClassNotFoundException{ 18. new SubInitClass2(); 19. } 20. } 上 面 的 代 码 中, 初 始 化 的 顺 序 是 : 第 03 行, 第 05 行, 第 11 行, 第 13 行 第 04 行 是 声 明 操 作, 没 有 赋 值, 所 以 不 会 被 运 行 而 下 面 的 代 码 : [java] view plainc opy 1. class InitClass2{ 2. public static Field1 f1 = new Field1(); 3. public static Field1 f2; 4. static{ 5. System.out.println(" 运 行 父 类 静 态 代 码 "); 6. } 7. } 8. 9. class SubInitClass2 extends InitClass2{ 10. public static Field2 f2 = new Field2(); 11. static{ 12. System.out.println(" 运 行 子 类 静 态 代 码 "); 13. } 14. } 15. 16. public class Test2 {

17. public static void main(string[] args) throws ClassNotFoundException{ 18. new SubInitClass2(); 19. } 20. } 初 始 化 顺 序 为 : 第 02 行 第 05 行 第 10 行 第 12 行, 各 位 可 以 运 行 程 序 查 看 结 果 在 类 的 初 始 化 阶 段, 只 会 初 始 化 与 类 相 关 的 静 态 赋 值 语 句 和 静 态 语 句, 也 就 是 有 static 关 键 字 修 饰 的 信 息, 而 没 有 static 修 饰 的 赋 值 语 句 和 执 行 语 句 在 实 例 化 对 象 的 时 候 才 会 运 行 使 用 类 的 使 用 包 括 主 动 引 用 和 被 动 引 用, 主 动 引 用 在 初 始 化 的 章 节 中 已 经 说 过 了, 下 面 我 们 主 要 来 说 一 下 被 动 引 用 : 引 用 父 类 的 静 态 字 段, 只 会 引 起 父 类 的 初 始 化, 而 不 会 引 起 子 类 的 初 始 化 定 义 类 数 组, 不 会 引 起 类 的 初 始 化 引 用 类 的 常 量, 不 会 引 起 类 的 初 始 化 被 动 引 用 的 示 例 代 码 : [java] view plainc opy 1. class InitClass{ 2. static { 3. System.out.println(" 初 始 化 InitClass"); 4. } 5. public static String a = null; 6. public final static String b = "b"; 7. public static void method(){} 8. } 9. 10. class SubInitClass extends InitClass{ 11. static { 12. System.out.println(" 初 始 化 SubInitClass"); 13. } 14. } 15. 16. public class Test4 { 17. 18. public static void main(string[] args) throws Exception{ 19. // String a = SubInitClass.a;// 引 用 父 类 的 静 态 字 段, 只 会 引 起 父 类 初 始 化, 而 不 会 引 起 子 类 的 初 始 化

20. // String b = InitClass.b;// 使 用 类 的 常 量 不 会 引 起 类 的 初 始 化 21. SubInitClass[] sc = new SubInitClass[10];// 定 义 类 数 组 不 会 引 起 类 的 初 始 化 22. } 23. } 最 后 总 结 一 下 使 用 阶 段 : 使 用 阶 段 包 括 主 动 引 用 和 被 动 引 用, 主 动 饮 用 会 引 起 类 的 初 始 化, 而 被 动 引 用 不 会 引 起 类 的 初 始 化 当 使 用 阶 段 完 成 之 后,java 类 就 进 入 了 卸 载 阶 段 卸 载 关 于 类 的 卸 载, 笔 者 在 单 例 模 式 讨 论 篇 : 单 例 模 式 与 垃 圾 回 收 一 文 中 有 过 描 述, 在 类 使 用 完 之 后, 如 果 满 足 下 面 的 情 况, 类 就 会 被 卸 载 : 该 类 所 有 的 实 例 都 已 经 被 回 收, 也 就 是 java 堆 中 不 存 在 该 类 的 任 何 实 例 加 载 该 类 的 ClassLoader 已 经 被 回 收 该 类 对 应 的 java.lang.class 对 象 没 有 任 何 地 方 被 引 用, 无 法 在 任 何 地 方 通 过 反 射 访 问 该 类 的 方 法 如 果 以 上 三 个 条 件 全 部 满 足,jvm 就 会 在 方 法 区 垃 圾 回 收 的 时 候 对 类 进 行 卸 载, 类 的 卸 载 过 程 其 实 就 是 在 方 法 区 中 清 空 类 信 息,java 类 的 整 个 生 命 周 期 就 结 束 了 总 结 做 java 的 朋 友 对 于 对 象 的 生 命 周 期 可 能 都 比 较 熟 悉, 对 象 基 本 上 都 是 在 jvm 的 堆 区 中 创 建, 在 创 建 对 象 之 前, 会 触 发 类 加 载 ( 加 载 连 接 初 始 化 ), 当 类 初 始 化 完 成 后, 根 据 类 信 息 在 堆 区 中 实 例 化 类 对 象, 初 始 化 非 静 态 变 量 非 静 态 代 码 以 及 默 认 构 造 方 法, 当 对 象 使 用 完 之 后 会 在 合 适 的 时 候 被 jvm 垃 圾 收 集 器 回 收 读 完 本 文 后 我 们 知 道, 对 象 的 生 命 周 期 只 是 类 的 生 命 周 期 中 使 用 阶 段 的 主 动 引 用 的 一 种 情 况 ( 即 实 例 化 类 对 象 ) 而 类 的 整 个 生 命 周 期 则 要 比 对 象 的 生 命 周 期 长 的 多 十 一 Java Web 的 生 命 周 期

JavaWeb 的 生 命 周 期 是 由 Servlet 容 器 来 控 制 的 总 的 来 说 分 为 三 个 阶 段 1. 启 动 阶 段 : 加 载 web 应 用 相 关 数 据, 创 建 ServletContext 对 象, 对 Filter 和 servlet 进 行 初 始 化 a. 把 web.xml 中 的 数 据 加 载 到 内 存 中 b. 为 JavaWeb 应 用 创 建 一 个 ServletContext 对 象 c. 对 所 有 的 Filter 进 行 初 始 化 d. 对 需 要 在 web 应 用 启 动 时 就 被 初 始 化 的 Servlet 进 行 初 始 化 2. 运 行 时 阶 段 : 为 客 户 提 供 服 务 a. 所 有 的 Servlet 都 处 于 待 命 状 态, 随 时 响 应 客 户 请 求, 提 供 服 务 b. 如 客 户 请 求 的 Servlet 还 不 存 在,Servlet 容 器 会 先 初 始 化 Servlet 再 调 用 它 的 service() 方 法 3. 终 止 阶 段 : 释 放 web 应 用 占 用 的 各 种 资 源 a. 销 毁 JavaWeb 中 所 有 处 于 运 行 状 态 的 Servlet b. 销 毁 JavaWeb 中 所 有 处 于 运 行 状 态 的 Filter c. 销 毁 所 有 与 JavaWeb 相 关 的 对 象 如 ServletContext, 并 释 放 资 源 Servlet 的 生 命 周 期 也 是 由 Servlet 容 器 来 控 制 也 分 为 三 个 阶 段 与 JavaWeb 相 同 1. 初 始 化 阶 段 ( 对 应 javax.servlet.servlet 接 口 中 的 init() 方 法 ) a.servlet 容 器 加 载 Servlet 类, 将 其.class 文 件 中 的 数 据 读 入 内 存 b.servlet 容 器 创 建 ServletConfig 对 象,ServletConfig 对 象 包 含 特 定 的 Servlet

的 初 始 化 配 置 信 息 同 时 Servlet 容 器 还 会 使 得 ServletConfig 对 象 与 当 前 Web 应 用 的 ServletContext 对 象 关 联 c.servlet 容 器 创 建 Servlet 对 象 d.servlet 容 器 调 用 Servlet 对 象 的 init(servletconfig config) 方 法 完 成 初 始 化 Servlet 对 象 只 要 通 过 getservletcontext() 方 法 就 能 得 到 当 前 Web 应 用 中 的 ServletContext 对 象 2. 运 行 阶 段 ( 对 应 Service() 方 法 ) a. 当 Servlet 容 器 接 收 到 要 求 访 问 特 定 的 Servlet 和 客 户 请 求 时 Servlet 容 器 会 创 建 针 对 这 个 请 求 的 ServletRequest 对 象 和 ServletResponse 对 象, 然 后 调 用 对 应 Servlet 的 service() 方 法 从 ServletRequest 对 象 中 得 到 客 户 请 求 信 息 并 处 理 该 请 求 再 通 过 ServletResponse 对 象 生 成 响 应 结 果 b. 当 Servlet 容 器 把 Servlet 生 成 的 响 应 结 果 发 送 给 客 户,Servlet 容 器 就 会 销 毁 ServletRequest 对 象 和 ServletResponse 对 象 3. 销 毁 阶 段 ( 对 应 destroy() 方 法 ) a. 当 Web 应 用 被 终 止 时,Servlet 容 器 会 调 用 当 前 Web 应 用 中 所 有 Servlet 对 象 的 destroy() 方 法, 然 后 再 销 毁 这 些 Servlet 对 象 b. 在 destroy() 方 法 中 会 释 放 Servlet 所 占 用 的 资 源 ( 关 闭 输 入 输 出 流, 数 据 库 连 接 等 ) c.servlet 容 器 销 毁 与 Servlet 对 象 关 联 的 ServletConfig 对 象

注 意 :Servlet 的 初 始 化 和 销 毁 只 会 发 生 一 次, 初 始 化 发 生 特 定 Servlet 在 首 次 被 客 户 端 访 问 销 毁 发 生 在 web 应 用 被 终 止 JSP 的 生 命 周 期 :JSP 的 生 命 周 期 与 Servlet 一 个 区 别 在 于,Servlet 容 器 必 须 先 将 Jsp 编 译 成 Servlet 类 然 后 再 运 行 它.JSP 生 命 周 期 如 下 : a. 解 析 阶 段 :Servlet 容 器 解 析 JSP 文 件 的 代 码 查 看 是 否 有 语 法 错 误 b. 翻 译 阶 段 :Servlet 容 器 把 JSP 文 件 翻 译 成 Servlet 源 文 件 (.java) c. 编 译 阶 段 :Servlet 容 器 翻 译 Servlet 源 文 件 生 成 Servlet 类 (.class) d. 初 始 化 阶 段 : 加 载 与 JSP 对 应 的 Servlet 尖, 创 建 其 实 例, 并 调 用 它 的 初 始 化 方 法 e. 运 行 时 阶 段 : 调 用 与 JSP 对 应 的 Servlet 实 例 的 服 务 方 法 f. 销 毁 阶 段 : 调 用 与 JSP 对 应 的 Servlet 实 例 的 销 毁 方 法, 然 后 销 毁 Servlet 实 例 注 意 : 在 JSP 的 生 命 周 期 中, 解 析, 翻 译, 编 译 是 JSP 特 有 的 阶 段, 仅 发 生 在 JSP 文 件 首 次 被 客 户 端 请 求 访 问,JSP 文 件 被 更 新, 与 JSP 文 件 相 对 应 的 Servlet 类 的 类 文 件 被 手 工 删 除 十 二 Tomcat 处 理 web 请 求 过 程 Tomcat 处 理 一 个 HTTP 请 求 的 过 程 假 设 来 自 客 户 的 请 求 为 : http://localhost:8080/wsota/wsota_index.jsp 1) 请 求 被 发 送 到 本 机 端 口 8080, 被 在 那 里 侦 听 的 Coyote HTTP/1.1 Connector 获 得 2) Connector 把 该 请 求 交 给 它 所 在 的 Service 的 Engine 来 处 理, 并 等 待 来 自 Engine 的 回 应

3) Engine 获 得 请 求 localhost/wsota/wsota_index.jsp, 匹 配 它 所 拥 有 的 所 有 虚 拟 主 机 Host 4) Engine 匹 配 到 名 为 localhost 的 Host( 即 使 匹 配 不 到 也 把 请 求 交 给 该 Host 处 理, 因 为 该 Host 被 定 义 为 该 Engine 的 默 认 主 机 ) 5) localhost Host 获 得 请 求 /wsota/wsota_index.jsp, 匹 配 它 所 拥 有 的 所 有 Context 6) Host 匹 配 到 路 径 为 /wsota 的 Context( 如 果 匹 配 不 到 就 把 该 请 求 交 给 路 径 名 为 "" 的 Context 去 处 理 ) 7) path="/wsota" 的 Context 获 得 请 求 /wsota_index.jsp, 在 它 的 mapping table 中 寻 找 对 应 的 servlet 8) Context 匹 配 到 URL PATTERN 为 *.jsp 的 servlet, 对 应 于 JspServlet 类 9) 构 造 HttpServletRequest 对 象 和 HttpServletResponse 对 象, 作 为 参 数 调 用 JspServlet 的 doget 或 dopost 方 法 10)Context 把 执 行 完 了 之 后 的 HttpServletResponse 对 象 返 回 给 Host 11)Host 把 HttpServletResponse 对 象 返 回 给 Engine 12)Engine 把 HttpServletResponse 对 象 返 回 给 Connector 13)Connector 把 HttpServletResponse 对 象 返 回 给 客 户 browser 十 三 Java 垃 圾 回 收 机 制 在 Java GC 中, 对 象 被 划 分 为 generations( 代 ) 或 spaces( 空 间 ) Java 把 对 象 分 为 young ( 年 轻 代 ),tenured( 年 老 代 ) 和 perm( 永 久 代 ) 在 GC 过 程 中, 对 象 从 一 个 space ( 空 间 ) 移 动 到 另 一 个 space Object Spaces( 对 象 空 间 ) Young: 年 轻 代 中 保 存 着 刚 创 建 的 对 象, 这 个 代 中 的 对 象 能 够 minor or major 收 集 中 被 回 收

Tenured: 年 老 代 中 保 存 着 从 年 轻 代 中 幸 存 下 来 的 对 象, 只 能 够 在 major 中 被 回 收 Perm: 永 久 代 中 保 存 着 JVM 所 需 的 对 象, 比 如 Class 对 象 和 Method 对 象, 以 及 他 们 的 字 节 码 和 内 部 字 符 串 等 对 Perm 中 的 对 象 GC 意 味 着 所 有 的 Class 都 被 卸 载 了 十 四 Java 性 能 优 化 1. 不 要 在 循 环 中 调 用 synchronized( 同 步 ) 方 法, 方 法 的 同 步 需 要 消 耗 相 当 大 的 资 料, 在 一 个 循 环 中 调 用 它 绝 对 不 是 一 个 好 主 意 2. 将 try/catch 块 移 出 循 环, 把 try/catch 块 放 入 循 环 体 内, 会 极 大 的 影 响 性 能, 如 果 编 译 jit 被 关 闭 或 者 你 所 使 用 的 是 一 个 不 带 jit 的 jvm, 性 能 会 将 下 降 21% 之 多! 3. 对 于 boolean 值, 避 免 不 必 要 的 等 式 判 断, 将 一 个 boolean 值 与 一 个 true 比 较 是 一 个 恒 等 操 作 ( 直 接 返 回 该 boolean 变 量 的 值 ). 移 走 对 于 boolean 的 不 必 要 操 作 至 少 会 带 来 2 个 好 处 : a) 代 码 执 行 的 更 快 ( 生 成 的 字 节 码 少 了 5 个 字 节 ); b) 代 码 也 会 更 加 干 净 4. 对 于 常 量 字 符 串, 用 'string' 代 替 'stringbuffer' 5. 确 定 stringbuffer 的 容 量, stringbuffer 的 构 造 器 会 创 建 一 个 默 认 大 小 ( 通 常 是 16) 的 字 符 数 组 在 使 用 中, 如 果 超 出 这 个 大 小, 就 会 重 新 分 配 内 存, 创 建 一 个 更 大 的 数 组, 并 将 原 先 的 数 组 复 制 过 来, 再 丢 弃 旧 的 数 组 在 大 多 数 情 况 下, 你 可 以 在 创 建 stringbuffer 的 时 候 指 定 大 小, 这 样 就 避 免 了 在 容 量 不 够 的 时 候 自 动 增 长, 以 提 高 性 能 6. StringBuffer,StringBuilder 的 区 别 在 于 :java.lang.stringbuffer 线 程 安 全 的 可 变 字 符 序 列 一 个 类 似 于 String 的 字 符 串 缓 冲 区, 但 不 能 修 改 StringBuilder 与 该 类 相 比, 通 常 应 该 优 先 使 用 StringBuilder 类, 因 为 她 支 持 所 有 相 同 的 操 作, 但

由 于 她 不 执 行 同 步, 所 以 速 度 更 快 为 了 获 得 更 好 的 性 能, 在 构 造 StringBuffer 或 StringBuilder 时 应 尽 量 指 定 她 的 容 量 当 然 如 果 不 超 过 16 个 字 符 时 就 不 用 了 相 同 情 况 下, 使 用 StringBuilder 比 使 用 StringBuffer 仅 能 获 得 10%~15% 的 性 能 提 升, 但 却 要 冒 多 线 程 不 安 全 的 风 险 综 合 考 虑 还 是 建 议 使 用 StringBuffer 7. 不 要 在 循 环 体 中 实 例 化 变 量 8. 尽 可 能 的 使 用 栈 变 量, 如 果 一 个 变 量 需 要 经 常 访 问, 那 么 你 就 需 要 考 虑 这 个 变 量 的 作 用 域 了 static? local? 还 是 实 例 变 量? 访 问 静 态 变 量 和 实 例 变 量 将 会 比 访 问 局 部 变 量 多 耗 费 2-3 个 时 钟 周 期 9. 不 要 总 是 使 用 取 反 操 作 符 (!), 取 反 操 作 符 (!) 降 低 程 序 的 可 读 性, 所 以 不 要 总 是 使 用 10. 与 一 个 接 口 进 行 instanceof 操 作, 基 于 接 口 的 设 计 通 常 是 件 好 事, 因 为 它 允 许 有 不 同 的 实 现, 而 又 保 持 灵 活 只 要 可 能, 对 一 个 对 象 进 行 instanceof 操 作, 以 判

断 它 是 否 某 一 接 口 要 比 是 否 某 一 个 类 要 快 11. 尽 量 使 用 final 修 饰 符 带 有 final 修 饰 符 的 类 是 不 可 派 生 的 在 JAVA 核 心 API 中, 有 许 多 应 用 final 的 例 子, 例 如 java.lang.string 为 String 类 指 定 final 防 止 了 使 用 者 覆 盖 length() 方 法 另 外, 如 果 一 个 类 是 final 的, 则 该 类 所 有 方 法 都 是 final 的 java 编 译 器 会 寻 找 机 会 内 联 (inline) 所 有 的 final 方 法 ( 这 和 具 体 的 编 译 器 实 现 有 关 ) 此 举 能 够 使 性 能 平 均 提 高 50% 12. 尽 量 重 用 对 象, 特 别 是 String 对 象 的 使 用 中, 出 现 字 符 串 连 接 情 况 时 应 使 用 StringBuffer 代 替, 由 于 系 统 不 仅 要 花 时 间 生 成 对 象, 以 后 可 能 还 需 要 花 时 间 对 这 些 对 象 进 行 垃 圾 回 收 和 处 理 因 此 生 成 过 多 的 对 象 将 会 给 程 序 的 性 能 带 来 很 大 的 影 响 13. 尽 量 使 用 局 部 变 量, 调 用 方 法 时 传 递 的 参 数 以 及 在 调 用 中 创 建 的 临 时 变 量 都 保 存 在 栈 (Stack) 中, 速 度 较 快 其 他 变 量, 如 静 态 变 量, 实 例 变 量 等, 都 在 堆 (Heap) 中 创 建, 速 度 较 慢 14. 不 要 重 复 初 始 化 变 量, 默 认 情 况 下, 调 用 类 的 构 造 函 数 时,java 会 把 变 量 初 始 化 成 确 定 的 值, 所 有 的 对 象 被 设 置 成 null, 整 数 变 量 设 置 成 0,float 和 double 变 量 设 置 成 0.0, 逻 辑 值 设 置 成 false 当 一 个 类 从 另 一 个 类 派 生 时, 这 一 点 尤 其 应 该 注 意, 因 为 用 new 关 键 字 创 建 一 个 对 象 时, 构 造 函 数 链 中 的 所 有 构 造 函 数 都 会 被

自 动 调 用 这 里 有 个 注 意, 给 成 员 变 量 设 置 初 始 值 但 需 要 调 用 其 他 方 法 的 时 候, 最 好 放 在 一 个 方 法 比 如 initxxx() 中, 因 为 直 接 调 用 某 方 法 赋 值 可 能 会 因 为 类 尚 未 初 始 化 而 抛 空 指 针 异 常,public int state = this.getstate(); 15. 在 java+oracle 的 应 用 系 统 开 发 中,java 中 内 嵌 的 SQL 语 言 应 尽 量 使 用 大 写 形 式, 以 减 少 Oracle 解 析 器 的 解 析 负 担 16..java 编 程 过 程 中, 进 行 数 据 库 连 接,I/O 流 操 作, 在 使 用 完 毕 后, 及 时 关 闭 以 释 放 资 源 因 为 对 这 些 大 对 象 的 操 作 会 造 成 系 统 大 的 开 销 17. 过 分 的 创 建 对 象 会 消 耗 系 统 的 大 量 内 存, 严 重 时, 会 导 致 内 存 泄 漏, 因 此, 保 证 过 期 的 对 象 的 及 时 回 收 具 有 重 要 意 义 JVM 的 GC 并 非 十 分 智 能, 因 此 建 议 在 对 象 使 用 完 毕 后, 手 动 设 置 成 null 18. 在 使 用 同 步 机 制 时, 应 尽 量 使 用 方 法 同 步 代 替 代 码 块 同 步 19. 尽 量 减 少 对 变 量 的 重 复 计 算 20. 采 用 在 需 要 的 时 候 才 开 始 创 建 的 策 略 21.. 慎 用 异 常, 异 常 对 性 能 不 利 抛 出 异 常 首 先 要 创 建 一 个 新 的 对 象 Throwable 接 口 的 构 造 函 数 调 用 名 为 fillinstacktrace() 的 本 地 方 法,fillInStackTrace() 方 法 检 查 栈, 收 集 调 用 跟 踪 信 息 只 要 有 异 常 被 抛 出,VM 就 必 须 调 整 调 用 栈, 因 为 在 处 理 过 程 中 创 建 了 一 个 新 的 对 象

异 常 只 能 用 于 错 误 处 理, 不 应 该 用 来 控 制 程 序 流 程 22.. 当 复 制 大 量 数 据 时, 使 用 System.arraycopy(); 23. 乘 除 法 如 果 可 以 使 用 位 移, 应 尽 量 使 用 位 移, 但 最 好 加 上 注 释, 因 为 位 移 操 作 不 直 观, 难 于 理 解. 24. 不 要 将 数 组 声 明 为 :public static final 25. array( 数 组 ) 和 ArrayList 的 使 用, array 数 组 效 率 最 高, 但 容 量 固 定, 无 法 动 态 改 变,ArrayList 容 量 可 以 动 态 增 长, 但 牺 牲 了 效 率 26. 单 线 程 应 尽 量 使 用 HashMap, ArrayList, 除 非 必 要, 否 则 不 推 荐 使 用 HashTable,Vector, 她 们 使 用 了 同 步 机 制, 而 降 低 了 性 能 27. 考 虑 使 用 静 态 方 法, 如 果 你 没 有 必 要 去 访 问 对 象 的 外 部, 那 么 就 使 你 的 方 法 成 为 静 态 方 法 她 会 被 更 快 地 调 用, 因 为 她 不 需 要 一 个 虚 拟 函 数 导 向 表 这 同 事 也 是 一 个 很 好 的 实 践, 因 为 她 告 诉 你 如 何 区 分 方 法 的 性 质, 调 用 这 个 方 法 不 会 改 变 对 象 的 状 态 28. 应 尽 可 能 避 免 使 用 内 在 的 GET,SET 方 法 android 编 程 中, 虚 方 法 的 调 用 会 产 生 很 多 代 价, 比 实 例 属 性 查 询 的 代 价 还 要 多 我 们 应 该 在 外 包 调 用 的 时 候 才 使 用 get,set 方 法, 但 在 内 部 调 用 的 时 候, 应 该 直 接 调 用 29. 避 免 枚 举, 浮 点 数 的 使 用 30. 二 维 数 组 比 一 维 数 组 占 用 更 多 的 内 存 空 间, 大 概 是 10 倍 计 算 31. 十 五 十 六

十 七 十 八 十 九 二 十 二 十 一