java.txt

第 一 章 Java语 言 的 产 生 及 其 特 点 第 二 章 Java程 序 开 发 与 运 行 环 境第 三 章 Java程 序 设 计 基 础 第 四 章 Java应 用 程 序 的

3.1.5 表 达 式 
　　Java语 言 的 表 达 式 和C语 言 非 常 类 似。 运 算 符 运 算 符(operator)优 先 级 从 高 到 底 排 列 如 下： . [ ] () ++ -- ! ～ instanceof * / % + - << >> >>> < > <= >\\ == ! = & ^ && || ? : 
= op = , 整 数 运 算 符 在 整 数 运 算 时， 如 果 操 作 数 是long类 型， 则 运 算 结 果 是long类 型， 否 则 为int类 型， 绝 不 会 是byte，short或char型。 这 样， 如 果 变 量i被 声 明 为short或byte，i+1的 结 果 会 是int。 如 果 结 果 超 过 该 类 型 的 取 值 范 围， 则 按 该 类 型 的 最 大 值 取 模。 单 目 整 数 运 算 符 是： 运 算 符 操 作 - 单 目 非 ～ 位 补 码 ++ 加1 -- 减1 ++运 算 符 用 于 表 示 直 接 加1操 作。 增 量 操 作 也 可 以 用 加 运 算 符 和 赋 值 操 作 间 接 完 成。++ lvalue （左 值?copy; 表 示lvalue+=1, ++lvalue 也 表 示lvalue =lvalue +1 (只 要lvalue没 有 副 作 用)。--运 算 符 用 于 表 示 减1操 作。++和--运 算 符 既 可 以 作 为 前 缀 运 算 符， 也 可 以 做 为 后 缀 运 算 符。 双 目 整 数 运 算 符 是： 运 算 符 操 作** + 加 - 减 * 乘 / 除 % 取 模 & 位 与 ｜ 位 或 ^ 位 异 或 << 左 移 >> 右 移(带 符 号) >>> 添 零 右 移 整 数 除 法 按 零 舍 入。 除 法 和 取 模 遵 守 以 下 等 式： ( a/b ) * b + ( a%b ) == a 整 数 算 术 运 算 的 异 常 是 由 于 除 零 或 按 零 取 模 造 成 的。 它 将 引 发 一 个 算 术 异 常。 下 溢 产 生 零， 上 溢 导 致 越 界。 例 如： 加1超 过 整 数 最 大 值， 取 模 后， 变 成 最 小 值。 一 个op=赋 值 运 算 符， 和 上 表 中 的 各 双 目 整 数 运 算 符 联 用， 构 成 一 个 表 达 式。 整 数 关 系 运 算 符<， >，<=，>=，==和!=产 生boolean类 型 的 数 据。 
　　布 尔 运 算 符 布 尔(boolean)变 量 或 表 达 式 的 组 合 运 算 可 以 产 生 新 的boolean值。 单 目 运 算 符!是 布 尔 非。 双 目 运 算 符 ＆， ｜ 和^是 逻 辑AND，OR和XOR运 算 符， 它 们 强 制 两 个 操 作 数 求 布 尔 值。 为 避 免 右 侧 操 作 数 冗 余 求 值， 用 户 可 以 使 用 短 路 求 值 运 算 符 ＆ ＆ 和 ｜ ｜。 用 户 可 以 使 用==和!=， 赋 值 运 算 符 也 可 以 用 &=、|=、^=。 三 元 条 件 操 作 符? : 和C语 言 中 的 一 样。 
　　浮点 运 算 符 浮点 运 算 符 可 以 使 用 常 规 运 算 符 的 组 合： 如 单 目 运 算 符++、--， 双 目 运 算 符+、-、* 和/， 以 及 赋 值 运 算 符+=，-=，*=， 和/=。 此 外， 还 有 取 模 运 算： %和%=也 可 以 作 用 于浮点 数， 例 如： a%b和a-((int) (a/b)*b)的 语 义 相 同。 这 表 示a%b的 结 果 是 除 完 后 剩 下 的浮点 数 部 分。 只 有 单 精 度 操 作 数 的浮点 表 达 式 按 照 单 精 度 运 算 求 值， 产 生 单 精 度 结 果。 如 果浮点 表 达 式 中 含 有 一 个 或 一 个 以 上 的 双 精 度 操 作 数， 则 按 双 精 度 运 算， 结 果 是 双 精 度浮点 数。 
　　数 组 运 算 符 数 组 运 算 符 形 式 如 下： [ ] 可 给 出 数 组 中 某 个 元 素 的 值。 合 法 的 取 值 范 围 是 从0到 数 组 的 长 度 减1。 取 值 范 围 的 检 查 只 在 运 行 时 刻 实 。 运 算 符 以String对 象 实 现。 运 算 符\'+\'完 成 并 操 作， 如 果 必 要 则 自 动 把 操 作 数 转 换 为String型。 如 果 操 作 数 是 一 个 对 象， 它 可 定 义 一 个 方 法toString ( ) 返 回 该 对 象 的String方 式， 例 如 float a = 1.0 print (\'The value of a is\'+ a +\'\\n\'); +运 算 符 用 到 ?reg; 上 的 例 子 String s=\'a=\'+ a; +=运 算 符 也 可 以 用 于String。 注 意， 左 边(下 例 中 的s1)仅 求 值 一 次。 s1+=a; //s1=s1+a //若a非String型， 自 动 转 换 为String型。 对 象 运 算 符 双 目 运 算 符instanceof 测 试 某 个 对 象 是 否 是 指 定 类 或 其 子 类 的 实 例。 例 如： if(myObject instanceof MyClass) { MyClass anothermyObject=( MyClass) myObject; … } 是 判 定myObject是 否 是MyClass的 实 例 或 是 其 子 类 的 实 例。 强 制 和 转 换 Java语 言 和 解 释 器 限 制 使 用 强 制 和 转 换， 以 防 止 出 错 导 致 系 统 崩 溃。 整 数 和浮点 数 之 间 可 以 来 回 
强 制 转 换， 但 整 数 不 能 强 制 转 换 成 数 组 或 对 象。 对 象 不 能 被 强 制 为 基 本 类 型。 
3.1.6 Java流 控 制 
　　下 面 几 个 控 制 结 构 是 从C语 言 借 鉴 的。 分 支 结 构 
　　if/else分 支 结 构 if (Boolean) { statemanets; } else { statements; } 
　　switch分 支 结 构 switch(expr1) { case expr2: statements; break; case expr3: statements; break; default: statements; break; } 
　　循 环 结 构 for循 环 结 构 for (init expr1;test expr2;increment expr3) { statements; } 
　　While循 环 结 构 While(Boolean) { statements; } 
　　Do循 环 结 构 do { statements; } while (Boolean); 
　　一 般 顺 序 控 制 break [label] continue [label] reutrn expr; label:statement; 
　　for循 环 例 子 下 面 是 一 个 程 序 例 子， 画 几 条 线， 分 别 用 红,绿,蓝 颜 色， 这 段 程 序 可 能 是Java函 数 的 一 部 分： int count; for (count=1;count<=12;count++) { switch (count % 3) } case 0: setColor(Color.red); break; case 1: setColor(Color.blue); break; case 2: setColor(Color.green); break; } g.drawLine(10,count*10,80,count*10); } 
3.2 Java变 量 和 函 数 的 实 例 
　　Java的 类 包 含 变 量 和 函 数。 数 据 变 量 可 以 是 一 些 原 始 的 类 型,如int,char等。 成 员 函 数 是 一 些 可 执 行 的 过 程。 例 如,下 面 程 序 里： public class ClassOne { int i; public ClassOne() { i=10; } public void Add_i(int j) { i=i+j; } } ClassOne包 含 一 个 变 量i和 两 个 成 员 函 数,ClassOne(int first)和Add_i(int j)。 
　　成 员 函 数 成 员 函 数 是 一 些 可 被 其 它 类 或 自 己 类 调 用 的 处 理 子 程 序。 一 个 特 殊 的 成 员 函 数 叫 构 造 函 数, 这 个 函 数 名 称 一 般 与 本 类 名 程 相 同。 它 没 有 返 回 值。 构 造 函 数 和 成 员 函 数 当 你 在Java里 定 义 一 个 类 时,你 可 定 义 一 个 或 多 个 可 选 的 构 造 函 数,当 创 建 本 类 的 一 个 对 象 时 用 某 一 个 构 造 函 数 来 初 始 化 本 对 象。 用 前 面 的 程 序 例 子 来 说 明,当ClassOne类 创 建 一 个 新 实 例 时, 所 有 成 员 函 数 和 变 量 被 创 建(创 建 实 例)。 构 造 函 数 被 调 用。 ClassOne mc: mc = new ClassOne(); 
　　关 键 词new用 来 创 建 一 个 类 的 实 例,一 个 类 用new初 始 化 前 并 不 占 用 内 存,它 只 是 一 个 类 型 定 义, 当mc对 象 初 始 化 后,mc对 象 里 的i变 量 等 于10。 你 可 以 通 过 对 象 名 来 引 用 变 量i。(有 时 称 为 实 例 变 量) mc.i++;//mc实 例 变 量 加1 因 为mc有ClassOne类 的 所 有 变 量 和 成 员 函 数， 我 们 可 以 使 用 同 样 的 语 法 来 调 用 成 员 函 数 Add_i： Add_i(10); 现 在mc.i变 量 等 于21. 
　　结 束 函 数 Java并 不 支 持 析 构 函 数(C++里 的 定 义),因 为java本 身 提供 对 象 无 用 时 自 动 清 除 的 功 能,同 时 它 也 提 供了 一 个 自 动 拉 圾 箱 的 成 员 函 数， 在 清 除 对 象 时 被 调 用： Protected void finalize() { close(); } 
3.3 对 象 有 效 范 围 和 废 物 自 动 回 收 对 象 有 一 定 的 生 命 期 并 在 它 的 生 命 期 间 使 用 资 源,当 一 个 对 象 不 再 被 使 用 时,它 应 释 放 内 存, 避 免 内 存 溢 出。 在Java里,收 集 和 释 放 内 存 是 一 个 叫 自 动 废 品 回 收 站 的 线 程 的 责 任。 这 个 线 程 监 视 对 象 有 效 范 围 并 给 一 个 走 出 有 效 范 围 的 对 象 作 上 标 识。 
　　例 如： String s;//没 有 分 配 内 存 s = new String(\'oldstring\');//分 配 内 存 s =\'newstring\';//重 新 分 配 内 存(创 建 新 对 象) 我 们 将 在 以 后 访 问String类 时 将 更 加 明 白 它 的 工 作 过 程,但 它 的 快 速 工 作 过 程 是 这 样 的： 1.创 建 一 个 新 的String类 对 象 并 填 充 以\'oldstring\' 2.创 建 另 一 个String对 象 并 填 充 以\'newstring\' 注 意 我 们 创 建 了 两 个 对 象。 Stirng 对 象 \'oldstring\' Stirng 对 象 \'newstring\' 在 第 三 条 语 句 里,第 一 个 包 括\'oldstring\'的 叫 做s的 对 象 已 走 出 了 有 效 范 围,没 有 任 何 方 法 可 以 再 访 问 他,我 们 现 在 有 一 个 新 的 对 象 也 叫s,包 含\'newstring\'。 在 下 一 个 废 品 回 收 线 程,前 一 个 对 象 将 被 标 识 并 清 除。 
3.4 子 类 
　　子 类 是 利 用 存 在 的 对 象 创 建 一 个 新 对 象 的 机 制,比 如,如 果 你 有 一 个Horse类,你 可 以 创 建 一 个 Zebra子 类,Zebra是Horse的 一 种。 
　　class Zebra extends Horse { int number_OF_stripes: } 关 键 词extends来 定 义 对 象 有 的 子 类.Zebra是Horse的 子 类。Horse类 里 的 所 有 特 征 都 将 拷 贝 到 Zebra类 里,而Zebra类 里 可 以 定 义 自 己 的 成 员 函 数 和 实 例 变 量。Zebra称 为Horse的 派 生 类 或 继 承。 另 外,你 也 许 还 想 覆 盖 基 类 的 成 员 函 数。 用ClassOne说 明,下 面 是 一 个 派 生 类 覆 盖Add_i功 能 的 例 子. 
import ClassOne; public class NewClass extends ClassOne { public void 
Add_i(int j) { i=i+(j/2); } } 
　　当NewClass类 的 实 例 创 建 时,变 量i初 始 化 值 为10,但 调 用Add_i产 生 不 同 的 结 果。 NewClass mnc; mnc=new NewClass(); mnc.Add_i(10); 访 问 控 制 Java里 当 你 创 建 一 个 新 类 时,你 可 以 标 明 变 量 和 成 员 函 数 的 访 问 层 次。 
　　public public void AnyOneCanAccess(){} public实 例 变 量 和 成 员 函 数 可 以 任 意 其 它 类 调 用。 
　　protected protected void OnlySubClasses(){} protected实 例 变 量 和 成 员 函 数 只 能 被 其 子 类 调 用. 
　　private private String CreditCardNumber; private实 例 变 量 和 成 员 函 数 只 能 在 本 类 里 调 用. 
　　friendly void MyPackageMethod(){} 缺 省 的,如 果 没 有 定 义 任 何 防 火 控 制,实 例 变 量 或 函 数 缺 省 定 义 成friendly,意 味 着 可 以 被 本 包 里 的 任 意 对 象 防 问,但 其 它 包 里 的 对 象 不 可 防 问。 静 态 成 员 函 数 和 变 量 有 ?copy; 时 候,你 创 建 一 个 类,希 望 这 个 类 的 所 有 实 例 都 公 用 一 个 变 量。 也 就 是 说,所 有 这 个 类 的 对 象 都 只 有 实 例 变 量 的 同 一 个 拷 贝。 这 种 方 法 的 关 键 词 是static， 例 如： class Block { 　static int number=50; } 
　　所 有 从Block类 创 建 的 对 象 的number变 量 值 都 是 相 同 的。 无 任 在 哪 个 对 象 里 改 变 了number的 值, 所 有 对 象 的number都 跟 着 改 变。 同 样 的,你 可 以 定 义static成 员 函 数,但 这 个 成 员 函 数 不 能 访 问 非static函 数 和 变 量。 class Block { static int number = 50; int localvalue; static void add_local(){ localvalue++;//没 有 运 行 } static void add_static() { number++;//运 行 } } 
3.5 this和super 
　　访 问 一 个 类 的 实 例 变 量 时,this关 键 词 是 指 向 这 个 类 本 身 的 指 针,在 前 面ClassOne例 子 中,我 们 可 以 增 加 构 造 函 数 如 下： 
　　public class ClassOne { int i; public ClassOne() { i = 10; } 
　　public ClassOne (int value) this.i = value; } 
　　public void Add_i(int j) { i = i + j; } } 
　　这 里,this指 向ClassOne类 的 指 针。 如 果 在 一 个 子 类 里 覆 盖 了 父 类 的 某 个 成 员 函 数,但 又 想 调 用 父 类 的 成 员 函 数,你 可 以 用super 关 键 词 指 向 父 类 的 成 员 函 数。 
import ClassOne; public class NewClass extends ClassOne { public void Add_i (int j) { i = i+(j/2); super.Add_i (j); } } 
　　下 面 程 序 里,i变 量 被 构 造 函 数 设 成10,然 后15， 最 后 被 父 类(ClassOne)设 成25。 NewClass mnc; mnc = new NewClass(); mnc.Add_i(10); 
3.6 类 的 类 型 
　　至 今 为 止,我 用 在 类 前 面 只 用 了 一 个public关 键 词,其 实 它 有 下 面4种 选 择：abstract 一 个abstract类 必 须 至 少 有 一 个 虚 拟 函 数,一 个abstract类 不 能 直 接 创 建 对 象,必 须 继 承 子 类 后 才 能。 
　　final 一 个final类 声 明 了 子 类 链 的 结 尾,用final声 明 的 类 不 能 再 派 生 子 类。 public public类 能 被 其 它 的 类 访 问。 在 其 它 包 里,如 果 想 使用 这 个 类 必 须 先import, 则 它 只 能 在 它 定 义 的package里 使 用。 synchronicable 这 个 类 标 识 表 示 所 有 ?copy; 类 的 成 员 函 数 都 是 同 步 的。