yyrm5.html

关于java学习的一些基本知识！

            <P>操 作 符new用 来 生 成 一 个 类 的 实 例， 下 面 这 个 例 子 生 成 了类University的 一 个 实 
            例， 存 放 在 变 量u中。 </P>
            <P>University u = new University( ); </P>
            <P>在 此 例 中， 变 量u指 向 这 个 对 象， 但 并 不 真 正 包 含 这 个 对象。 你 可 以 用 多 个 变 量 指 
            向 同 一 个 对 象。 下 面 的 例 子 中，创 建 了 一 个University的 对 象， 但 创 建 了 两 个 指 向 它 
            的 变 量。 </P>
            <P>University u = new University(); University u2 = u; </P>
            <P>对u2所 指 向 的 对 象 的 任 何 改 动 都 会 对u所 指 向 的 对 象 起 作用， 因 为 它 们 是 同 一 个 
            对 象。 对u和u2的 赋 值 只 是 把 它 们 指向 这 个 对 象， 既 没 有 分 配 内 存， 也 没 有 复 制 这 个 对 
            象 的 任何 部 分。 对u的 再 赋 值 只 是 简 单 地 去 掉 了u和 原 来 对 象 的 联系， 并 不 影 响 对 象 本 
            身， 下 面 的 例 子 说 明 了 这 种 情 况。 </P>
            <P>University u = new University( ); University u2 = u; u = null; 
            </P>
            <P>尽管u被 赋 值 为null，u2仍 指 向 原 来 由 操 作 符new创 建 的 对 象。在 前 面 的 例 子 里， 我 们 
            生 成 了 一 个 对 象 并 且 指 向 了 它 两次。 这 就 允 许 两 个 变 量 改 变 同 一 个 对 象。 创 建 一 个 
            新 的 对象 时， 可 直 接 对 它 的 实 例 变 量 赋 值。 每 个 对 象 都 有 它 所 属类 的 实 例 变 量 的 拷 
            贝， 每 个 对 象 的 实 例 变 量 都 是 和 其 他对 象 的 实 例 变 量 分 离 的， 所 以 改 变 一 个 对 象 的 
            实 例 变 量不 会 影 响 其 他 对 象 的 实 例 变 量。 下 面 的 例 子 创 建 了 两 个University的对 象， 
            并 对 它 们 分 别 赋 值： </P>
            <P>class TwoUniversity { public static void main(String args[]) { 
            University u1 = new University( ); University u2 = new University( 
            ); u1.name = "北 ?copy; 大 学"; u1.city = "北 ?copy;"; u2.name = "清华 大 
            学"; u2.city = "北 ?copy;"; System.out.println("大学：" + u1.name + " 城 
            市：" + u1.city); System.out.println("大学：" + u2.name + " 城 市：" + 
            u2.city); } } </P>
            <P>这 个 例 子 创 建 了 两 个University的 对 象， 并 且 对 它 们 的name、city分别 赋 了 不 同 
            的 值， 这 说 明 这 两 个 对 象 是 真 正 分 离 的。 下 面是 该 程 序 运 行 后 的 输 出 结 果。 </P>
            <P>C:\&gt;java TwoUniversity 大 学： 北 ?copy; 大 学 城 市： 北 ?copy; 大 学： 清 
            华 大 学 城 市： 北 ?copy; </P>
            <H2 align=center>5.4 点（.?copy; 操 作 符</H2>
            <P>点（.?copy; 操 作 符 用 来 接 收 一 个 对 象 的 实 例 变 量 和 成 员函 数。 下 面 是 用 点 操 作 
            符 来 接 收 实 例 变 量 的 一 般 形 式。 </P>
            <P>objectreference.variablename </P>
            <P>这 里objectreference是 一 个 对 象 实 例，variablename是 这 个 对 象里 你 想 接 收 的 
            实 例 变 量。 下 面 的 程 序 段 说 明 了 怎 样 用 点操 作 符 来 给 实 例 变 量 赋 值。 </P>
            <P>u.name = "北 ?copy; 大 学"; u.city = "北 ?copy;"; </P>
            <P>下 面 说 明 怎 样 用 点 操 作 符 来 得 到 实 例 变 量 的 值。 </P>
            <P>System.out.println("大 学：" + u.name + " 城 市：" + u.city); </P>
            <P>通 过 向 类University里 加 入 一 个 成 员 函 数main， 我 们 创 建 了一 个 完 整 的 例 子， 它 
            使 用 了new 操 作 符 来 创 建 一 个University，用 点 操 作 符 来 赋 值， 然 后 打 印 结 果。 
</P>
            <P>class University { String name, city; public static void 
            main(String args[]) { University u = new University( ); u.name = "北 
            ?copy; 大学"; u.city = "北 ?copy;"; System.out.println("大学：" + u.name + 
            " 城 市：" + u.city); } } </P>
            <P>运 行 这 个 程 序 后， 就 会 得 到 下 面 的 结 果。 </P>
            <P>C:\&gt;java University 大 学： 北 ?copy; 大 学 城 市： 北 ?copy; </P>
            <H2 align=center>5.5 成 员 函 数 定 义 </H2>
            <P>成 员 函 数， 是 类 的 功 能 接 口， 是 类 定 义 里 的 一 个 子 程 序，在 类 的 定 义 里 和 实 例 变 
            量 处 于 同 一 级 别。 你 必 须 通 过 一个 类 的 实 例 来 调 用 成 员 函 数。 成 员 函 数 可 以 不 用 点 
            操 作符 而 直 接 使 用 实 例 变 量。 成 员 函 数 带 有 输 入 参 数， 具 有 某种 类 型 的 返 回 值。 成 员 
            函 数 定 义 的 一 般 形 式 如 下： </P>
            <P>type methodname ( formal-parameter-list ) { method-body; } </P>
            <P>这 里type指 的 是 成 员 函 数 的 返 回 值 的 类 型， 如 果 没 有 返回 值， 就 用 无 
            值（void?copy; 类 型。 methodname可 以 是 任 何 合 法的 标 识 符， 但 不 能 与 当 前 的 类 名 
            相 同。formal-parameter-list是用 逗 号 分 隔 的 类 型、 标 识 符 对 的 序 列。 如 果 没 有 参 
            数， 括号 里 就 是 空 的。 还 是 用 我 们 的University的 例 子， 下 面 的 成 员函 数 用 来 初 始 化 
            两 个 实 例 变 量。 成 员 函 数 是 在 类 的 大 括号 ?reg; 内 定 义 的， 和 实 例 变 量 所 处 的 范 围 
            相 同。 </P>
            <P>class University { String name, city; void init(String a, String 
            b) { name = a; city = b; } } </P>
            <P>注 意， 我 们 这 里 直 接 给name和city赋 值， 而 没 有 象 以 前 那 样用u1.name。 这 是 因 为 
            每 个 成 员 函 数 都 在 类 的 个 别 实 例 内 执行。 我 们 创 建 的 类 的 实 例 具 有 它 自 己 的 实 例 
            变 量， 所 以 成员 函 数 可 直 接 使 用 它 们。 </P>
            <H2 align=center>5.6 成 员 函 数 调 用 </H2>
            <P>可 以 用 点（.?copy; 操 作 符 来 调 用 一 个 类 的 实 例 的 成 员 函数。 成 员 函 数 调 用 的 一 
            般 形 式 如 下： </P>
            <P>objectreference.methodname( parameter-list ); </P>
            <P>这 里，objectreference是 指 向 某 个 对 象 的 变 
            量，methodname是objectreference所属 类 的 一 个 成 员 函 数，parameter-list是 用 逗 号 
            分 隔 的 变 量 或表 达 式 的 序 列， 它 们 要 与 该 成 员 函 数 的 定 义 的 参 数 个 数及 类 型 匹 配。 
            在 这 个 例 子 里， 我 们 可 以 对 任 何University对 象调 用 成 员 函 数init来 给name和city赋 
            值。 下 面 的 程 序 段 说 明 了怎 样 完 成 这 个 工 作。 </P>
            <P>University u = new University( ); u.init("北 ?copy; 大 学", "北 
            ?copy;"); </P>
            <P>这 个 例 子 创 建 了University的 一 个 实 例， 存 放 在u中。 通 过 点操 作 符 来 调 用 这 个 实 
            例 的init 成 员 函 数， 把"北 ?copy; 大学"和"北 ?copy;"分 别 传 递 给 参 数a和b。 在init成 
            员函 数 内 部，name和city 直 接 指 向u所 指 向 的 对 象 的 实 例 变 量。把name 赋 值 为"北 
            ?copy; 大 学"，city赋 值 为"北 ?copy;"，然 后 返 回。 在 这 个 例 子 里，init被 定 义 为 无 
            值（void?copy; 返回 类 型。 在 进 行 这 个 成 员 函 数 调 用 后，u指 向 ?个name值 和city值改 变 
            了 的University对 象。 </P>
            <H2 align=center>5.7 this </H2>
            <P>Java有 一 个 特 殊 的 实 例 值 叫this， 它 用 来 在 一 个 成 员 函 数内 部 指 向 当 前 的 对 
            象。 在 前 面 的 例 子 里， 我 们 调 用u.init，一 ?copy; 进 入init成 员 函 数 内 部，this就 会 
            指 向u所 指 向 的 对 象。在Java里， 在 同 一 个 范 围 定 义 两 个 相 同 名 字 的 局 部 变 量 是不 可 以 
            的。 有 趣 的 是， 局 部 变 量、 成 员 函 数 的 参 数 可 以 和实 例 变 量 的 名 字 相 同。 前 面 我 们 没 
            有 用name和city作 为 成 员函 数init的 参 数 名 字， 因 为 这 样 它 们 在 成 员 函 数 的 范 围 里就 
            把 实 例 变 量name和city隐 藏 了， 即name指 向 参 数name， 隐 藏 了实 例 变 量name。this让 我 
            们 可 以 直 接 指 向 对 象 本 身。 下 面 是另 一 个 版 本 的 init， 用name和city作 为 参 数 名 字， 
            用this来 接 收当 前 对 象 的 实 例 变 量。 </P>
            <P>void init(String name, String city) { this.name = name; this.city 
            = city; } </P>
            <P>下 面 是 带 有 新 的init初 始 成 员 函 数 的TwoUniversity例 子。 </P>
            <P>class University { String name, city; void init(String name, 
            String city) { this.name = name; this.city = city; } } </P>
            <P>class TwoUniversityInit { public static void main(String args[]) 
            { University u1 = new University( ); University u2 = new University( 
            ); u1.init("北 ?copy; 大 学", "北 ?copy;"); u2.init("清 华 大 学", "北 
            ?copy;"); System.out.println("大 学：" + u1.name + " 城 市：" + u1.city); 
            system.out.println("大 学：" + u2.name + " 城 市：" + u2.city); } } </P>
            <H2 align=center>5.8 构 造 函 数（Constructor?copy; </H2>
            <P>每 创 建 一 个 类 的 实 例 都 去 初 始 化 它 的 所 有 变 量 是 乏 味的。 如 果 一 个 对 象 在 被 创 
            建 时 就 完 成 了 所 有 的 初 始 工 作，将 是 简 单 的 和 简 洁 的。 因 此，Java在 类 里 提 ?copy; 
            了 一 个 特殊 的 成 员 函 数， 叫 做 构 造 函 数（Constructor?copy;。 一 个 构 造函 数 是 对 象 
            被 创 建 时 初 始 对 象 的 成 员 函 数。 它 具 有 和 它所 在 的 类 完 全 一 样 的 名 字。 一 ?copy; 
            定 义 好 一 个 构 造 函 数，创 建 对 象 时 就 会 自 动 调 用 它。 构 造 函 数 没 有 返 回 类 型， 即使 
            是void类 型 也 没 有。 这 是 因 为 一 个 类 的 构 造 函 数 的 返 回值 的 类 型 就 是 这 个 类 本 身。 
            构 造 函 数 的 任 务 是 初 始 一 个对 象 的 内 部 状 态， 所 以 用new操 作 符 创 建 一 个 实 例 后， 立 
            刻就 会 得 到 一 个 清 楚、 可 用 的 对 象。 下 面 这 个 例 子 里， 用 构造 函 数 取 代 了 成 员 函 
            数init。 </P>
            <P>class University { String name, city; University(String name, 
            String city) { this.name = name; this.city = city; } } </P>
            <P>class UniversityCreate { public static void main(String args[]) { 
            University u = new University("北 ?copy; 大 学", "北 ?copy;"); 
            System.out.println("大 学：" + u.name + " 城 市：" + u.city); } } </P>
            <P>new语 句 中 类 名 后 的 参 数 是 传 给 构 造 函 数 的。 </P>
            <H2 align=center>5.9 成 员 函 数 重 载</H2>
            <P>对 于 几 个 意 义 相 近 的 成 员 函 数， 有 时 使 用 相 同 的 名 字便 于 理 解。 因 此，Java语 言 
            实 现 了 成 员 函 数 重 载， 即 可 以 创建 几 个 名 字 相 同、 参 数 不 同 的 成 员 函 数。 成 员 函 数 
            重 载 提 ?copy; 了Java的 多 态 行 为。 下 面 的 例 子 用 到 了 重 载。 </P>
            <P>class University { String name, city; University(String name, 
            String city) { this.name = name; this.city = city; } University( ) { 
            name = "北 ?copy; 大 学"; city = "北 ?copy;"; } } </P>
            <P>class UniversityCreateAlt { public static void main(String 
            args[]) { University u = new University( ); System.out.println("大 
            学：" + u.name + " 城 市：" + u.city); } } </P>
            <P>这 个 例 子 创 建 了 一 个University对 象， 调 用 了 第 二 个 构 造函 数。 下 面 是 它 的 运 行 
            结 果。 </P>
            <P>C:\&gt;java UniversityCreateAlt 大 学： 北 ?copy; 大 学 城 市： 北 ?copy; 
            </P>
            <P>一 个 构 造 函 数 可 以 调 用 另 一 个 构 造 函 数 来 创 建 实 例。例 如： </P>
            <P>class University { String name, city; University(String name, 
            String city) { this.name = name; this.city = city; } University( ) { 
            this("北 ?copy; 大 学", "北 ?copy;"); } } </P>
            <P>第 二 个 构 造 函 数 调 用 了 第 一 个 构 造 函 数 来 完 成 实 例 的初 始 化。 你 也 可 以 用 重 载 
            来 创 建 一 般 的 成 员 函 数。 下 面 这个 例 子 里 有University类 的 两 个 版 本 的 samecity成 
            员 函 数。samecity判断 一 个 大 学 是 否 在 一 个 城 市 里 或 一 个 大 学 和 另 一 个 大 学是 否 在 
            同 一 个 城 市 里。 一 个 成 员 函 数 用city作 参 数， 另 一 个用University对 象 作 参 数。 </P>
            <P>class University { String name, city; University(String name, 
            String city) { this.name = name; this.city = city; } boolean 
            samecity(String city) { if (city.equals(this.city)) return true; 
            else return false; } boolean samecity(University u) { return 
            samecity(u.city); } } </P>
            <P>class UniversityCity { public static void main(String args[]) { 
            String city = "上海"; University u1 = new University("北 ?copy; 大 学", 
            "北 ?copy;"); University u2 = new University("清华 大 学", "北 ?copy;"); 
            System.out.println("u1 = " + u1.name + ", " + u1.city); 
            System.out.println("u2 = " + u2.name + ", " + u2.city); 
            System.out.println("city = " + city); 
            System.out.println("u1.samecity(u2) = " + u1.samecity(u2)); 
            System.out.println("u1.samecity(city) = " + u1.samecity(city)); } } 
            </P>
            <P>下 面 是 该 程 序 的 运 行 结 果。 </P>
            <P>C:\&gt;java UniversityCity u1 = 北 ?copy; 大 学, 北 ?copy; u2 = 清华 大 
            学, 北 ?copy; city = 上海 u1.samecity(u2) = true u1.samecity(city) = 
            false </P>
            <H2 align=center>5.10 继 承 </H2>
            <P>第 二 个 基 本 的 面 向 对 象 机 制 是 继 承。 继 承 是 关 于 有 层次 关 系 的 类 ?reg; 间 的 概