yyrm5.html

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

            念。 一 个 类 的 后 代 可 以 继 承 它 的祖 先 的 所 有 变 量 和 成 员 函 数， 就 象 创 建 自 己 的 一 
            样。 一 个类 的 直 接 父 亲 叫 做 它 的 超 类（superclass?copy;。 一 ?copy; 你创 建 了 一 个 
            象University这 样 的 类， 创 建 它 的 子 类 是 很 简 单的。 一 个 类 的 子 类 是 它 的 继 承 了 实 
            例 变 量 和 成 员 函 数 的特 殊 的 版 本。 在 这 个 例 子 里， 我 们 把University类 派 生 为 含 有叫 
            做country的 第 三 个 元 素 的 子 类。 </P>
            <P>class UniversityWorld extends University { String country; 
            UniversityWorld(String name, String city, String country) { 
            this.name = name; this.city = city; this.country = country; } 
            UniversityWorld( ) { this("北 ?copy; 大学", "北 ?copy;", "中 国"); } } 
</P>
            <P>关 键 词extends用 来 表 示 我 们 要 创 建University的 子 类。name和city不需 再 
            在UniversityWorld 中 进 行 声 明， 因 为 它 们 是 从University中继 承 的。Java允 许 
            在UniversityWorld中 声 明 变 量name 和city， 但 这会 隐 藏University中 的name和city， 
            是 与 使 用 子 类 的 目 的 相 矛 盾的， 应 当 避 免。 在 UniversityWorld的 实 例 
            中，name、city和country的地 位 是 一 样 的。 </P>
            <P>5.11 super 在UniversityWorld的 例 子 里， 有 一 段 代 码 和 它 的 超类University的 
            重 复， 这 段 代 码 是 初 始 化 name和city的， </P>
            <P>this.name = name; this.city = city; </P>
            <P>就 象 在University例 子 中 用this指 向 第 一 个 构 造 函 数 一 样，在Java里 有 另 一 个 变 
            量 叫 做 super， 它 直 接 指 向 超 类 的 构 造函 数。 下 面 这 个 例 子 用super来 初 始 化 变 
            量name和city， 然 后 打印 出 这 个 对 象 的 内 容。 </P>
            <P>class UniversityWorld extends University { String country; 
            UniversityWorld(String name, String city, String country) { 
            super(name, city); // 调 用 了 构造 函 数University(name, city) 
            this.country = country; } public static void main(String args[]) { 
            UniversityWorld u = new UniversityWorld("北 ?copy; 大 学", "北 ?copy;", 
            "中 国"); System.out.println("大学：" + u.name + " 城 市：" + u.city + " 国 
            家：" + u.country); } } </P>
            <P>下 面 是 运 行 结 果。 </P>
            <P>C:\&gt;java UniversityWorld 大 学： 北 ?copy; 大 学 城 市： 北 ?copy; 国 家： 
            中 国 </P>
            <H2 align=center>5.12 成 员 函 数 的 覆 盖</H2>
            <P>这 个University的 新 的 子 类 继 承 了 它 的 超 类 的 成 员 函 数samecity。但 这 个 成 员 
            函 数samecity 判 断 的 是 两 个 城 市 的 名 字， 这 是 不够 的， 因 为 有 可 能 两 个 两 个 ?字 一 
            样 的 城 市 属 于 不 同 的国 家， 我 们 要 用 同 时 判 断 城 市 和 国 家 的 成 员 函 数 来 覆 盖它。 下 
            面 就 是 实 现 覆 盖 的 例 子。 </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 UniversityWorld extends University { String country; 
            UniversityWorld(String name, String city, String country) { 
            super(name, city); this.country = country; } boolean samecity(String 
            city, String country) { if (city.equals(u.city) &amp;&amp; 
            country.equals(u.country)) return true; else return false; } boolean 
            samecity(UniversityWorld other) { return distance(other.city, 
            other.country); } } </P>
            <P>class UniversityWorldCity { public static void main(String 
            args[]) { String city = "上海"; String country = "中 国"; 
            UniversityWorld u1 = new UniversityWorld("北 ?copy; 大 学", "北 ?copy;", 
            "中 国"); UniversityWorld u2 = new UniversityWorld("清 华大 学", "北 
            ?copy;", "中 国"); System.out.println("u1 = " + u1.name + ", " + 
            u1.city + ", " + u1.country); System.out.println("u2 = " + u2.name + 
            ", " + u2.city+ ", " + u2.country); System.out.println("city = " + 
            city + ", country = " + country); 
            System.out.println("u1.samecity(u2) = " + u1.samecity(u2)); 
            System.out.println("u1.samecity(city, country) = " + 
            u1.samecity(city, country)); } } </P>
            <P>下 面 是 输 出 结 果。 </P>
            <P>C:\&gt;java UniversityWorldCity u1 = 北 ?copy; 大 学, 北 ?copy;, 中国 
            u2 = 清 华 大 学, 北 ?copy;, 中 国 city = 上海, country = 中 国 u1.samecity(u2) 
            = true u1.samecity(city, country) = false </P>
            <H2 align=center>5.13 动 态 成 员 函 数 发 送 </H2>
            <P>当 你 用 点 操 作 符 调 用 一 个 对 象 实 例 的 成 员 函 数 时， 对象 实 例 所 属 的 类 在 编 译 时 
            要 被 检 查， 以 确 保 调 用 的 成 员函 数 在 该 类 中 是 存 在 的。 在 运 行 时， 对 象 实 例 可 以 指 
            向 所声 明 类 型 的 子 类 的 实 例。 在 这 ?copy; 情 况 下， 如 果 子 类 覆盖 了 要 调 用 的 成 员 函 
            数，Java就 用 实 例 来 决 定 调 用 哪 一 个成 员 函 数。 如 下 面 的 例 子， 两 个 类 是 子 类 和 超 类 
            的 关 系，子 类 覆 盖 了 超 类 的 成 员 函 数。 </P>
            <P>class A { void callme( ) { System.out.println("在A的callme成 员函 数 
            里"); } } </P>
            <P>class B extends A { void callme( ) { 
            System.out.println("在B的callme成员 函 数 里"); } } </P>
            <P>class Dispatch { public static void main(String args[]) { A a = 
            new B( ); a.callme( ); } } </P>
            <P>有 趣 的 是， 在 成 员 函 数main里， 我 们 把 变 量a声 明 为 类 型A，然 后 把 类B的 一 个 实 例 存 
            放 到 它 上 面。 我 们 在a上 调 用 成 员函 数callme，Java编 译 器 确 定 在 类A确 实 有 成 员 函 
            数callme， 但 是在 运 行 时， 由 于a事 实 上 是B的 实 例， 所 以 调 用B的callme， 而 不调 用A的。 下 
            面 是 运 行 结 果： </P>
            <P>C:\&gt;java Dispatch 在B的callme成 员 函 数 里 </P>
            <H2 align=center>5.14 final </H2>
            <P>在 缺 省 情 况 下， 所 有 的 成 员 函 数 和 实 例 变 量 都 可 以 被覆 盖。 如 果 你 希 望 你 的 变 
            量 或 成 员 函 数 不 再 被 子 类 覆 盖，可 以 把 它 们 声 明 为final。 这 意 味 着 将 来 的 实 例 都 
            依 赖 这 个定 义。 例 如： </P>
            <P>final int FILE_NEW = 1; final int FILE_OPEN = 2; final int 
            FILE_SAVE = 3; fianl int FILE_SAVEAS = 4; final int FILE_QUIT = 5; 
            </P>
            <P>final变 量 用 大 写 标 识 符 是 一 个 一 般 的 约 定。 </P>
            <H2 align=center>5.15 静 态 </H2>
            <P>如 果 你 想 要 创 建 一 个 可 以 在 实 例 的 外 部 调 用 的 成 员 函数， 那 么 你 只 需 声 明 它 为 
            静 态 的 （static?copy;， 它 就 会 正常 运 行。 静 态 成 员 函 数 只 能 直 接 调 用 其 他 静 态 成 
            员 函 数，而 不 能 以 任 何 方 式 使 用this或super。 你 也 可 以 把 变 量 声 明 为静 态 的。 如 果 你 
            想 初 始 化 一 个 静 态 变 量， 你 可 以 用 static声明 一 个 恰 好 在 类 调 用 时 执 行 一 次 的 程 
            序 块。 下 面 的 例 子是 一 个 带 有 一 个 静 ?成 员 函 数， 几 个 静 态 变 量， 和 一 个 静态 初 始 块 
            的 类。 </P>
            <P>class Static { static int a = 3; static int b; static void 
            method(int x) { System.out.println("x = " + x); 
            System.out.println("a = " + a); System.out.println("b = " + b); } 
            static { System.out.println("静态 初 始 块"); b = a * 4; } public static 
            void main(String args[]) { method(42); } } </P>
            <P>一 ?copy; 这 个 类 被 调 用， 所 有 的 静 态 变 量 都 被 初 始 化，a被赋 为3， 然 后 运 
            行static块， 这 将 打 印 出 一 段 消 息， 并 且 把b赋为a*4， 即12。 然 后 解 释 器 调 用main成 员 
            函 数， 它 调 用 了 成 员函 数 method， 参 数x为42。 这 三 个println语 句 打 印 了 两 个 静 态 
            变量a、b和 局 部 变 量x。 下 面 是 运 行 结 果： </P>
            <P>C:\&gt;java Static 静 态 初 始 块 x = 42 a = 3 b = 12 </P>
            <P>一 个 静 态 成 员 函 数 可 以 通 过 它 所 属 的 类 名 来 调 用。 象调 用 实 例 变 量 一 样， 你 可 
            以 用 点 操 作 符 通 过 类 名 来 调 用静 态 成 员 函 数 和 静 态 变 量。Java就 是 这 样 实 现 了 全 局 
            函 数和 全 局 变 量。 下 面 的 例 子 里， 我 们 创 建 了 带 有 一 个 静 态 成员 函 数 和 两 个 静 态 变 
            量 的 类。 第 二 个 类 可 以 通 过 名 字 直接 来 调 用 第 一 个 类 的 静 态 成 员 函 数 和 静 态 变 量。 
            </P>
            <P>class staticClass { static int a = 42; static int b = 99; static 
            void callme( ) { System.out.println("a = " + a); } } </P>
            <P>class StaticByName { public static void main(String args[]) { 
            StaticClass.callme( ); System.out.println("b = " + staticClass.b); } 
            } </P>
            <P>下 面 是 运 行 结 果： </P>
            <P>C:\&gt;java staticByName a = 42 b = 99 </P>
            <H2 align=center>5.16 抽 象 </H2>
            <P>有 时 你 需 要 定 义 一 个 给 出 抽 象 结 构、 但 不 给 出 每 个 成员 函 数 的 完 整 实 现 的 类。 
            如 果 某 个 成 员 函 数 没 有 完 整 实现， 必 须 要 由 子 类 来 覆 盖， 你 可 把 它 声 明 为 抽 
            象（abstract?copy; 型。 含 有 抽 象 型 成 员 函 数 的 类 必 须 声 明 为 抽 象 的。 为 了 把一 个 
            类 声 明 为 抽 象 的， 你 只 需 在 类 定 义 的class关 键 词 前 放置 关 键 词abstract。 这 
            ?copy; 类 不 能 直 接 用new操 作 符 生 成 实例， 因 为 它 们 的 完 整 实 现 还 没 有 定 义。 你 不 
            能 定 义 抽 象 的构 造 函 数 或 抽 象 的 静 态 成 员 函 数。 抽 象 类 的 子 类 或 者 实现 了 它 的 超 类 
            的 所 有 抽 象 的 成 员 函 数， 或 者 也 被 声 明 为抽 象 的。 下 面 例 子 是 一 个 带 有 抽 象 成 员 函 
            数 的 类， 其 后 是一 个 实 现 了 该 成 员 函 数 的 类。 </P>
            <P>abstract class A { abstract void callme( ) ; void metoo( ) { 
            system.out.println("在A的metoo成员 函 数 里"); } } </P>
            <P>class B extends A { void callme( ) { 
            System.out.println("在B的callme成员 函 数 里"); } } </P>
            <P>class Abstract { public static void main(String args[]) { A a = 
            new B( ); a.callme( ); a.metoo( ); } } </P>
            <P>下 面 是 运 行 结 果： </P>
            <P>C:\&gt;java Abstract 在B的callme成 员 函 数 里 在A的metoo成 员 函 数里 </P>
            <H2 align=center>本 章 小 结 </H2>
            <P>1. 类 是Java语 言 面 向 对 象 编 程 的 基 本 元 素， 它 定 义 了 一个 对 象 的 结 构 和 功 能。 
            2. Java通 过 在 类 定 义 的 大 括 号 里 声明 变 量 来 把 数 据 封 装 在 一 个 类 里， 这 里 的 变 量 
            称 为 实 例变 量。 3. 成 员 函 数， 是 类 的 功 能 接 口， 是 类 定 义 里 的 一 个子 程 序， 在 类 的 定 
            义 里 和 实 例 变 量 处 于 同 一 级 别。 </P></TD>
        <TR>
        <TR>
          <TD bgColor=#f0f0f0 borderColor=#ffffff class=t1 noWrap 
            width="50%"><IMG height=12 src="yyrm5.files/yellow_dot.gif" 
            width=12><A 
            href="http://www.chinajavaworld.net/doc/yyrm/yyrm4.html">上一章</A> </TD>
          <TD bgColor=#f0f0f0 borderColor=#ffffff class=t1 noWrap 
            width="50%"><IMG height=12 src="yyrm5.files/blue_dot.gif" 
            width=12><A 
            href="http://www.chinajavaworld.net/doc/yyrm/yyrm6.html">下一章</A> </TD>
        <TR></TR></TBODY></TABLE></TD></TR></TBODY></TABLE><!--end first table --><!--  start foot -->
<SCRIPT src="yyrm5.files/foot1.js"></SCRIPT>

<SCRIPT src="yyrm5.files/adsindex.js"></SCRIPT>

<SCRIPT src="yyrm5.files/foot2.js"></SCRIPT>
<!--  end foot --></CENTER></BODY></HTML>