一. Java基础部分......................................................................................................2

目 录 1. Java 基 础 部 分... 10 1 一 个 ".java" 源 文 件 中 是 否 可 以 包 括 多 个 类 ( 不 是 内 部 类 )? 有 什 么 限 制?... 10 2 Java 有 没 有 goto?... 10 3 说 说 & 和 && 的 区 别... 10 4 在 JAVA 中 如 何 跳 出 当 前 的 多 重 嵌 套 循 环?... 11 5 switch 语 句 能 否 作 用 在 byte 上, 能 否 作 用 在 long 上, 能 否 作 用 在 String 上?. 11 6 short s1 = 1; s1 = s1 + 1; 有 什 么 错? short s1 = 1; s1 += 1; 有 什 么 错?... 12 7 char 型 变 量 中 能 不 能 存 贮 一 个 中 文 汉 字? 为 什 么?... 12 8 用 最 有 效 率 的 方 法 算 出 2 乘 以 8 等 于 几?... 12 9 请 设 计 一 个 一 百 亿 的 计 算 器... 12 10 使 用 final 关 键 字 修 饰 一 个 变 量 时, 是 引 用 不 能 变, 还 是 引 用 的 对 象 不 能 变? 14 11 "==" 和 equals 方 法 究 竟 有 什 么 区 别?... 14 12 静 态 变 量 和 实 例 变 量 的 区 别?... 15 13 是 否 可 以 从 一 个 static 方 法 内 部 发 出 对 非 static 方 法 的 调 用?... 16 14 Integer 与 int 的 区 别... 16 15 Math.round(11.5) 等 於 多 少? Math.round(-11.5) 等 於 多 少?... 17 16 下 面 的 代 码 有 什 么 不 妥 之 处?... 17 17 请 说 出 作 用 域 public,private,protected, 以 及 不 写 时 的 区 别... 17 18 Overload 和 Override 的 区 别 Overloaded 的 方 法 是 否 可 以 改 变 返 回 值 的 类 型?... 18 19 构 造 器 Constructor 是 否 可 被 override?... 19 20 接 口 是 否 可 继 承 接 口? 抽 象 类 是 否 可 实 现 (implements) 接 口? 抽 象 类 是 否 可 继 承 具 体 类 (concrete class)? 抽 象 类 中 是 否 可 以 有 静 态 的 main 方 法?... 19 21 写 clone() 方 法 时, 通 常 都 有 一 行 代 码, 是 什 么?... 19 22 面 向 对 象 的 特 征 有 哪 些 方 面... 19 23 java 中 实 现 多 态 的 机 制 是 什 么?... 21 24 abstract class 和 interface 有 什 么 区 别?... 21 25 abstract 的 method 是 否 可 同 时 是 static, 是 否 可 同 时 是 native, 是 否 可 同 时 是 synchronized?... 23 26 什 么 是 内 部 类?Static Nested Class 和 Inner Class 的 不 同... 24

27 内 部 类 可 以 引 用 它 的 包 含 类 的 成 员 吗? 有 没 有 什 么 限 制?... 26 28 Anonymous Inner Class ( 匿 名 内 部 类 ) 是 否 可 以 extends( 继 承 ) 其 它 类, 是 否 可 以 implements( 实 现 )interface( 接 口 )?... 27 29 super.getclass() 方 法 调 用... 27 30 String 是 最 基 本 的 数 据 类 型 吗?... 28 31 String s = "Hello";s = s + " world!"; 这 两 行 代 码 执 行 后, 原 始 的 String 对 象 中 的 内 容 到 底 变 了 没 有?... 28 32 是 否 可 以 继 承 String 类?... 29 33 String s = new String("xyz"); 创 建 了 几 个 String Object? 二 者 之 间 有 什 么 区 别?... 29 34 String 和 StringBuffer 的 区 别... 30 35 如 何 把 一 段 逗 号 分 割 的 字 符 串 转 换 成 一 个 数 组?... 30 36 数 组 有 没 有 length() 这 个 方 法? String 有 没 有 length() 这 个 方 法?... 31 37 下 面 这 条 语 句 一 共 创 建 了 多 少 个 对 象 :String s="a"+"b"+"c"+"d";... 31 38 try 里 有 一 个 return 语 句, 那 么 紧 跟 在 这 个 try 后 的 finally 里 的 code 会 不 会 被 执 行, 什 么 时 候 被 执 行, 在 return 前 还 是 后?... 31 39 下 面 的 程 序 代 码 输 出 的 结 果 是 多 少?... 32 40 final, finally, finalize 的 区 别... 35 41 运 行 时 异 常 与 一 般 异 常 有 何 异 同?... 35 42 error 和 exception 有 什 么 区 别?... 35 43 Java 中 的 异 常 处 理 机 制 的 简 单 原 理 和 应 用... 35 44 请 写 出 你 最 常 见 到 的 5 个 runtime exception... 36 45 JAVA 语 言 如 何 进 行 异 常 处 理, 关 键 字 :throws,throw,try,catch,finally 分 别 代 表 什 么 意 义? 在 try 块 中 可 以 抛 出 异 常 吗?... 36 46 java 中 有 几 种 方 法 可 以 实 现 一 个 线 程? 用 什 么 关 键 字 修 饰 同 步 方 法? stop() 和 suspend() 方 法 为 何 不 推 荐 使 用?... 36 47 sleep() 和 wait() 有 什 么 区 别?... 38 48 同 步 和 异 步 有 何 异 同, 在 什 么 情 况 下 分 别 使 用 他 们? 举 例 说 明... 41 49. 下 面 两 个 方 法 同 步 吗?( 自 己 发 明 )... 41 50 多 线 程 有 几 种 实 现 方 法? 同 步 有 几 种 实 现 方 法?... 42 51 启 动 一 个 线 程 是 用 run() 还 是 start()?.... 42 52 当 一 个 线 程 进 入 一 个 对 象 的 一 个 synchronized 方 法 后, 其 它 线 程 是 否 可 进 入 此 对 象 的 其 它 方 法?... 42

53 线 程 的 基 本 概 念 线 程 的 基 本 状 态 以 及 状 态 之 间 的 关 系... 43 54 简 述 synchronized 和 java.util.concurrent.locks.lock 的 异 同?... 43 55 设 计 4 个 线 程, 其 中 两 个 线 程 每 次 对 j 增 加 1, 另 外 两 个 线 程 对 j 每 次 减 少 1 写 出 程 序... 46 56 子 线 程 循 环 10 次, 接 着 主 线 程 循 环 100, 接 着 又 回 到 子 线 程 循 环 10 次, 接 着 再 回 到 主 线 程 又 循 环 100, 如 此 循 环 50 次, 请 写 出 程 序... 48 57 介 绍 Collection 框 架 的 结 构... 56 58 Collection 框 架 中 实 现 比 较 要 实 现 什 么 接 口... 56 59 ArrayList 和 Vector 的 区 别... 56 60 HashMap 和 Hashtable 的 区 别... 57 61 List 和 Map 区 别?... 57 62 List, Set, Map 是 否 继 承 自 Collection 接 口?... 58 63 List Map Set 三 个 接 口, 存 取 元 素 时, 各 有 什 么 特 点?... 58 64 说 出 ArrayList,Vector, LinkedList 的 存 储 性 能 和 特 性... 59 65 去 掉 一 个 Vector 集 合 中 重 复 的 元 素... 59 66 Collection 和 Collections 的 区 别... 59 67 Set 里 的 元 素 是 不 能 重 复 的, 那 么 用 什 么 方 法 来 区 分 重 复 与 否 呢? 是 用 == 还 是 equals()? 它 们 有 何 区 别?... 60 68 你 所 知 道 的 集 合 类 都 有 哪 些? 主 要 方 法?... 60 69 两 个 对 象 值 相 同 (x.equals(y) == true), 但 却 可 有 不 同 的 hash code, 这 句 话 对 不 对?... 61 70 TreeSet 里 面 放 对 象, 如 果 同 时 放 入 了 父 类 和 子 类 的 实 例 对 象, 那 比 较 时 使 用 的 是 父 类 的 compareto 方 法, 还 是 使 用 的 子 类 的 compareto 方 法, 还 是 抛 异 常!. 61 71 说 出 一 些 常 用 的 类, 包, 接 口, 请 各 举 5 个... 63 72 java 中 有 几 种 类 型 的 流?JDK 为 每 种 类 型 的 流 提 供 了 一 些 抽 象 类 以 供 继 承, 请 说 出 他 们 分 别 是 哪 些 类?... 63 73 字 节 流 与 字 符 流 的 区 别... 63 74 什 么 是 java 序 列 化, 如 何 实 现 java 序 列 化? 或 者 请 解 释 Serializable 接 口 的 作 用... 65 75 描 述 一 下 JVM 加 载 class 文 件 的 原 理 机 制?... 66 76 heap 和 stack 有 什 么 区 别... 66 77 GC 是 什 么? 为 什 么 要 有 GC?... 66 78 垃 圾 回 收 的 优 点 和 原 理 并 考 虑 2 种 回 收 机 制... 66

79 垃 圾 回 收 器 的 基 本 原 理 是 什 么? 垃 圾 回 收 器 可 以 马 上 回 收 内 存 吗? 有 什 么 办 法 主 动 通 知 虚 拟 机 进 行 垃 圾 回 收?... 66 80 什 么 时 候 用 assert... 67 81 java 中 会 存 在 内 存 泄 漏 吗, 请 简 单 描 述... 68 82 能 不 能 自 己 写 个 类, 也 叫 java.lang.string?... 72 83. Java 代 码 查 错... 73 二. 算 法 与 编 程... 77 1 编 写 一 个 程 序, 将 a.txt 文 件 中 的 单 词 与 b.txt 文 件 中 的 单 词 交 替 合 并 到 c.txt 文 件 中,a.txt 文 件 中 的 单 词 用 回 车 符 分 隔,b.txt 文 件 中 用 回 车 或 空 格 进 行 分 隔... 77 2 编 写 一 个 程 序, 将 d:\java 目 录 下 的 所 有.java 文 件 复 制 到 d:\jad 目 录 下, 并 将 原 来 文 件 的 扩 展 名 从.java 改 为.jad... 79 3 编 写 一 个 截 取 字 符 串 的 函 数, 输 入 为 一 个 字 符 串 和 字 节 数, 输 出 为 按 字 节 截 取 的 字 符 串, 但 要 保 证 汉 字 不 被 截 取 半 个, 如 我 ABC,4, 应 该 截 取 我 AB, 输 入 我 ABC 汉 DEF,6, 应 该 输 出 我 ABC, 而 不 是 我 ABC+ 汉 的 半 个... 82 4 有 一 个 字 符 串, 其 中 包 含 中 文 字 符 英 文 字 符 和 数 字 字 符, 请 统 计 和 打 印 出 各 个 字 符 的 个 数... 83 5 说 明 生 活 中 遇 到 的 二 叉 树, 用 java 实 现 二 叉 树... 84 6 从 类 似 如 下 的 文 本 文 件 中 读 取 出 所 有 的 姓 名, 并 打 印 出 重 复 的 姓 名 和 重 复 的 次 数, 并 按 重 复 次 数 排 序 :... 91 7 写 一 个 Singleton 出 来... 96 8 递 归 算 法 题 1... 99 9 递 归 算 法 题 2... 100 10 排 序 都 有 哪 几 种 方 法? 请 列 举 用 JAVA 实 现 一 个 快 速 排 序... 100 11 有 数 组 a[n], 用 java 代 码 将 数 组 元 素 顺 序 颠 倒... 102 12. 金 额 转 换, 阿 拉 伯 数 字 的 金 额 转 换 成 中 国 传 统 的 形 式 如 :( 1011)->( 一 千 零 一 拾 一 元 整 ) 输 出... 103 三. html&javascript&ajax 部 分... 104 1. 判 断 第 二 个 日 期 比 第 一 个 日 期 大... 104 2. 用 table 显 示 n 条 记 录, 每 3 行 换 一 次 颜 色, 即 1,2,3 用 红 色 字 体,4,5,6 用 绿 色 字 体,7,8,9 用 红 颜 色 字 体... 106 3 HTML 的 form 提 交 之 前 如 何 验 证 数 值 文 本 框 的 内 容 全 部 为 数 字? 否 则 的 话 提 示 用 户 并 终 止 提 交?... 107 4 请 写 出 用 于 校 验 HTML 文 本 框 中 输 入 的 内 容 全 部 为 数 字 的 javascript 代 码... 107 5 说 说 你 用 过 那 些 ajax 技 术 和 框 架, 说 说 它 们 的 区 别... 108

四. Java web 部 分... 108 1 Tomcat 的 优 化 经 验... 108 2 HTTP 请 求 的 GET 与 POST 方 式 的 区 别... 108 3 解 释 一 下 什 么 是 servlet;... 108 4 说 一 说 Servlet 的 生 命 周 期?... 109 5 Servlet 的 基 本 架 构... 109 6 SERVLET API 中 forward() 与 redirect() 的 区 别?... 109 7 什 么 情 况 下 调 用 doget() 和 dopost()?... 109 8 Request 对 象 的 主 要 方 法 :... 110 9 forward 和 redirect 的 区 别... 110 10 request.getattribute() 和 request.getparameter() 有 何 区 别?... 111 11. jsp 有 哪 些 内 置 对 象? 作 用 分 别 是 什 么? 分 别 有 什 么 方 法?... 111 12. jsp 有 哪 些 动 作? 作 用 分 别 是 什 么?... 112 13 JSP 的 常 用 指 令... 112 14. JSP 中 动 态 INCLUDE 与 静 态 INCLUDE 的 区 别?... 112 15 两 种 跳 转 方 式 分 别 是 什 么? 有 什 么 区 别?... 113 16 页 面 间 对 象 传 递 的 方 法... 113 17 JSP 和 Servlet 有 哪 些 相 同 点 和 不 同 点, 他 们 之 间 的 联 系 是 什 么?... 113 18 MVC 的 各 个 部 分 都 有 那 些 技 术 来 实 现? 如 何 实 现?... 113 19 我 们 在 web 应 用 开 发 过 程 中 经 常 遇 到 输 出 某 种 编 码 的 字 符, 如 iso8859-1 等, 如 何 输 出 一 个 某 种 编 码 的 字 符 串?... 113 20 现 在 输 入 n 个 数 字, 以 逗 号, 分 开 ; 然 后 可 选 择 升 或 者 降 序 排 序 ; 按 提 交 键 就 在 另 一 页 面 显 示 按 什 么 排 序, 结 果 为, 提 供 reset... 114 五. 数 据 库 部 分... 114 1 用 两 种 方 式 根 据 部 门 号 从 高 到 低, 工 资 从 低 到 高 列 出 每 个 员 工 的 信 息... 114 2 列 出 各 个 部 门 中 工 资 高 于 本 部 门 的 平 均 工 资 的 员 工 数 和 部 门 号, 并 按 部 门 号 排 序... 114 3 存 储 过 程 与 触 发 器 必 须 讲, 经 常 被 面 试 到?... 116 4 数 据 库 三 范 式 是 什 么?... 118 5 说 出 一 些 数 据 库 优 化 方 面 的 经 验?... 119 6 union 和 union all 有 什 么 不 同?... 121 7. 分 页 语 句... 122

8. 用 一 条 SQL 语 句 查 询 出 每 门 课 都 大 于 80 分 的 学 生 姓 名... 126 9. 所 有 部 门 之 间 的 比 赛 组 合... 127 10. 每 个 月 份 的 发 生 额 都 比 101 科 目 多 的 科 目... 127 11. 统 计 每 年 每 月 的 信 息... 129 12. 显 示 文 章 标 题, 发 帖 人 最 后 回 复 时 间... 131 13. 删 除 除 了 id 号 不 同, 其 他 都 相 同 的 学 生 冗 余 信 息... 131 14. 航 空 网 的 几 个 航 班 查 询 题 :... 132 15. 查 出 比 经 理 薪 水 还 高 的 员 工 信 息 :... 134 16 求 出 小 于 45 岁 的 各 个 老 师 所 带 的 大 于 12 岁 的 学 生 人 数... 135 17. 求 出 发 帖 最 多 的 人 :... 136 18 一 个 用 户 表 中 有 一 个 积 分 字 段, 假 如 数 据 库 中 有 100 多 万 个 用 户, 若 要 在 每 年 第 一 天 凌 晨 将 积 分 清 零, 你 将 考 虑 什 么, 你 将 想 什 么 办 法 解 决?... 136 19 一 个 用 户 具 有 多 个 角 色, 请 查 询 出 该 表 中 具 有 该 用 户 的 所 有 角 色 的 其 他 用 户... 137 20. xxx 公 司 的 sql 面 试... 138 21 注 册 Jdbc 驱 动 程 序 的 三 种 方 式... 139 22 用 JDBC 如 何 调 用 存 储 过 程... 139 23 JDBC 中 的 PreparedStatement 相 比 Statement 的 好 处... 141 24. 写 一 个 用 jdbc 连 接 并 访 问 oracle 数 据 的 程 序 代 码... 141 25 Class.forName 的 作 用? 为 什 么 要 用?... 141 26 大 数 据 量 下 的 分 页 解 决 方 法... 141 27 用 JDBC 查 询 学 生 成 绩 单, 把 主 要 代 码 写 出 来 ( 考 试 概 率 极 大 ).... 142 28 这 段 代 码 有 什 么 不 足 之 处?... 143 29 说 出 数 据 连 接 池 的 工 作 机 制 是 什 么?... 143 30 为 什 么 要 用 ORM? 和 JDBC 有 何 不 一 样?... 144 六. XML 部 分... 144 1 xml 有 哪 些 解 析 技 术? 区 别 是 什 么?... 144 2 你 在 项 目 中 用 到 了 xml 技 术 的 哪 些 方 面? 如 何 实 现 的?... 144 3 用 jdom 解 析 xml 文 件 时 如 何 解 决 中 文 问 题? 如 何 解 析?... 144 4 编 程 用 JAVA 解 析 XML 的 方 式... 145 5 XML 文 档 定 义 有 几 种 形 式? 它 们 之 间 有 何 本 质 区 别? 解 析 XML 文 档 有 哪 几 种 方 式?... 148

七. 流 行 的 框 架 与 新 技 术... 148 1 谈 谈 你 对 Struts 的 理 解... 149 2 谈 谈 你 对 Hibernate 的 理 解... 149 3 AOP 的 作 用... 150 4 你 对 Spring 的 理 解... 150 5 谈 谈 Struts 中 的 Action servlet... 151 6 Struts 优 缺 点 优 点 : 1. 实 现 MVC 模 式, 结 构 清 晰, 使 开 发 者 只 关 注 业 务 逻 辑 的 实 现... 151 7 STRUTS 的 应 用 ( 如 STRUTS 架 构 )... 153 8 说 说 struts1 与 struts2 的 区 别... 153 9 hibernate 中 的 update() 和 saveorupdate() 的 区 别,session 的 load() 和 get() 的 区 别... 154 10 简 述 Hibernate 和 JDBC 的 优 缺 点? 如 何 书 写 一 个 one to many 配 置 文 件.. 154 11 ibatis 与 Hibernate 有 什 么 不 同?... 154 12 写 Hibernate 的 一 对 多 和 多 对 一 双 向 关 联 的 orm 配 置?... 154 12.1 hibernate 的 inverse 属 性 的 作 用?... 154 13 在 DAO 中 如 何 体 现 DAO 设 计 模 式?... 155 14 spring+hibernate 中 委 托 方 案 怎 么 配 置?... 155 15 spring+hibernate 中 委 托 方 案 怎 么 配 置?... 155 16. hibernate 进 行 多 表 查 询 每 个 表 中 各 取 几 个 字 段, 也 就 是 说 查 询 出 来 的 结 果 集 没 有 一 个 实 体 类 与 之 对 应 如 何 解 决 ;... 155 17. 介 绍 一 下 Hibernate 的 二 级 缓 存... 155 18 Spring 的 依 赖 注 入 是 什 么 意 思? 给 一 个 Bean 的 message 属 性, 字 符 串 类 型, 注 入 值 为 "Hello" 的 XML 配 置 文 件 该 怎 么 写?... 158 19 Jdo 是 什 么?... 158 20 什 么 是 spring 的 IOC AOP... 158 21 STRUTS 的 工 作 流 程!... 158 22 spring 与 EJB 的 区 别!!... 158 八. 软 件 工 程 与 设 计 模 式... 158 1 UML 方 面... 158 2 j2ee 常 用 的 设 计 模 式? 说 明 工 厂 模 式... 158 3 开 发 中 都 用 到 了 那 些 设 计 模 式? 用 在 什 么 场 合?... 159 九. j2ee 部 分... 159

1 BS 与 CS 的 联 系 与 区 别... 159 1. 硬 件 环 境 不 同 :... 159 2. 对 安 全 要 求 不 同... 160 3. 对 程 序 架 构 不 同... 160 4. 软 件 重 用 不 同... 160 5. 系 统 维 护 不 同... 160 6. 处 理 问 题 不 同... 160 7. 用 户 接 口 不 同... 160 2 应 用 服 务 器 与 WEB SERVER 的 区 别?... 161 3 应 用 服 务 器 有 那 些?... 161 4 J2EE 是 什 么?... 161 5 J2EE 是 技 术 还 是 平 台 还 是 框 架? 什 么 是 J2EE... 161 6 请 对 以 下 在 J2EE 中 常 用 的 名 词 进 行 解 释 ( 或 简 单 描 述 )... 161 7 如 何 给 weblogic 指 定 大 小 的 内 存?... 162 8 如 何 设 定 的 weblogic 的 热 启 动 模 式 ( 开 发 模 式 ) 与 产 品 发 布 模 式?... 162 9 如 何 启 动 时 不 需 输 入 用 户 名 与 密 码?... 162 10 在 weblogic 管 理 制 台 中 对 一 个 应 用 域 ( 或 者 说 是 一 个 网 站,Domain) 进 行 jms 及 ejb 或 连 接 池 等 相 关 信 息 进 行 配 置 后, 实 际 保 存 在 什 么 文 件 中?... 162 11 说 说 weblogic 中 一 个 Domain 的 缺 省 目 录 结 构? 比 如 要 将 一 个 简 单 的 helloworld.jsp 放 入 何 目 录 下, 然 的 在 浏 览 器 上 就 可 打 入 http:// 主 机 : 端 口 号 //helloword.jsp 就 可 以 看 到 运 行 结 果 了? 又 比 如 这 其 中 用 到 了 一 个 自 己 写 的 javabean 该 如 何 办?... 162 12 在 weblogic 中 发 布 ejb 需 涉 及 到 哪 些 配 置 文 件... 163 13 如 何 在 weblogic 中 进 行 ssl 配 置 与 客 户 端 的 认 证 配 置 或 说 说 j2ee( 标 准 ) 进 行 ssl 的 配 置?... 163 14 如 何 查 看 在 weblogic 中 已 经 发 布 的 EJB?... 163 十. EJB 部 分... 163 1 EJB 是 基 于 哪 些 技 术 实 现 的? 并 说 出 SessionBean 和 EntityBean 的 区 别, StatefulBean 和 StatelessBean 的 区 别... 163 2 简 要 讲 一 下 EJB 的 7 个 Transaction Level?... 164 3 EJB 与 JAVA BEAN 的 区 别?... 164 4 EJB 包 括 (SessionBean,EntityBean) 说 出 他 们 的 生 命 周 期, 及 如 何 管 理 事 务 的?... 164

5 EJB 容 器 提 供 的 服 务... 164 6 EJB 的 激 活 机 制... 164 7 EJB 的 几 种 类 型... 165 8 客 服 端 调 用 EJB 对 象 的 几 个 基 本 步 骤... 165 十 一. webservice 部 分... 165 1 WEB SERVICE 名 词 解 释 JSWDL 开 发 包 的 介 绍 JAXP JAXM 的 解 释 SOAP UDDI,WSDL 解 释... 165 2 CORBA 是 什 么? 用 途 是 什 么?... 165 3. Linux... 166 4 LINUX 下 线 程,GDI 类 的 解 释... 166 5. 问 得 稀 里 糊 涂 的 题... 166 6 四 种 会 话 跟 踪 技 术... 166 7 简 述 逻 辑 操 作 (&,,^) 与 条 件 操 作 (&&, ) 的 区 别... 166 十 二. 其 他... 166 1 请 用 英 文 简 单 介 绍 一 下 自 己... 166 2 请 把 http://tomcat.apache.org/ 首 页 的 这 一 段 话 用 中 文 翻 译 一 下?... 166 3 美 资 软 件 公 司 JAVA 工 程 师 电 话 面 试 题 目... 167

这 套 面 试 题 主 要 目 的 是 帮 助 那 些 还 没 有 java 软 件 开 发 实 际 工 作 经 验, 而 正 在 努 力 寻 找 java 软 件 开 发 工 作 的 朋 友 在 笔 试 时 更 好 地 赢 得 笔 试 和 面 试 由 于 这 套 面 试 题 涉 及 的 范 围 很 泛, 很 广, 很 杂, 大 家 不 可 能 一 天 两 天 就 看 完 和 学 完 这 套 面 试 宝 典, 即 使 你 已 经 学 过 了 有 关 的 技 术, 那 么 至 少 也 需 要 一 个 月 的 时 间 才 能 消 化 和 掌 握 这 套 面 试 宝 典, 所 以, 大 家 应 该 早 作 准 备, 从 拿 到 这 套 面 试 宝 典 之 日 起, 就 要 坚 持 在 每 天 闲 暇 之 余 学 习 其 中 几 道 题 目, 日 积 月 累, 等 到 出 去 面 试 时, 一 切 都 水 到 渠 成, 面 试 时 就 自 然 会 游 刃 有 余 了 答 题 时, 先 答 是 什 么, 再 答 有 什 么 作 用 和 要 注 意 什 么 ( 这 部 分 最 重 要, 展 现 自 己 的 心 得 ) 答 案 的 段 落 分 别, 层 次 分 明, 条 理 清 晰 都 非 常 重 要, 从 这 些 表 面 的 东 西 也 可 以 看 出 一 个 人 的 习 惯 办 事 风 格 条 理 等 要 讲 你 做 出 答 案 的 思 路 过 程, 或 者 说 你 记 住 答 案 的 思 想 都 写 下 来 把 答 题 想 着 是 辩 论 赛 答 题 就 是 给 别 人 讲 道 理 摆 事 实 答 题 不 局 限 于 什 么 格 式 和 形 式, 就 是 要 将 自 己 的 学 识 展 现 出 来! 别 因 为 人 家 题 目 本 来 就 模 棱 两 可, 你 就 心 里 胆 怯 和 没 底 气 了, 不 敢 回 答 了 你 要 大 胆 地 指 出 对 方 题 目 很 模 糊 和 你 的 观 点, 不 要 把 面 试 官 想 得 有 多 高, 其 实 他 和 你 就 是 差 不 多 的, 你 想 想, 如 果 他 把 你 招 进 去 了, 你 们 以 后 就 是 同 事 了, 可 不 是 差 不 多 的 吗? 关 于 就 业 薪 水, 如 果 你 是 应 届 生, 那 不 能 要 高 工 资, 好 比 大 饼 的 故 事, 没 有 文 凭 还 想 拿 高 工 资, 就 去 中 关 村 缺 什 么 补 什 么 吧! 少 数 人 基 础 确 实 很 好, 在 校 期 间 确 实 又 做 过 一 些 项 目, 那 仍 然 是 可 以 要 到 相 对 高 的 工 资 的 1. Java 基 础 部 分 基 础 部 分 的 顺 序 : 基 本 语 法, 类 相 关 的 语 法, 内 部 类 的 语 法, 继 承 相 关 的 语 法, 异 常 的 语 法, 线 程 的 语 法, 集 合 的 语 法,io 的 语 法, 虚 拟 机 方 面 的 语 法 1 一 个 ".java" 源 文 件 中 是 否 可 以 包 括 多 个 类 ( 不 是 内 部 类 )? 有 什 么 限 制? 可 以 有 多 个 类, 但 只 能 有 一 个 public 的 类, 并 且 public 的 类 名 必 须 与 文 件 名 相 一 致 2 Java 有 没 有 goto? java 中 的 保 留 字, 现 在 没 有 在 java 中 使 用 3 说 说 & 和 && 的 区 别 & 和 && 都 可 以 用 作 逻 辑 与 的 运 算 符, 表 示 逻 辑 与 (and), 当 运 算 符 两 边 的 表 达 式 的 结 果 都 为 true 时, 整 个 运 算 结 果 才 为 true, 否 则, 只 要 有 一 方 为 false, 则 结 果 为 false && 还 具 有 短 路 的 功 能, 即 如 果 第 一 个 表 达 式 为 false, 则 不 再 计 算 第 二 个 表 达 式, 例 如, 对 于 if(str!= null&&!str.equals( )) 表 达 式, 当 str 为 null 时, 后 面 的 表 达 式 不 会 执 行, 所 以 不 会 出 现 NullPointerException 如 果 将 && 改 为 &, 则 会 抛 出 NullPointerException 异 常 If(x==33 &++y>0) y 会 增 长,If(x==33 && ++y>0) 不 会 增 长 & 还 可 以 用 作 位 运 算 符, 当 & 操 作 符 两 边 的 表 达 式 不 是 boolean 类 型 时,& 表 示 按 位 与 操 作,

我 们 通 常 使 用 0x0f 来 与 一 个 整 数 进 行 & 运 算, 来 获 取 该 整 数 的 最 低 4 个 bit 位, 例 如,0x31 & 0x0f 的 结 果 为 0x01 备 注 : 这 道 题 先 说 两 者 的 共 同 点, 再 说 出 && 和 & 的 特 殊 之 处, 并 列 举 一 些 经 典 的 例 子 来 表 明 自 己 理 解 透 彻 深 入 实 际 经 验 丰 富 4 在 JAVA 中 如 何 跳 出 当 前 的 多 重 嵌 套 循 环? 在 Java 中, 要 想 跳 出 多 重 循 环, 可 以 在 外 面 的 循 环 语 句 前 定 义 一 个 标 号, 然 后 在 里 层 循 环 体 的 代 码 中 使 用 带 有 标 号 的 break 语 句, 即 可 跳 出 外 层 循 环 例 如, ok: for(int i=0;i<10;i++) for(int j=0;j<10;j++) System.out.println( i= + i +,j= + j); if(j == 5) break ok; 另 外, 我 个 人 通 常 并 不 使 用 标 号 这 种 方 式, 而 是 让 外 层 的 循 环 条 件 表 达 式 的 结 果 可 以 受 到 里 层 循 环 体 代 码 的 控 制, 例 如, 要 在 二 维 数 组 中 查 找 到 某 个 数 字 int arr[][] =1,2,3,4,5,6,7,9; boolean found = false; for(int i=0;i<arr.length&&!found;i++) for(int j=0;j<arr[i].length;j++) System.out.println( i= + i +,j= + j); if(arr[i][j] ==5) found = true; break; 5 switch 语 句 能 否 作 用 在 byte 上, 能 否 作 用 在 long 上, 能 否 作 用 在 String 上? 在 switch(expr1) 中,expr1 只 能 是 一 个 整 数 表 达 式 或 者 枚 举 常 量 ( 更 大 字 体 ), 整 数 表 达 式 可 以 是 int 基 本 类 型 或 Integer 包 装 类 型, 由 于,byte,short,char 都 可 以 隐 含 转 换 为 int,

所 以, 这 些 类 型 以 及 这 些 类 型 的 包 装 类 型 也 是 可 以 的 显 然,long 和 String 类 型 都 不 符 合 switch 的 语 法 规 定, 并 且 不 能 被 隐 式 转 换 成 int 类 型, 所 以, 它 们 不 能 作 用 于 swtich 语 句 中 6 short s1 = 1; s1 = s1 + 1; 有 什 么 错? short s1 = 1; s1 += 1; 有 什 么 错? 对 于 short s1 = 1; s1 = s1 + 1; 由 于 s1+1 运 算 时 会 自 动 提 升 表 达 式 的 类 型, 所 以 结 果 是 int 型, 再 赋 值 给 short 类 型 s1 时, 编 译 器 将 报 告 需 要 强 制 转 换 类 型 的 错 误 对 于 short s1 = 1; s1 += 1; 由 于 += 是 java 语 言 规 定 的 运 算 符,java 编 译 器 会 对 它 进 行 特 殊 处 理, 因 此 可 以 正 确 编 译 7 char 型 变 量 中 能 不 能 存 贮 一 个 中 文 汉 字? 为 什 么? char 型 变 量 是 用 来 存 储 Unicode 编 码 的 字 符 的,unicode 编 码 字 符 集 中 包 含 了 汉 字, 所 以, char 型 变 量 中 当 然 可 以 存 储 汉 字 啦 不 过, 如 果 某 个 特 殊 的 汉 字 没 有 被 包 含 在 unicode 编 码 字 符 集 中, 那 么, 这 个 char 型 变 量 中 就 不 能 存 储 这 个 特 殊 汉 字 补 充 说 明 :unicode 编 码 占 用 两 个 字 节, 所 以,char 类 型 的 变 量 也 是 占 用 两 个 字 节 备 注 : 后 面 一 部 分 回 答 虽 然 不 是 在 正 面 回 答 题 目, 但 是, 为 了 展 现 自 己 的 学 识 和 表 现 自 己 对 问 题 理 解 的 透 彻 深 入, 可 以 回 答 一 些 相 关 的 知 识, 做 到 知 无 不 言, 言 无 不 尽 8 用 最 有 效 率 的 方 法 算 出 2 乘 以 8 等 于 几? 2 << 3, 因 为 将 一 个 数 左 移 n 位, 就 相 当 于 乘 以 了 2 的 n 次 方, 那 么, 一 个 数 乘 以 8 只 要 将 其 左 移 3 位 即 可, 而 位 运 算 cpu 直 接 支 持 的, 效 率 最 高, 所 以,2 乘 以 8 等 於 几 的 最 效 率 的 方 法 是 2 << 3 9 请 设 计 一 个 一 百 亿 的 计 算 器 首 先 要 明 白 这 道 题 目 的 考 查 点 是 什 么, 一 是 大 家 首 先 要 对 计 算 机 原 理 的 底 层 细 节 要 清 楚 要 知 道 加 减 法 的 位 运 算 原 理 和 知 道 计 算 机 中 的 算 术 运 算 会 发 生 越 界 的 情 况, 二 是 要 具 备 一 定 的 面 向 对 象 的 设 计 思 想 首 先, 计 算 机 中 用 固 定 数 量 的 几 个 字 节 来 存 储 的 数 值, 所 以 计 算 机 中 能 够 表 示 的 数 值 是 有 一 定 的 范 围 的, 为 了 便 于 讲 解 和 理 解, 我 们 先 以 byte 类 型 的 整 数 为 例, 它 用 1 个 字 节 进 行 存 储, 表 示 的 最 大 数 值 范 围 为 -128 到 +127-1 在 内 存 中 对 应 的 二 进 制 数 据 为 11111111, 如 果 两 个 -1 相 加, 不 考 虑 Java 运 算 时 的 类 型 提 升, 运 算 后 会 产 生 进 位, 二 进 制 结 果 为 1,11111110, 由 于 进 位 后 超 过 了 byte 类 型 的 存 储 空 间, 所 以 进 位 部 分 被 舍 弃, 即 最 终 的 结 果 为 11111110, 也 就 是 -2, 这 正 好 利 用 溢 位 的 方 式 实 现 了 负 数 的 运 算 -128 在 内 存 中 对 应 的 二 进 制 数 据 为 10000000, 如 果 两 个 -128 相 加, 不 考 虑 Java 运 算 时 的 类 型 提 升, 运 算 后 会 产 生 进 位, 二 进 制 结 果 为 1,00000000, 由 于 进 位 后 超 过 了 byte 类 型 的 存 储 空 间, 所 以 进 位 部 分 被 舍 弃, 即 最 终 的 结 果 为 00000000, 也 就 是 0, 这 样 的 结 果 显 然 不 是 我 们 期 望 的, 这 说 明 计 算 机 中 的 算 术 运 算 是 会 发 生 越 界 情 况 的, 两 个 数 值 的 运 算 结 果 不 能 超 过 计 算 机 中 的 该 类 型 的 数 值 范

围 由 于 Java 中 涉 及 表 达 式 运 算 时 的 类 型 自 动 提 升, 我 们 无 法 用 byte 类 型 来 做 演 示 这 种 问 题 和 现 象 的 实 验, 大 家 可 以 用 下 面 一 个 使 用 整 数 做 实 验 的 例 子 程 序 体 验 一 下 : int a = Integer.MAX_VALUE; int b = Integer.MAX_VALUE; int sum = a + b; System.out.println( a= +a+,b= +b+,sum= +sum); 先 不 考 虑 long 类 型, 由 于 int 的 正 数 范 围 为 2 的 31 次 方, 表 示 的 最 大 数 值 约 等 于 2*1000*1000*1000, 也 就 是 20 亿 的 大 小, 所 以, 要 实 现 一 个 一 百 亿 的 计 算 器, 我 们 得 自 己 设 计 一 个 类 可 以 用 于 表 示 很 大 的 整 数, 并 且 提 供 了 与 另 外 一 个 整 数 进 行 加 减 乘 除 的 功 能, 大 概 功 能 如 下 : (1) 这 个 类 内 部 有 两 个 成 员 变 量, 一 个 表 示 符 号, 另 一 个 用 字 节 数 组 表 示 数 值 的 二 进 制 数 (2) 有 一 个 构 造 方 法, 把 一 个 包 含 有 多 位 数 值 的 字 符 串 转 换 到 内 部 的 符 号 和 字 节 数 组 中 (3) 提 供 加 减 乘 除 的 功 能 public class BigInteger int sign; byte[] val; public Biginteger(String val) sign = ; val = ; public BigInteger add(biginteger other) public BigInteger subtract(biginteger other) public BigInteger multiply(biginteger other) public BigInteger divide(biginteger other)

备 注 : 要 想 写 出 这 个 类 的 完 整 代 码, 是 非 常 复 杂 的, 如 果 有 兴 趣 的 话, 可 以 参 看 jdk 中 自 带 的 java.math.biginteger 类 的 源 码 面 试 的 人 也 知 道 谁 都 不 可 能 在 短 时 间 内 写 出 这 个 类 的 完 整 代 码 的, 他 要 的 是 你 是 否 有 这 方 面 的 概 念 和 意 识, 他 最 重 要 的 还 是 考 查 你 的 能 力, 所 以, 你 不 要 因 为 自 己 无 法 写 出 完 整 的 最 终 结 果 就 放 弃 答 这 道 题, 你 要 做 的 就 是 你 比 别 人 写 得 多, 证 明 你 比 别 人 强, 你 有 这 方 面 的 思 想 意 识 就 可 以 了, 毕 竟 别 人 可 能 连 题 目 的 意 思 都 看 不 懂, 什 么 都 没 写, 你 要 敢 于 答 这 道 题, 即 使 只 答 了 一 部 分, 那 也 与 那 些 什 么 都 不 懂 的 人 区 别 出 来, 拉 开 了 距 离, 算 是 矮 子 中 的 高 个, 机 会 当 然 就 属 于 你 了 另 外, 答 案 中 的 框 架 代 码 也 很 重 要, 体 现 了 一 些 面 向 对 象 设 计 的 功 底, 特 别 是 其 中 的 方 法 命 名 很 专 业, 用 的 英 文 单 词 很 精 准, 这 也 是 能 力 经 验 专 业 性 英 语 水 平 等 多 个 方 面 的 体 现, 会 给 人 留 下 很 好 的 印 象, 在 编 程 能 力 和 其 他 方 面 条 件 差 不 多 的 情 况 下, 英 语 好 除 了 可 以 使 你 获 得 更 多 机 会 外, 薪 水 可 以 高 出 一 千 元 10 使 用 final 关 键 字 修 饰 一 个 变 量 时, 是 引 用 不 能 变, 还 是 引 用 的 对 象 不 能 变? 使 用 final 关 键 字 修 饰 一 个 变 量 时, 是 指 引 用 变 量 不 能 变, 引 用 变 量 所 指 向 的 对 象 中 的 内 容 还 是 可 以 改 变 的 例 如, 对 于 如 下 语 句 : final StringBuffer a=new StringBuffer("immutable"); 执 行 如 下 语 句 将 报 告 编 译 期 错 误 : a=new StringBuffer(""); 但 是, 执 行 如 下 语 句 则 可 以 通 过 编 译 : a.append(" broken!"); 有 人 在 定 义 方 法 的 参 数 时, 可 能 想 采 用 如 下 形 式 来 阻 止 方 法 内 部 修 改 传 进 来 的 参 数 对 象 : public void method(final StringBuffer param) 实 际 上, 这 是 办 不 到 的, 在 该 方 法 内 部 仍 然 可 以 增 加 如 下 代 码 来 修 改 参 数 对 象 : param.append("a"); 11 "==" 和 equals 方 法 究 竟 有 什 么 区 别? ( 单 独 把 一 个 东 西 说 清 楚, 然 后 再 说 清 楚 另 一 个, 这 样, 它 们 的 区 别 自 然 就 出 来 了, 混 在 一 起 说, 则 很 难 说 清 楚 )

== 操 作 符 专 门 用 来 比 较 两 个 变 量 的 值 是 否 相 等, 也 就 是 用 于 比 较 变 量 所 对 应 的 内 存 中 所 存 储 的 数 值 是 否 相 同, 要 比 较 两 个 基 本 类 型 的 数 据 或 两 个 引 用 变 量 是 否 相 等, 只 能 用 == 操 作 符 如 果 一 个 变 量 指 向 的 数 据 是 对 象 类 型 的, 那 么, 这 时 候 涉 及 了 两 块 内 存, 对 象 本 身 占 用 一 块 内 存 ( 堆 内 存 ), 变 量 也 占 用 一 块 内 存, 例 如 Objet obj = new Object(); 变 量 obj 是 一 个 内 存, new Object() 是 另 一 个 内 存, 此 时, 变 量 obj 所 对 应 的 内 存 中 存 储 的 数 值 就 是 对 象 占 用 的 那 块 内 存 的 首 地 址 对 于 指 向 对 象 类 型 的 变 量, 如 果 要 比 较 两 个 变 量 是 否 指 向 同 一 个 对 象, 即 要 看 这 两 个 变 量 所 对 应 的 内 存 中 的 数 值 是 否 相 等, 这 时 候 就 需 要 用 == 操 作 符 进 行 比 较 equals 方 法 是 用 于 比 较 两 个 独 立 对 象 的 内 容 是 否 相 同, 就 好 比 去 比 较 两 个 人 的 长 相 是 否 相 同, 它 比 较 的 两 个 对 象 是 独 立 的 例 如, 对 于 下 面 的 代 码 : String a=new String("foo"); String b=new String("foo"); 两 条 new 语 句 创 建 了 两 个 对 象, 然 后 用 a/b 这 两 个 变 量 分 别 指 向 了 其 中 一 个 对 象, 这 是 两 个 不 同 的 对 象, 它 们 的 首 地 址 是 不 同 的, 即 a 和 b 中 存 储 的 数 值 是 不 相 同 的, 所 以, 表 达 式 a==b 将 返 回 false, 而 这 两 个 对 象 中 的 内 容 是 相 同 的, 所 以, 表 达 式 a.equals(b) 将 返 回 true 在 实 际 开 发 中, 我 们 经 常 要 比 较 传 递 进 行 来 的 字 符 串 内 容 是 否 等, 例 如,String input = ;input.equals( quit ), 许 多 人 稍 不 注 意 就 使 用 == 进 行 比 较 了, 这 是 错 误 的, 随 便 从 网 上 找 几 个 项 目 实 战 的 教 学 视 频 看 看, 里 面 就 有 大 量 这 样 的 错 误 记 住, 字 符 串 的 比 较 基 本 上 都 是 使 用 equals 方 法 如 果 一 个 类 没 有 自 己 定 义 equals 方 法, 那 么 它 将 继 承 Object 类 的 equals 方 法,Object 类 的 equals 方 法 的 实 现 代 码 如 下 : boolean equals(object o) return this==o; 这 说 明, 如 果 一 个 类 没 有 自 己 定 义 equals 方 法, 它 默 认 的 equals 方 法 ( 从 Object 类 继 承 的 ) 就 是 使 用 == 操 作 符, 也 是 在 比 较 两 个 变 量 指 向 的 对 象 是 否 是 同 一 对 象, 这 时 候 使 用 equals 和 使 用 == 会 得 到 同 样 的 结 果, 如 果 比 较 的 是 两 个 独 立 的 对 象 则 总 返 回 false 如 果 你 编 写 的 类 希 望 能 够 比 较 该 类 创 建 的 两 个 实 例 对 象 的 内 容 是 否 相 同, 那 么 你 必 须 覆 盖 equals 方 法, 由 你 自 己 写 代 码 来 决 定 在 什 么 情 况 即 可 认 为 两 个 对 象 的 内 容 是 相 同 的 12 静 态 变 量 和 实 例 变 量 的 区 别? 在 语 法 定 义 上 的 区 别 : 静 态 变 量 前 要 加 static 关 键 字, 而 实 例 变 量 前 则 不 加 在 程 序 运 行 时 的 区 别 : 实 例 变 量 属 于 某 个 对 象 的 属 性, 必 须 创 建 了 实 例 对 象, 其 中 的 实 例 变

量 才 会 被 分 配 空 间, 才 能 使 用 这 个 实 例 变 量 静 态 变 量 不 属 于 某 个 实 例 对 象, 而 是 属 于 类, 所 以 也 称 为 类 变 量, 只 要 程 序 加 载 了 类 的 字 节 码, 不 用 创 建 任 何 实 例 对 象, 静 态 变 量 就 会 被 分 配 空 间, 静 态 变 量 就 可 以 被 使 用 了 总 之, 实 例 变 量 必 须 创 建 对 象 后 才 可 以 通 过 这 个 对 象 来 使 用, 静 态 变 量 则 可 以 直 接 使 用 类 名 来 引 用 例 如, 对 于 下 面 的 程 序, 无 论 创 建 多 少 个 实 例 对 象, 永 远 都 只 分 配 了 一 个 staticvar 变 量, 并 且 每 创 建 一 个 实 例 对 象, 这 个 staticvar 就 会 加 1; 但 是, 每 创 建 一 个 实 例 对 象, 就 会 分 配 一 个 instancevar, 即 可 能 分 配 多 个 instancevar, 并 且 每 个 instancevar 的 值 都 只 自 加 了 1 次 public class VariantTest public static int staticvar = 0; public int instancevar = 0; public VariantTest() staticvar++; instancevar++; System.out.println( staticvar= + staticvar +,instancevar= + instancevar); 备 注 : 这 个 解 答 除 了 说 清 楚 两 者 的 区 别 外, 最 后 还 用 一 个 具 体 的 应 用 例 子 来 说 明 两 者 的 差 异, 体 现 了 自 己 有 很 好 的 解 说 问 题 和 设 计 案 例 的 能 力, 思 维 敏 捷, 超 过 一 般 程 序 员, 有 写 作 能 力! 13 是 否 可 以 从 一 个 static 方 法 内 部 发 出 对 非 static 方 法 的 调 用? 不 可 以 因 为 非 static 方 法 是 要 与 对 象 关 联 在 一 起 的, 必 须 创 建 一 个 对 象 后, 才 可 以 在 该 对 象 上 进 行 方 法 调 用, 而 static 方 法 调 用 时 不 需 要 创 建 对 象, 可 以 直 接 调 用 也 就 是 说, 当 一 个 static 方 法 被 调 用 时, 可 能 还 没 有 创 建 任 何 实 例 对 象, 如 果 从 一 个 static 方 法 中 发 出 对 非 static 方 法 的 调 用, 那 个 非 static 方 法 是 关 联 到 哪 个 对 象 上 的 呢? 这 个 逻 辑 无 法 成 立, 所 以, 一 个 static 方 法 内 部 发 出 对 非 static 方 法 的 调 用 14 Integer 与 int 的 区 别 int 是 java 提 供 的 8 种 原 始 数 据 类 型 之 一 Java 为 每 个 原 始 类 型 提 供 了 封 装 类,Integer 是 java 为 int 提 供 的 封 装 类 int 的 默 认 值 为 0, 而 Integer 的 默 认 值 为 null, 即 Integer 可 以 区 分 出 未 赋 值 和 值 为 0 的 区 别,int 则 无 法 表 达 出 未 赋 值 的 情 况, 例 如, 要 想 表 达 出 没 有 参 加 考 试 和 考 试 成 绩 为 0 的 区 别, 则 只 能 使 用 Integer 在 JSP 开 发 中,Integer 的 默 认 为 null, 所 以 用 el 表 达 式 在 文 本 框 中 显 示 时, 值 为 空 白 字 符 串, 而 int 默 认 的 默 认 值 为 0, 所 以 用 el 表 达 式

在 文 本 框 中 显 示 时, 结 果 为 0, 所 以,int 不 适 合 作 为 web 层 的 表 单 数 据 的 类 型 在 Hibernate 中, 如 果 将 OID 定 义 为 Integer 类 型, 那 么 Hibernate 就 可 以 根 据 其 值 是 否 为 null 而 判 断 一 个 对 象 是 否 是 临 时 的, 如 果 将 OID 定 义 为 了 int 类 型, 还 需 要 在 hbm 映 射 文 件 中 设 置 其 unsaved-value 属 性 为 0 另 外,Integer 提 供 了 多 个 与 整 数 相 关 的 操 作 方 法, 例 如, 将 一 个 字 符 串 转 换 成 整 数,Integer 中 还 定 义 了 表 示 整 数 的 最 大 值 和 最 小 值 的 常 量 15 Math.round(11.5) 等 於 多 少? Math.round(-11.5) 等 於 多 少? Math 类 中 提 供 了 三 个 与 取 整 有 关 的 方 法 :ceil floor round, 这 些 方 法 的 作 用 与 它 们 的 英 文 名 称 的 含 义 相 对 应, 例 如,ceil 的 英 文 意 义 是 天 花 板, 该 方 法 就 表 示 向 上 取 整, Math.ceil(11.3) 的 结 果 为 12,Math.ceil(-11.3) 的 结 果 是 -11;floor 的 英 文 意 义 是 地 板, 该 方 法 就 表 示 向 下 取 整,Math.ceil(11.6) 的 结 果 为 11,Math.ceil(-11.6) 的 结 果 是 -12; 最 难 掌 握 的 是 round 方 法, 它 表 示 四 舍 五 入, 算 法 为 Math.floor(x+0.5), 即 将 原 来 的 数 字 加 上 0.5 后 再 向 下 取 整, 所 以,Math.round(11.5) 的 结 果 为 12,Math.round(-11.5) 的 结 果 为 -11 16 下 面 的 代 码 有 什 么 不 妥 之 处? 1. if(username.equals( zxx ) username 可 能 为 NULL, 会 报 空 指 针 错 误 ; 改 为 "zxx".equals(username) 2. int x = 1; return x==1?true:false; 这 个 改 成 return x==1; 就 可 以! 17 请 说 出 作 用 域 public,private,protected, 以 及 不 写 时 的 区 别 这 四 个 作 用 域 的 可 见 范 围 如 下 表 所 示 说 明 : 如 果 在 修 饰 的 元 素 上 面 没 有 写 任 何 访 问 修 饰 符, 则 表 示 friendly 作 用 域 当 前 类 同 一 包 (package) 子 孙 类 其 他 包 (package) public protected friendly private 备 注 : 只 要 记 住 了 有 4 种 访 问 权 限,4 个 访 问 范 围, 然 后 将 全 选 和 范 围 在 水 平 和 垂 直 方 向 上 分 别 按 排 从 小 到 大 或 从 大 到 小 的 顺 序 排 列, 就 很 容 易 画 出 上 面 的 图 了

18 Overload 和 Override 的 区 别 Overloaded 的 方 法 是 否 可 以 改 变 返 回 值 的 类 型? Overload 是 重 载 的 意 思,Override 是 覆 盖 的 意 思, 也 就 是 重 写 重 载 Overload 表 示 同 一 个 类 中 可 以 有 多 个 名 称 相 同 的 方 法, 但 这 些 方 法 的 参 数 列 表 各 不 相 同 ( 即 参 数 个 数 或 类 型 不 同 ) 重 写 Override 表 示 子 类 中 的 方 法 可 以 与 父 类 中 的 某 个 方 法 的 名 称 和 参 数 完 全 相 同, 通 过 子 类 创 建 的 实 例 对 象 调 用 这 个 方 法 时, 将 调 用 子 类 中 的 定 义 方 法, 这 相 当 于 把 父 类 中 定 义 的 那 个 完 全 相 同 的 方 法 给 覆 盖 了, 这 也 是 面 向 对 象 编 程 的 多 态 性 的 一 种 表 现 子 类 覆 盖 父 类 的 方 法 时, 只 能 比 父 类 抛 出 更 少 的 异 常, 或 者 是 抛 出 父 类 抛 出 的 异 常 的 子 异 常, 因 为 子 类 可 以 解 决 父 类 的 一 些 问 题, 不 能 比 父 类 有 更 多 的 问 题 子 类 方 法 的 访 问 权 限 只 能 比 父 类 的 更 大, 不 能 更 小 如 果 父 类 的 方 法 是 private 类 型, 那 么, 子 类 则 不 存 在 覆 盖 的 限 制, 相 当 于 子 类 中 增 加 了 一 个 全 新 的 方 法 至 于 Overloaded 的 方 法 是 否 可 以 改 变 返 回 值 的 类 型 这 个 问 题, 要 看 你 倒 底 想 问 什 么 呢? 这 个 题 目 很 模 糊 如 果 几 个 Overloaded 的 方 法 的 参 数 列 表 不 一 样, 它 们 的 返 回 者 类 型 当 然 也 可 以 不 一 样 但 我 估 计 你 想 问 的 问 题 是 : 如 果 两 个 方 法 的 参 数 列 表 完 全 一 样, 是 否 可 以 让 它 们 的 返 回 值 不 同 来 实 现 重 载 Overload 这 是 不 行 的, 我 们 可 以 用 反 证 法 来 说 明 这 个 问 题, 因 为 我 们 有 时 候 调 用 一 个 方 法 时 也 可 以 不 定 义 返 回 结 果 变 量, 即 不 要 关 心 其 返 回 结 果, 例 如, 我 们 调 用 map.remove(key) 方 法 时, 虽 然 remove 方 法 有 返 回 值, 但 是 我 们 通 常 都 不 会 定 义 接 收 返 回 结 果 的 变 量, 这 时 候 假 设 该 类 中 有 两 个 名 称 和 参 数 列 表 完 全 相 同 的 方 法, 仅 仅 是 返 回 类 型 不 同,java 就 无 法 确 定 编 程 者 倒 底 是 想 调 用 哪 个 方 法 了, 因 为 它 无 法 通 过 返 回 结 果 类 型 来 判 断 override 可 以 翻 译 为 覆 盖, 从 字 面 就 可 以 知 道, 它 是 覆 盖 了 一 个 方 法 并 且 对 其 重 写, 以 求 达 到 不 同 的 作 用 对 我 们 来 说 最 熟 悉 的 覆 盖 就 是 对 接 口 方 法 的 实 现, 在 接 口 中 一 般 只 是 对 方 法 进 行 了 声 明, 而 我 们 在 实 现 时, 就 需 要 实 现 接 口 声 明 的 所 有 方 法 除 了 这 个 典 型 的 用 法 以 外, 我 们 在 继 承 中 也 可 能 会 在 子 类 覆 盖 父 类 中 的 方 法 在 覆 盖 要 注 意 以 下 的 几 点 : 1 覆 盖 的 方 法 的 标 志 必 须 要 和 被 覆 盖 的 方 法 的 标 志 完 全 匹 配, 才 能 达 到 覆 盖 的 效 果 ; 2 覆 盖 的 方 法 的 返 回 值 必 须 和 被 覆 盖 的 方 法 的 返 回 一 致 ; 3 覆 盖 的 方 法 所 抛 出 的 异 常 必 须 和 被 覆 盖 方 法 的 所 抛 出 的 异 常 一 致, 或 者 是 其 子 类 ; 4 被 覆 盖 的 方 法 不 能 为 private, 否 则 在 其 子 类 中 只 是 新 定 义 了 一 个 方 法, 并 没 有 对 其 进 行 覆 盖 overload 对 我 们 来 说 可 能 比 较 熟 悉, 可 以 翻 译 为 重 载, 它 是 指 我 们 可 以 定 义 一 些 名 称 相 同 的 方 法, 通 过 定 义 不 同 的 输 入 参 数 来 区 分 这 些 方 法, 然 后 再 调 用 时,VM 就 会 根 据 不 同 的 参

数 样 式, 来 选 择 合 适 的 方 法 执 行 在 使 用 重 载 要 注 意 以 下 的 几 点 : 1 在 使 用 重 载 时 只 能 通 过 不 同 的 参 数 样 式 例 如, 不 同 的 参 数 类 型, 不 同 的 参 数 个 数, 不 同 的 参 数 顺 序 ( 当 然, 同 一 方 法 内 的 几 个 参 数 类 型 必 须 不 一 样, 例 如 可 以 是 fun(int,float), 但 是 不 能 为 fun(int,int)); 2 不 能 通 过 访 问 权 限 返 回 类 型 抛 出 的 异 常 进 行 重 载 ; 3 方 法 的 异 常 类 型 和 数 目 不 会 对 重 载 造 成 影 响 ; 4 对 于 继 承 来 说, 如 果 某 一 方 法 在 父 类 中 是 访 问 权 限 是 priavte, 那 么 就 不 能 在 子 类 对 其 进 行 重 载, 如 果 定 义 的 话, 也 只 是 定 义 了 一 个 新 方 法, 而 不 会 达 到 重 载 的 效 果 19 构 造 器 Constructor 是 否 可 被 override? 构 造 器 Constructor 不 能 被 继 承, 因 此 不 能 重 写 Override, 但 可 以 被 重 载 Overload 20 接 口 是 否 可 继 承 接 口? 抽 象 类 是 否 可 实 现 (implements) 接 口? 抽 象 类 是 否 可 继 承 具 体 类 (concrete class)? 抽 象 类 中 是 否 可 以 有 静 态 的 main 方 法? 接 口 可 以 继 承 接 口 抽 象 类 可 以 实 现 (implements) 接 口, 抽 象 类 可 以 继 承 具 体 类 抽 象 类 中 可 以 有 静 态 的 main 方 法 备 注 : 只 要 明 白 了 接 口 和 抽 象 类 的 本 质 和 作 用, 这 些 问 题 都 很 好 回 答, 你 想 想, 如 果 你 是 java 语 言 的 设 计 者, 你 是 否 会 提 供 这 样 的 支 持, 如 果 不 提 供 的 话, 有 什 么 理 由 吗? 如 果 你 没 有 道 理 不 提 供, 那 答 案 就 是 肯 定 的 了 只 有 记 住 抽 象 类 与 普 通 类 的 唯 一 区 别 : 就 是 不 能 创 建 实 例 对 象 和 允 许 有 abstract 方 法 21 写 clone() 方 法 时, 通 常 都 有 一 行 代 码, 是 什 么? clone 有 缺 省 行 为, super.clone(); 因 为 首 先 要 把 父 类 中 的 成 员 复 制 到 位, 然 后 才 是 复 制 自 己 的 成 员 22 面 向 对 象 的 特 征 有 哪 些 方 面 计 算 机 软 件 系 统 是 现 实 生 活 中 的 业 务 在 计 算 机 中 的 映 射, 而 现 实 生 活 中 的 业 务 其 实 就 是 一 个 个 对 象 协 作 的 过 程 面 向 对 象 编 程 就 是 按 现 实 业 务 一 样 的 方 式 将 程 序 代 码 按 一 个 个 对 象 进 行 组 织 和 编 写, 让 计 算 机 系 统 能 够 识 别 和 理 解 用 对 象 方 式 组 织 和 编 写 的 程 序 代 码, 这 样 就 可 以 把 现 实 生 活 中 的 业 务 对 象 映 射 到 计 算 机 系 统 中 面 向 对 象 的 编 程 语 言 有, 吗 等 4 个 主 要 的 特 征 封 装 : 封 装 是 保 证 软 件 部 件 具 有 优 良 的 模 块 性 的 基 础, 封 装 的 目 标 就 是 要 实 现 软 件 部 件 的 高 内 聚

低 耦 合, 防 止 程 序 相 互 依 赖 性 而 带 来 的 变 动 影 响 在 面 向 对 象 的 编 程 语 言 中, 对 象 是 封 装 的 最 基 本 单 位, 面 向 对 象 的 封 装 比 传 统 语 言 的 封 装 更 为 清 晰 更 为 有 力 面 向 对 象 的 封 装 就 是 把 描 述 一 个 对 象 的 属 性 和 行 为 的 代 码 封 装 在 一 个 模 块 中, 也 就 是 一 个 类 中, 属 性 用 变 量 定 义, 行 为 用 方 法 进 行 定 义, 方 法 可 以 直 接 访 问 同 一 个 对 象 中 的 属 性 通 常 情 况 下, 只 要 记 住 让 变 量 和 访 问 这 个 变 量 的 方 法 放 在 一 起, 将 一 个 类 中 的 成 员 变 量 全 部 定 义 成 私 有 的, 只 有 这 个 类 自 己 的 方 法 才 可 以 访 问 到 这 些 成 员 变 量, 这 就 基 本 上 实 现 对 象 的 封 装, 就 很 容 易 找 出 要 分 配 到 这 个 类 上 的 方 法 了, 就 基 本 上 算 是 会 面 向 对 象 的 编 程 了 把 握 一 个 原 则 : 把 对 同 一 事 物 进 行 操 作 的 方 法 和 相 关 的 方 法 放 在 同 一 个 类 中, 把 方 法 和 它 操 作 的 数 据 放 在 同 一 个 类 中 例 如, 人 要 在 黑 板 上 画 圆, 这 一 共 涉 及 三 个 对 象 : 人 黑 板 圆, 画 圆 的 方 法 要 分 配 给 哪 个 对 象 呢? 由 于 画 圆 需 要 使 用 到 圆 心 和 半 径, 圆 心 和 半 径 显 然 是 圆 的 属 性, 如 果 将 它 们 在 类 中 定 义 成 了 私 有 的 成 员 变 量, 那 么, 画 圆 的 方 法 必 须 分 配 给 圆, 它 才 能 访 问 到 圆 心 和 半 径 这 两 个 属 性, 人 以 后 只 是 调 用 圆 的 画 圆 方 法 表 示 给 圆 发 给 消 息 而 已, 画 圆 这 个 方 法 不 应 该 分 配 在 人 这 个 对 象 上, 这 就 是 面 向 对 象 的 封 装 性, 即 将 对 象 封 装 成 一 个 高 度 自 治 和 相 对 封 闭 的 个 体, 对 象 状 态 ( 属 性 ) 由 这 个 对 象 自 己 的 行 为 ( 方 法 ) 来 读 取 和 改 变 一 个 更 便 于 理 解 的 例 子 就 是, 司 机 将 火 车 刹 住 了, 刹 车 的 动 作 是 分 配 给 司 机, 还 是 分 配 给 火 车, 显 然, 应 该 分 配 给 火 车, 因 为 司 机 自 身 是 不 可 能 有 那 么 大 的 力 气 将 一 个 火 车 给 停 下 来 的, 只 有 火 车 自 己 才 能 完 成 这 一 动 作, 火 车 需 要 调 用 内 部 的 离 合 器 和 刹 车 片 等 多 个 器 件 协 作 才 能 完 成 刹 车 这 个 动 作, 司 机 刹 车 的 过 程 只 是 给 火 车 发 了 一 个 消 息, 通 知 火 车 要 执 行 刹 车 动 作 而 已 抽 象 : 抽 象 就 是 找 出 一 些 事 物 的 相 似 和 共 性 之 处, 然 后 将 这 些 事 物 归 为 一 个 类, 这 个 类 只 考 虑 这 些 事 物 的 相 似 和 共 性 之 处, 并 且 会 忽 略 与 当 前 主 题 和 目 标 无 关 的 那 些 方 面, 将 注 意 力 集 中 在 与 当 前 目 标 有 关 的 方 面 例 如, 看 到 一 只 蚂 蚁 和 大 象, 你 能 够 想 象 出 它 们 的 相 同 之 处, 那 就 是 抽 象 抽 象 包 括 行 为 抽 象 和 状 态 抽 象 两 个 方 面 例 如, 定 义 一 个 Person 类, 如 下 : classperson String name; int age; 人 本 来 是 很 复 杂 的 事 物, 有 很 多 方 面, 但 因 为 当 前 系 统 只 需 要 了 解 人 的 姓 名 和 年 龄, 所 以 上 面 定 义 的 类 中 只 包 含 姓 名 和 年 龄 这 两 个 属 性, 这 就 是 一 种 抽 像, 使 用 抽 象 可 以 避 免 考 虑 一 些 与 目 标 无 关 的 细 节 我 对 抽 象 的 理 解 就 是 不 要 用 显 微 镜 去 看 一 个 事 物 的 所 有 方 面, 这 样 涉 及 的 内 容 就 太 多 了, 而 是 要 善 于 划 分 问 题 的 边 界, 当 前 系 统 需 要 什 么, 就 只 考 虑 什 么

继 承 : 在 定 义 和 实 现 一 个 类 的 时 候, 可 以 在 一 个 已 经 存 在 的 类 的 基 础 之 上 来 进 行, 把 这 个 已 经 存 在 的 类 所 定 义 的 内 容 作 为 自 己 的 内 容, 并 可 以 加 入 若 干 新 的 内 容, 或 修 改 原 来 的 方 法 使 之 更 适 合 特 殊 的 需 要, 这 就 是 继 承 继 承 是 子 类 自 动 共 享 父 类 数 据 和 方 法 的 机 制, 这 是 类 之 间 的 一 种 关 系, 提 高 了 软 件 的 可 重 用 性 和 可 扩 展 性 多 态 : 多 态 是 指 程 序 中 定 义 的 引 用 变 量 所 指 向 的 具 体 类 型 和 通 过 该 引 用 变 量 发 出 的 方 法 调 用 在 编 程 时 并 不 确 定, 而 是 在 程 序 运 行 期 间 才 确 定, 即 一 个 引 用 变 量 倒 底 会 指 向 哪 个 类 的 实 例 对 象, 该 引 用 变 量 发 出 的 方 法 调 用 到 底 是 哪 个 类 中 实 现 的 方 法, 必 须 在 由 程 序 运 行 期 间 才 能 决 定 因 为 在 程 序 运 行 时 才 确 定 具 体 的 类, 这 样, 不 用 修 改 源 程 序 代 码, 就 可 以 让 引 用 变 量 绑 定 到 各 种 不 同 的 类 实 现 上, 从 而 导 致 该 引 用 调 用 的 具 体 方 法 随 之 改 变, 即 不 修 改 程 序 代 码 就 可 以 改 变 程 序 运 行 时 所 绑 定 的 具 体 代 码, 让 程 序 可 以 选 择 多 个 运 行 状 态, 这 就 是 多 态 性 多 态 性 增 强 了 软 件 的 灵 活 性 和 扩 展 性 例 如, 下 面 代 码 中 的 UserDao 是 一 个 接 口, 它 定 义 引 用 变 量 userdao 指 向 的 实 例 对 象 由 daofactory.getdao() 在 执 行 的 时 候 返 回, 有 时 候 指 向 的 是 UserJdbcDao 这 个 实 现, 有 时 候 指 向 的 是 UserHibernateDao 这 个 实 现, 这 样, 不 用 修 改 源 代 码, 就 可 以 改 变 userdao 指 向 的 具 体 类 实 现, 从 而 导 致 userdao.insertuser() 方 法 调 用 的 具 体 代 码 也 随 之 改 变, 即 有 时 候 调 用 的 是 UserJdbcDao 的 insertuser 方 法, 有 时 候 调 用 的 是 UserHibernateDao 的 insertuser 方 法 : UserDao userdao =daofactory.getdao(); userdao.insertuser(user); 比 喻 : 人 吃 饭, 你 看 到 的 是 左 手, 还 是 右 手? 23 java 中 实 现 多 态 的 机 制 是 什 么? 靠 的 是 父 类 或 接 口 定 义 的 引 用 变 量 可 以 指 向 子 类 或 具 体 实 现 类 的 实 例 对 象, 而 程 序 调 用 的 方 法 在 运 行 期 才 动 态 绑 定, 就 是 引 用 变 量 所 指 向 的 具 体 实 例 对 象 的 方 法, 也 就 是 内 存 里 正 在 运 行 的 那 个 对 象 的 方 法, 而 不 是 引 用 变 量 的 类 型 中 定 义 的 方 法 24 abstract class 和 interface 有 什 么 区 别? 含 有 abstract 修 饰 符 的 class 即 为 抽 象 类,abstract 类 不 能 创 建 的 实 例 对 象 含 有 abstract 方 法 的 类 必 须 定 义 为 abstract class,abstract class 类 中 的 方 法 不 必 是 抽 象 的 abstract class

类 中 定 义 抽 象 方 法 必 须 在 具 体 (Concrete) 子 类 中 实 现, 所 以, 不 能 有 抽 象 构 造 方 法 或 抽 象 静 态 方 法 如 果 的 子 类 没 有 实 现 抽 象 父 类 中 的 所 有 抽 象 方 法, 那 么 子 类 也 必 须 定 义 为 abstract 类 型 接 口 (interface) 可 以 说 成 是 抽 象 类 的 一 种 特 例, 接 口 中 的 所 有 方 法 都 必 须 是 抽 象 的 接 口 中 的 方 法 定 义 默 认 为 public abstract 类 型, 接 口 中 的 成 员 变 量 类 型 默 认 为 public static final 下 面 比 较 一 下 两 者 的 语 法 区 别 : 1. 抽 象 类 可 以 有 构 造 方 法, 接 口 中 不 能 有 构 造 方 法 2. 抽 象 类 中 可 以 有 普 通 成 员 变 量, 接 口 中 没 有 普 通 成 员 变 量 3. 抽 象 类 中 可 以 包 含 非 抽 象 的 普 通 方 法, 接 口 中 的 所 有 方 法 必 须 都 是 抽 象 的, 不 能 有 非 抽 象 的 普 通 方 法 4. 抽 象 类 中 的 抽 象 方 法 的 访 问 类 型 可 以 是 public,protected 和 ( 默 认 类 型, 虽 然 eclipse 下 不 报 错, 但 应 该 也 不 行 ), 但 接 口 中 的 抽 象 方 法 只 能 是 public 类 型 的, 并 且 默 认 即 为 public abstract 类 型 5. 抽 象 类 中 可 以 包 含 静 态 方 法, 接 口 中 不 能 包 含 静 态 方 法 6. 抽 象 类 和 接 口 中 都 可 以 包 含 静 态 成 员 变 量, 抽 象 类 中 的 静 态 成 员 变 量 的 访 问 类 型 可 以 任 意, 但 接 口 中 定 义 的 变 量 只 能 是 public static final 类 型, 并 且 默 认 即 为 public static final 类 型 7. 一 个 类 可 以 实 现 多 个 接 口, 但 只 能 继 承 一 个 抽 象 类 下 面 接 着 再 说 说 两 者 在 应 用 上 的 区 别 : 接 口 更 多 的 是 在 系 统 架 构 设 计 方 法 发 挥 作 用, 主 要 用 于 定 义 模 块 之 间 的 通 信 契 约 而 抽 象 类 在 代 码 实 现 方 面 发 挥 作 用, 可 以 实 现 代 码 的 重 用, 例 如, 模 板 方 法 设 计 模 式 是 抽 象 类 的 一 个 典 型 应 用, 假 设 某 个 项 目 的 所 有 Servlet 类 都 要 用 相 同 的 方 式 进 行 权 限 判 断 记 录 访 问 日 志 和 处 理 异 常, 那 么 就 可 以 定 义 一 个 抽 象 的 基 类, 让 所 有 的 Servlet 都 继 承 这 个 抽 象 基 类, 在 抽 象 基 类 的 service 方 法 中 完 成 权 限 判 断 记 录 访 问 日 志 和 处 理 异 常 的 代 码, 在 各 个 子 类 中 只 是 完 成 各 自 的 业 务 逻 辑 代 码, 伪 代 码 如 下 : public abstract classbaseservlet extends HttpServlet public final void service(httpservletrequest request,httpservletresponse response) throws IOExcetion,ServletException 记 录 访 问 日 志 进 行 权 限 判 断 if( 具 有 权 限 ) try

doservice(request,response); catch(excetpion e) 记 录 异 常 信 息 protected abstract void doservice(httpservletrequest request,httpservletresponse response) throws IOExcetion,ServletException; // 注 意 访 问 权 限 定 义 成 protected, 显 得 既 专 业, 又 严 谨, 因 为 它 是 专 门 给 子 类 用 的 public class MyServlet1 extendsbaseservlet protected voiddoservice(httpservletrequest request, HttpServletResponse response) throwsioexcetion,servletexception 本 Servlet 只 处 理 的 具 体 业 务 逻 辑 代 码 父 类 方 法 中 间 的 某 段 代 码 不 确 定, 留 给 子 类 干, 就 用 模 板 方 法 设 计 模 式 备 注 : 这 道 题 的 思 路 是 先 从 总 体 解 释 抽 象 类 和 接 口 的 基 本 概 念, 然 后 再 比 较 两 者 的 语 法 细 节, 最 后 再 说 两 者 的 应 用 区 别 比 较 两 者 语 法 细 节 区 别 的 条 理 是 : 先 从 一 个 类 中 的 构 造 方 法 普 通 成 员 变 量 和 方 法 ( 包 括 抽 象 方 法 ), 静 态 变 量 和 方 法, 继 承 性 等 6 个 方 面 逐 一 去 比 较 回 答, 接 着 从 第 三 者 继 承 的 角 度 的 回 答, 特 别 是 最 后 用 了 一 个 典 型 的 例 子 来 展 现 自 己 深 厚 的 技 术 功 底 25 abstract 的 method 是 否 可 同 时 是 static, 是 否 可 同 时 是 native, 是 否 可 同 时 是 synchronized? abstract 的 method 不 可 以 是 static 的, 因 为 抽 象 的 方 法 是 要 被 子 类 实 现 的, 而 static 与 子 类 扯 不 上 关 系!

native 方 法 表 示 该 方 法 要 用 另 外 一 种 依 赖 平 台 的 编 程 语 言 实 现 的, 不 存 在 着 被 子 类 实 现 的 问 题, 所 以, 它 也 不 能 是 抽 象 的, 不 能 与 abstract 混 用 例 如,FileOutputSteam 类 要 硬 件 打 交 道, 底 层 的 实 现 用 的 是 操 作 系 统 相 关 的 api 实 现, 例 如, 在 windows 用 c 语 言 实 现 的, 所 以, 查 看 jdk 的 源 代 码, 可 以 发 现 FileOutputStream 的 open 方 法 的 定 义 如 下 : private native void open(stringname) throws FileNotFoundException; 如 果 我 们 要 用 java 调 用 别 人 写 的 c 语 言 函 数, 我 们 是 无 法 直 接 调 用 的, 我 们 需 要 按 照 java 的 要 求 写 一 个 c 语 言 的 函 数, 又 我 们 的 这 个 c 语 言 函 数 去 调 用 别 人 的 c 语 言 函 数 由 于 我 们 的 c 语 言 函 数 是 按 java 的 要 求 来 写 的, 我 们 这 个 c 语 言 函 数 就 可 以 与 java 对 接 上,java 那 边 的 对 接 方 式 就 是 定 义 出 与 我 们 这 个 c 函 数 相 对 应 的 方 法,java 中 对 应 的 方 法 不 需 要 写 具 体 的 代 码, 但 需 要 在 前 面 声 明 native 关 于 synchronized 与 abstract 合 用 的 问 题, 我 觉 得 也 不 行, 因 为 在 我 几 年 的 学 习 和 开 发 中, 从 来 没 见 到 过 这 种 情 况, 并 且 我 觉 得 synchronized 应 该 是 作 用 在 一 个 具 体 的 方 法 上 才 有 意 义 而 且, 方 法 上 的 synchronized 同 步 所 使 用 的 同 步 锁 对 象 是 this, 而 抽 象 方 法 上 无 法 确 定 this 是 什 么 26 什 么 是 内 部 类?Static Nested Class 和 Inner Class 的 不 同 内 部 类 就 是 在 一 个 类 的 内 部 定 义 的 类, 内 部 类 中 不 能 定 义 静 态 成 员 ( 静 态 成 员 不 是 对 象 的 特 性, 只 是 为 了 找 一 个 容 身 之 处, 所 以 需 要 放 到 一 个 类 中 而 已, 这 么 一 点 小 事, 你 还 要 把 它 放 到 类 内 部 的 一 个 类 中, 过 分 了 啊! 提 供 内 部 类, 不 是 为 让 你 干 这 种 事 情, 无 聊, 不 让 你 干 我 想 可 能 是 既 然 静 态 成 员 类 似 c 语 言 的 全 局 变 量, 而 内 部 类 通 常 是 用 于 创 建 内 部 对 象 用 的, 所 以, 把 全 局 变 量 放 在 内 部 类 中 就 是 毫 无 意 义 的 事 情, 既 然 是 毫 无 意 义 的 事 情, 就 应 该 被 禁 止 ), 内 部 类 可 以 直 接 访 问 外 部 类 中 的 成 员 变 量, 内 部 类 可 以 定 义 在 外 部 类 的 方 法 外 面, 也 可 以 定 义 在 外 部 类 的 方 法 体 中, 如 下 所 示 : public class Outer int out_x = 0; public void method() Inner1 inner1 = new Inner1(); public class Inner2 // 在 方 法 体 内 部 定 义 的 内 部 类 public method() out_x = 3;

Inner2 inner2 = new Inner2(); public class Inner1 // 在 方 法 体 外 面 定 义 的 内 部 类 在 方 法 体 外 面 定 义 的 内 部 类 的 访 问 类 型 可 以 是 public,protecte, 默 认 的,private 等 4 种 类 型, 这 就 好 像 类 中 定 义 的 成 员 变 量 有 4 种 访 问 类 型 一 样, 它 们 决 定 这 个 内 部 类 的 定 义 对 其 他 类 是 否 可 见 ; 对 于 这 种 情 况, 我 们 也 可 以 在 外 面 创 建 内 部 类 的 实 例 对 象, 创 建 内 部 类 的 实 例 对 象 时, 一 定 要 先 创 建 外 部 类 的 实 例 对 象, 然 后 用 这 个 外 部 类 的 实 例 对 象 去 创 建 内 部 类 的 实 例 对 象, 代 码 如 下 : Outer outer = new Outer(); Outer.Inner1 inner1 = outer.new Innner1(); 在 方 法 内 部 定 义 的 内 部 类 前 面 不 能 有 访 问 类 型 修 饰 符, 就 好 像 方 法 中 定 义 的 局 部 变 量 一 样, 但 这 种 内 部 类 的 前 面 可 以 使 用 final 或 abstract 修 饰 符 这 种 内 部 类 对 其 他 类 是 不 可 见 的 其 他 类 无 法 引 用 这 种 内 部 类, 但 是 这 种 内 部 类 创 建 的 实 例 对 象 可 以 传 递 给 其 他 类 访 问 这 种 内 部 类 必 须 是 先 定 义, 后 使 用, 即 内 部 类 的 定 义 代 码 必 须 出 现 在 使 用 该 类 之 前, 这 与 方 法 中 的 局 部 变 量 必 须 先 定 义 后 使 用 的 道 理 也 是 一 样 的 这 种 内 部 类 可 以 访 问 方 法 体 中 的 局 部 变 量, 但 是, 该 局 部 变 量 前 必 须 加 final 修 饰 符 对 于 这 些 细 节, 只 要 在 eclipse 写 代 码 试 试, 根 据 开 发 工 具 提 示 的 各 类 错 误 信 息 就 可 以 马 上 了 解 到 在 方 法 体 内 部 还 可 以 采 用 如 下 语 法 来 创 建 一 种 匿 名 内 部 类, 即 定 义 某 一 接 口 或 类 的 子 类 的 同 时, 还 创 建 了 该 子 类 的 实 例 对 象, 无 需 为 该 子 类 定 义 名 称 : public class Outer public void start()

new Thread( new Runable() public void run(); ).start(); 最 后, 在 方 法 外 部 定 义 的 内 部 类 前 面 可 以 加 上 static 关 键 字, 从 而 成 为 Static Nested Class, 它 不 再 具 有 内 部 类 的 特 性, 所 有, 从 狭 义 上 讲, 它 不 是 内 部 类 Static Nested Class 与 普 通 类 在 运 行 时 的 行 为 和 功 能 上 没 有 什 么 区 别, 只 是 在 编 程 引 用 时 的 语 法 上 有 一 些 差 别, 它 可 以 定 义 成 public protected 默 认 的 private 等 多 种 类 型, 而 普 通 类 只 能 定 义 成 public 和 默 认 的 这 两 种 类 型 在 外 面 引 用 Static Nested Class 类 的 名 称 为 外 部 类 名. 内 部 类 名 在 外 面 不 需 要 创 建 外 部 类 的 实 例 对 象, 就 可 以 直 接 创 建 Static Nested Class, 例 如, 假 设 Inner 是 定 义 在 Outer 类 中 的 Static Nested Class, 那 么 可 以 使 用 如 下 语 句 创 建 Inner 类 : Outer.Inner inner = newouter.inner(); 由 于 static Nested Class 不 依 赖 于 外 部 类 的 实 例 对 象, 所 以,static Nested Class 能 访 问 外 部 类 的 非 static 成 员 变 量 ( 不 能 直 接 访 问, 需 要 创 建 外 部 类 实 例 才 能 访 问 非 静 态 变 量 ) 当 在 外 部 类 中 访 问 Static Nested Class 时, 可 以 直 接 使 用 Static Nested Class 的 名 字, 而 不 需 要 加 上 外 部 类 的 名 字 了, 在 Static Nested Class 中 也 可 以 直 接 引 用 外 部 类 的 static 的 成 员 变 量, 不 需 要 加 上 外 部 类 的 名 字 在 静 态 方 法 中 定 义 的 内 部 类 也 是 Static Nested Class, 这 时 候 不 能 在 类 前 面 加 static 关 键 字, 静 态 方 法 中 的 Static Nested Class 与 普 通 方 法 中 的 内 部 类 的 应 用 方 式 很 相 似, 它 除 了 可 以 直 接 访 问 外 部 类 中 的 static 的 成 员 变 量, 还 可 以 访 问 静 态 方 法 中 的 局 部 变 量, 但 是, 该 局 部 变 量 前 必 须 加 final 修 饰 符 备 注 : 首 先 根 据 你 的 印 象 说 出 你 对 内 部 类 的 总 体 方 面 的 特 点 : 例 如, 在 两 个 地 方 可 以 定 义, 可 以 访 问 外 部 类 的 成 员 变 量, 不 能 定 义 静 态 成 员, 这 是 大 的 特 点 然 后 再 说 一 些 细 节 方 面 的 知 识, 例 如, 几 种 定 义 方 式 的 语 法 区 别, 静 态 内 部 类, 以 及 匿 名 内 部 类 27 内 部 类 可 以 引 用 它 的 包 含 类 的 成 员 吗? 有 没 有 什 么 限 制? 完 全 可 以 如 果 不 是 静 态 内 部 类, 那 没 有 什 么 限 制!

如 果 你 把 静 态 嵌 套 类 当 作 内 部 类 的 一 种 特 例, 那 在 这 种 情 况 下 不 可 以 访 问 外 部 类 的 普 通 成 员 变 量, 而 只 能 访 问 外 部 类 中 的 静 态 成 员, 例 如, 下 面 的 代 码 : class Outer static int x; static class Inner void test() syso(x); 答 题 时, 也 要 能 察 言 观 色, 揣 摩 提 问 者 的 心 思, 显 然 人 家 希 望 你 说 的 是 静 态 内 部 类 不 能 访 问 外 部 类 的 成 员, 但 你 一 上 来 就 顶 牛, 这 不 好, 要 先 顺 着 人 家, 让 人 家 满 意, 然 后 再 说 特 殊 情 况, 让 人 家 吃 惊 28 Anonymous Inner Class ( 匿 名 内 部 类 ) 是 否 可 以 extends( 继 承 ) 其 它 类, 是 否 可 以 implements( 实 现 )interface( 接 口 )? 可 以 继 承 其 他 类 或 实 现 其 他 接 口 不 仅 是 可 以, 而 是 必 须! 29 super.getclass() 方 法 调 用 下 面 程 序 的 输 出 结 果 是 多 少? importjava.util.date; public class Test extends Date public static void main(string[] args) new Test().test(); public void test()

System.out.println(super.getClass().getName()); 很 奇 怪, 结 果 是 Test 这 属 于 脑 筋 急 转 弯 的 题 目, 在 一 个 qq 群 有 个 网 友 正 好 问 过 这 个 问 题, 我 觉 得 挺 有 趣, 就 研 究 了 一 下, 没 想 到 今 天 还 被 你 面 到 了, 哈 哈 在 test 方 法 中, 直 接 调 用 getclass().getname() 方 法, 返 回 的 是 Test 类 名 由 于 getclass() 在 Object 类 中 定 义 成 了 final, 子 类 不 能 覆 盖 该 方 法, 所 以, 在 test 方 法 中 调 用 getclass().getname() 方 法, 其 实 就 是 在 调 用 从 父 类 继 承 的 getclass() 方 法, 等 效 于 调 用 super.getclass().getname() 方 法, 所 以,super.getClass().getName() 方 法 返 回 的 也 应 该 是 Test 如 果 想 得 到 父 类 的 名 称, 应 该 用 如 下 代 码 : getclass().getsuperclass().getname(); 30 String 是 最 基 本 的 数 据 类 型 吗? 基 本 数 据 类 型 包 括 byte int char long float double boolean 和 short java.lang.string 类 是 final 类 型 的, 因 此 不 可 以 继 承 这 个 类 不 能 修 改 这 个 类 为 了 提 高 效 率 节 省 空 间, 我 们 应 该 用 StringBuffer 类 31 String s = "Hello";s = s + " world!"; 这 两 行 代 码 执 行 后, 原 始 的 String 对 象 中 的 内 容 到 底 变 了 没 有? 没 有 因 为 String 被 设 计 成 不 可 变 (immutable) 类, 所 以 它 的 所 有 对 象 都 是 不 可 变 对 象 在 这 段 代 码 中,s 原 先 指 向 一 个 String 对 象, 内 容 是 "Hello", 然 后 我 们 对 s 进 行 了 + 操 作, 那 么 s 所 指 向 的 那 个 对 象 是 否 发 生 了 改 变 呢? 答 案 是 没 有 这 时,s 不 指 向 原 来 那 个 对 象 了, 而 指 向 了 另 一 个 String 对 象, 内 容 为 "Hello world!", 原 来 那 个 对 象 还 存 在 于 内 存 之 中, 只 是 s 这 个 引 用 变 量 不 再 指 向 它 了 通 过 上 面 的 说 明, 我 们 很 容 易 导 出 另 一 个 结 论, 如 果 经 常 对 字 符 串 进 行 各 种 各 样 的 修 改, 或 者 说, 不 可 预 见 的 修 改, 那 么 使 用 String 来 代 表 字 符 串 的 话 会 引 起 很 大 的 内 存 开 销 因 为 String 对 象 建 立 之 后 不 能 再 改 变, 所 以 对 于 每 一 个 不 同 的 字 符 串, 都 需 要 一 个 String 对 象 来 表 示 这 时, 应 该 考 虑 使 用 StringBuffer 类, 它 允 许 修 改, 而 不 是 每 个 不 同 的 字 符 串 都 要 生 成 一 个 新 的 对 象 并 且, 这 两 种 类 的 对 象 转 换 十 分 容 易 同 时, 我 们 还 可 以 知 道, 如 果 要 使 用 内 容 相 同 的 字 符 串, 不 必 每 次 都 new 一 个 String 例 如 我 们 要 在 构 造 器 中 对 一 个 名 叫 s 的 String 引 用 变 量 进 行 初 始 化, 把 它 设 置 为 初 始 值, 应

当 这 样 做 : public class Demo private String s;... public Demo s = "Initial Value";... 而 非 s = new String("Initial Value"); 后 者 每 次 都 会 调 用 构 造 器, 生 成 新 对 象, 性 能 低 下 且 内 存 开 销 大, 并 且 没 有 意 义, 因 为 String 对 象 不 可 改 变, 所 以 对 于 内 容 相 同 的 字 符 串, 只 要 一 个 String 对 象 来 表 示 就 可 以 了 也 就 说, 多 次 调 用 上 面 的 构 造 器 创 建 多 个 对 象, 他 们 的 String 类 型 属 性 s 都 指 向 同 一 个 对 象 上 面 的 结 论 还 基 于 这 样 一 个 事 实 : 对 于 字 符 串 常 量, 如 果 内 容 相 同,Java 认 为 它 们 代 表 同 一 个 String 对 象 而 用 关 键 字 new 调 用 构 造 器, 总 是 会 创 建 一 个 新 的 对 象, 无 论 内 容 是 否 相 同 至 于 为 什 么 要 把 String 类 设 计 成 不 可 变 类, 是 它 的 用 途 决 定 的 其 实 不 只 String, 很 多 Java 标 准 类 库 中 的 类 都 是 不 可 变 的 在 开 发 一 个 系 统 的 时 候, 我 们 有 时 候 也 需 要 设 计 不 可 变 类, 来 传 递 一 组 相 关 的 值, 这 也 是 面 向 对 象 思 想 的 体 现 不 可 变 类 有 一 些 优 点, 比 如 因 为 它 的 对 象 是 只 读 的, 所 以 多 线 程 并 发 访 问 也 不 会 有 任 何 问 题 当 然 也 有 一 些 缺 点, 比 如 每 个 不 同 的 状 态 都 要 一 个 对 象 来 代 表, 可 能 会 造 成 性 能 上 的 问 题 所 以 Java 标 准 类 库 还 提 供 了 一 个 可 变 版 本, 即 StringBuffer 32 是 否 可 以 继 承 String 类? String 类 是 final 类 故 不 可 以 继 承 33 String s = new String("xyz"); 创 建 了 几 个 String Object? 二 者 之 间 有 什 么 区 别? 两 个 或 一 个, xyz 对 应 一 个 对 象, 这 个 对 象 放 在 字 符 串 常 量 缓 冲 区, 常 量 xyz 不 管 出 现 多 少 遍, 都 是 缓 冲 区 中 的 那 一 个 New String 每 写 一 遍, 就 创 建 一 个 新 的 对 象, 它 一 句 那 个 常 量 xyz 对 象 的 内 容 来 创 建 出 一 个 新 String 对 象 如 果 以 前 就 用 过 xyz, 这 句 代 表 就 不 会 创 建 xyz 自 己 了, 直 接 从 缓 冲 区 拿

34 String 和 StringBuffer 的 区 别 JAVA 平 台 提 供 了 两 个 类 :String 和 StringBuffer, 它 们 可 以 储 存 和 操 作 字 符 串, 即 包 含 多 个 字 符 的 字 符 数 据 这 个 String 类 提 供 了 数 值 不 可 改 变 的 字 符 串 而 这 个 StringBuffer 类 提 供 的 字 符 串 进 行 修 改 当 你 知 道 字 符 数 据 要 改 变 的 时 候 你 就 可 以 使 用 StringBuffer 典 型 地, 你 可 以 使 用 StringBuffers 来 动 态 构 造 字 符 数 据 另 外,String 实 现 了 equals 方 法,new String( abc ).equals(newstring( abc ) 的 结 果 为 true, 而 StringBuffer 没 有 实 现 equals 方 法, 所 以,new StringBuffer( abc ).equals(newstringbuffer( abc ) 的 结 果 为 false 接 着 要 举 一 个 具 体 的 例 子 来 说 明, 我 们 要 把 1 到 100 的 所 有 数 字 拼 起 来, 组 成 一 个 串 StringBuffer sbf = new StringBuffer(); for(int i=0;i<100;i++) sbf.append(i); 上 面 的 代 码 效 率 很 高, 因 为 只 创 建 了 一 个 StringBuffer 对 象, 而 下 面 的 代 码 效 率 很 低, 因 为 创 建 了 101 个 对 象 String str = new String(); for(int i=0;i<100;i++) str = str + i; 在 讲 两 者 区 别 时, 应 把 循 环 的 次 数 搞 成 10000, 然 后 用 endtime-begintime 来 比 较 两 者 执 行 的 时 间 差 异, 最 后 还 要 讲 讲 StringBuilder 与 StringBuffer 的 区 别 String 覆 盖 了 equals 方 法 和 hashcode 方 法, 而 StringBuffer 没 有 覆 盖 equals 方 法 和 hashcode 方 法, 所 以, 将 StringBuffer 对 象 存 储 进 Java 集 合 类 中 时 会 出 现 问 题 35 如 何 把 一 段 逗 号 分 割 的 字 符 串 转 换 成 一 个 数 组? 如 果 不 查 jdk api, 我 很 难 写 出 来! 我 可 以 说 说 我 的 思 路 : 1 用 正 则 表 达 式, 代 码 大 概 为 :String [] result = orgstr.split(, ); 2 用 StingTokenizer, 代 码 为 :StringTokenizer tokener = StringTokenizer(orgStr,, );

String [] result =new String[tokener.countTokens()]; Int i=0; while(tokener.hasnext()result[i++]=toker.nexttoken(); 36 数 组 有 没 有 length() 这 个 方 法? String 有 没 有 length() 这 个 方 法? 数 组 没 有 length() 这 个 方 法, 有 length 的 属 性 String 有 有 length() 这 个 方 法 37 下 面 这 条 语 句 一 共 创 建 了 多 少 个 对 象 :String s="a"+"b"+"c"+"d"; 答 : 对 于 如 下 代 码 : String s1 = "a"; String s2 = s1 + "b"; String s3 = "a" + "b"; System.out.println(s2 == "ab"); System.out.println(s3 == "ab"); 第 一 条 语 句 打 印 的 结 果 为 false, 第 二 条 语 句 打 印 的 结 果 为 true, 这 说 明 javac 编 译 可 以 对 字 符 串 常 量 直 接 相 加 的 表 达 式 进 行 优 化, 不 必 要 等 到 运 行 期 去 进 行 加 法 运 算 处 理, 而 是 在 编 译 时 去 掉 其 中 的 加 号, 直 接 将 其 编 译 成 一 个 这 些 常 量 相 连 的 结 果 题 目 中 的 第 一 行 代 码 被 编 译 器 在 编 译 时 优 化 后, 相 当 于 直 接 定 义 了 一 个 abcd 的 字 符 串, 所 以, 上 面 的 代 码 应 该 只 创 建 了 一 个 String 对 象 写 如 下 两 行 代 码, String s ="a" + "b" + "c" + "d"; System.out.println(s== "abcd"); 最 终 打 印 的 结 果 应 该 为 true 38 try 里 有 一 个 return 语 句, 那 么 紧 跟 在 这 个 try 后 的 finally 里 的 code 会 不 会 被 执 行, 什 么 时 候 被 执 行, 在 return 前 还 是 后? 也 许 你 的 答 案 是 在 return 之 前, 但 往 更 细 地 说, 我 的 答 案 是 在 return 中 间 执 行, 请 看 下 面 程 序 代 码 的 运 行 结 果 : public classtest /** * @paramargs add by zxx,dec 9, 2008 */ public static void main(string[] args)

// TODO Auto-generated method stub System.out. println (new Test().test());; static int test() int x = 1; try Return x; finally ++x; --------- 执 行 结 果 --------- 1 运 行 结 果 是 1, 为 什 么 呢? 主 函 数 调 用 子 函 数 并 得 到 结 果 的 过 程, 好 比 主 函 数 准 备 一 个 空 罐 子, 当 子 函 数 要 返 回 结 果 时, 先 把 结 果 放 在 罐 子 里, 然 后 再 将 程 序 逻 辑 返 回 到 主 函 数 所 谓 返 回, 就 是 子 函 数 说, 我 不 运 行 了, 你 主 函 数 继 续 运 行 吧, 这 没 什 么 结 果 可 言, 结 果 是 在 说 这 话 之 前 放 进 罐 子 里 的 39 下 面 的 程 序 代 码 输 出 的 结 果 是 多 少? public class smallt public static void main(string args[])

smallt t = new smallt(); int b = t.get(); System.out.println(b); public int get() try Return 1 ; finally Return 2 ; 返 回 的 结 果 是 2 我 可 以 通 过 下 面 一 个 例 子 程 序 来 帮 助 我 解 释 这 个 答 案, 从 下 面 例 子 的 运 行 结 果 中 可 以 发 现, try 中 的 return 语 句 调 用 的 函 数 先 于 finally 中 调 用 的 函 数 执 行, 也 就 是 说 return 语 句 先 执 行, finally 语 句 后 执 行, 所 以, 返 回 的 结 果 是 2 Return 并 不 是 让 函 数 马 上 返 回, 而 是 return 语 句 执 行 后, 将 把 返 回 结 果 放 置 进 函 数 栈 中, 此 时 函 数 并 不 是 马 上 返 回, 它 要 执 行 finally 语 句 后 才 真 正 开 始 返 回 在 讲 解 答 案 时 可 以 用 下 面 的 程 序 来 帮 助 分 析 : public classtest /** * @paramargs add by zxx,dec 9, 2008 */ public static voidmain(string[] args)

// TODO Auto-generated method stub System.out.println(newTest().test());; int test() try return func1(); finally return func2(); int func1() System.out.println("func1"); return 1; int func2() System.out.println("func2"); return 2; ----------- 执 行 结 果 ----------------- func1 func2

2 结 论 :finally 中 的 代 码 比 return 和 break 语 句 后 执 行 40 final, finally, finalize 的 区 别 final 用 于 声 明 属 性, 方 法 和 类, 分 别 表 示 属 性 不 可 变, 方 法 不 可 覆 盖, 类 不 可 继 承 内 部 类 要 访 问 局 部 变 量, 局 部 变 量 必 须 定 义 成 final 类 型, 例 如, 一 段 代 码 finally 是 异 常 处 理 语 句 结 构 的 一 部 分, 表 示 总 是 执 行 finalize 是 Object 类 的 一 个 方 法, 在 垃 圾 收 集 器 执 行 的 时 候 会 调 用 被 回 收 对 象 的 此 方 法, 可 以 覆 盖 此 方 法 提 供 垃 圾 收 集 时 的 其 他 资 源 回 收, 例 如 关 闭 文 件 等 JVM 不 保 证 此 方 法 总 被 调 用 41 运 行 时 异 常 与 一 般 异 常 有 何 异 同? 异 常 表 示 程 序 运 行 过 程 中 可 能 出 现 的 非 正 常 状 态, 运 行 时 异 常 表 示 虚 拟 机 的 通 常 操 作 中 可 能 遇 到 的 异 常, 是 一 种 常 见 运 行 错 误 java 编 译 器 要 求 方 法 必 须 声 明 抛 出 可 能 发 生 的 非 运 行 时 异 常, 但 是 并 不 要 求 必 须 声 明 抛 出 未 被 捕 获 的 运 行 时 异 常 42 error 和 exception 有 什 么 区 别? error 表 示 恢 复 不 是 不 可 能 但 很 困 难 的 情 况 下 的 一 种 严 重 问 题 比 如 说 内 存 溢 出 不 可 能 指 望 程 序 能 处 理 这 样 的 情 况 exception 表 示 一 种 设 计 或 实 现 问 题 也 就 是 说, 它 表 示 如 果 程 序 运 行 正 常, 从 不 会 发 生 的 情 况 43 Java 中 的 异 常 处 理 机 制 的 简 单 原 理 和 应 用 异 常 是 指 java 程 序 运 行 时 ( 非 编 译 ) 所 发 生 的 非 正 常 情 况 或 错 误, 与 现 实 生 活 中 的 事 件 很 相 似, 现 实 生 活 中 的 事 件 可 以 包 含 事 件 发 生 的 时 间 地 点 人 物 情 节 等 信 息, 可 以 用 一 个 对 象 来 表 示,Java 使 用 面 向 对 象 的 方 式 来 处 理 异 常, 它 把 程 序 中 发 生 的 每 个 异 常 也 都 分 别 封 装 到 一 个 对 象 来 表 示 的, 该 对 象 中 包 含 有 异 常 的 信 息 Java 对 异 常 进 行 了 分 类, 不 同 类 型 的 异 常 分 别 用 不 同 的 Java 类 表 示, 所 有 异 常 的 根 类 为 java.lang.throwable,throwable 下 面 又 派 生 了 两 个 子 类 :Error 和 Exception,Error 表 示 应 用 程 序 本 身 无 法 克 服 和 恢 复 的 一 种 严 重 问 题, 程 序 只 有 死 的 份 了, 例 如, 说 内 存 溢 出 和 线 程 死 锁 等 系 统 问 题 Exception 表 示 程 序 还 能 够 克 服 和 恢 复 的 问 题, 其 中 又 分 为 系 统 异 常 和 普 通 异 常, 系 统 异 常 是 软 件 本 身 缺 陷 所 导 致 的 问 题, 也 就 是 软 件 开 发 人 员 考 虑 不 周 所 导 致 的

问 题, 软 件 使 用 者 无 法 克 服 和 恢 复 这 种 问 题, 但 在 这 种 问 题 下 还 可 以 让 软 件 系 统 继 续 运 行 或 者 让 软 件 死 掉, 例 如, 数 组 脚 本 越 界 (ArrayIndexOutOfBoundsException), 空 指 针 异 常 (NullPointerException) 类 转 换 异 常 (ClassCastException); 普 通 异 常 是 运 行 环 境 的 变 化 或 异 常 所 导 致 的 问 题, 是 用 户 能 够 克 服 的 问 题, 例 如, 网 络 断 线, 硬 盘 空 间 不 够, 发 生 这 样 的 异 常 后, 程 序 不 应 该 死 掉 java 为 系 统 异 常 和 普 通 异 常 提 供 了 不 同 的 解 决 方 案, 编 译 器 强 制 普 通 异 常 必 须 try..catch 处 理 或 用 throws 声 明 继 续 抛 给 上 层 调 用 方 法 处 理, 所 以 普 通 异 常 也 称 为 checked 异 常, 而 系 统 异 常 可 以 处 理 也 可 以 不 处 理, 所 以, 编 译 器 不 强 制 用 try..catch 处 理 或 用 throws 声 明, 所 以 系 统 异 常 也 称 为 unchecked 异 常 提 示 答 题 者 : 就 按 照 三 个 级 别 去 思 考 : 虚 拟 机 必 须 宕 机 的 错 误, 程 序 可 以 死 掉 也 可 以 不 死 掉 的 错 误, 程 序 不 应 该 死 掉 的 错 误 ; 44 请 写 出 你 最 常 见 到 的 5 个 runtime exception 这 道 题 主 要 考 你 的 代 码 量 到 底 多 大, 如 果 你 长 期 写 代 码 的, 应 该 经 常 都 看 到 过 一 些 系 统 方 面 的 异 常, 你 不 一 定 真 要 回 答 出 5 个 具 体 的 系 统 异 常, 但 你 要 能 够 说 出 什 么 是 系 统 异 常, 以 及 几 个 系 统 异 常 就 可 以 了, 当 然, 这 些 异 常 完 全 用 其 英 文 名 称 来 写 是 最 好 的, 如 果 实 在 写 不 出, 那 就 用 中 文 吧, 有 总 比 没 有 强! 所 谓 系 统 异 常, 就 是.., 它 们 都 是 RuntimeException 的 子 类, 在 jdk doc 中 查 RuntimeException 类, 就 可 以 看 到 其 所 有 的 子 类 列 表, 也 就 是 看 到 了 所 有 的 系 统 异 常 我 比 较 有 印 象 的 系 统 异 常 有 :NullPointerException ArrayIndexOutOfBoundsException ClassCastException 45 JAVA 语 言 如 何 进 行 异 常 处 理, 关 键 字 :throws,throw,try,catch,finally 分 别 代 表 什 么 意 义? 在 try 块 中 可 以 抛 出 异 常 吗? throws 捕 获 并 向 外 抛 出 异 常 throw 抛 出 异 常 try catch 是 内 部 捕 获 异 常 并 做 自 定 义 处 理 finally 是 无 论 是 否 有 异 常 都 会 被 处 理 的 语 句, 除 非 在 finally 前 存 在 被 执 行 的 System.exit(int i) 时 除 外 46 java 中 有 几 种 方 法 可 以 实 现 一 个 线 程? 用 什 么 关 键 字 修 饰 同 步 方 法? stop() 和 suspend() 方 法 为 何 不 推 荐 使 用? java5 以 前, 有 如 下 两 种 : 第 一 种 :

new Thread().start(); 这 表 示 调 用 Thread 子 类 对 象 的 run 方 法,new Thread() 表 示 一 个 Thread 的 匿 名 子 类 的 实 例 对 象, 子 类 加 上 run 方 法 后 的 代 码 如 下 : new Thread() public void run().start(); 第 二 种 : new Thread(new Runnable()).start(); 这 表 示 调 用 Thread 对 象 接 受 的 Runnable 对 象 的 run 方 法,new Runnable() 表 示 一 个 Runnable 的 匿 名 子 类 的 实 例 对 象,runnable 的 子 类 加 上 run 方 法 后 的 代 码 如 下 : new Thread(new Runnable() public voidrun() ).start(); 从 java5 开 始, 还 有 如 下 一 些 线 程 池 创 建 多 线 程 的 方 式 : ExecutorService pool = Executors.newFixedThreadPool(3) for(int i=0;i<10;i++) pool.execute(newrunable()public void run()); Executors.newCachedThreadPool().execute(new Runable()publicvoid run()); Executors.newSingleThreadExecutor().execute(new Runable()publicvoid run()); 有 两 种 实 现 方 法, 分 别 使 用 new Thread() 和 new Thread(runnable) 形 式, 第 一 种 直 接 调 用 thread 的 run 方 法, 所 以, 我 们 往 往 使 用 Thread 子 类, 即 new SubThread() 第 二 种 调 用