yyrm3.html

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

            为mc有ClassOne类的 所 有 变 量 和 成 员 函 数， 我 们 可 以 使 用 同 样 的 语 法 来 调用 成 员 函 数 
            Add_i： Add_i(10); 现 在mc.i变 量 等 于21. </P>
            <P>结 束 函 数 Java并 不 支 持 析 构 函 数(C++里 的 定 义),因 为java本身 提 ?copy; 对 象 无 
            用 时 自 动 清 除 的 功 能,同 时 它 也 提 ?copy; 了 一 个 自 动 拉 圾 箱 的 成 员 函 数， 在 清 除 
            对 象 时 被 调 用： Protected void finalize() { close(); } </P>
            <H2 align=center>3.3 对 象 有 效 范 围 和 废 物 自 动 回 收 </H2>
            <P>对 象 有 一 定 的 生 命 期 并 在 它 的 生 命 期 间 使 用 资 源,当 一个 对 象 不 再 被 使 用 时,它 
            应 释 放 内 存, 避 免 内 存 溢 出。 在Java里,收集 和 释 放 内 存 是 一 个 叫 自 动 废 品 回 收 站 的 
            线 程 的 责 任。这 个 线 程 监 视 对 象 有 效 范 围 并 给 一 个 走 出 有 效 范 围 的 对象 作 上 标 识。 
            </P>
            <P>例 如： String s;//没 有 分 配 内 存 s = new String("oldstring");//分配 内 存 
            s ="newstring";//重 新 分 配 内 存(创 建 新 对 象) </P>
            <P>我 们 将 在 以 后 访 问String类 时 将 更 加 明 白 它 的 工 作 过 程,但它 的 快 速 工 作 过 程 是 
            这 样 的： 1.创 建 一 个 新 的String类 对 象并 填 充 以"oldstring" 2.创 建 另 一 个String对 
            象 并 填 充以"newstring" 注 意 我 们 创 建 了 两 个 对 象。 Stirng 对 象 "oldstring" 
            Stirng 对 象 "newstring" </P>
            <P>在 第 三 条 语 句 里,第 一 个 包 括"oldstring"的 叫 做s的对 象 已 走 出 了 有 效 范 围,没 有 
            任 何 ?法 可 以 再 访 问 他,我 们现 在 有 一 个 新 的 对 象 也 叫s,包 含"newstring"。 在 下 一个 
            废 品 回 收 线 程,前 一 个 对 象 将 被 标 识 并 清 除。 </P>
            <H2 align=center>3.4 子 类 </H2>
            <P>子 类 是 利 用 存 在 的 对 象 创 建 一 个 新 对 象 的 机 制,比 如,如果 你 有 一 个Horse类,你 可 
            以 创 建 一 个 Zebra子 类,Zebra是Horse的 一种。 </P>
            <P>class Zebra extends Horse { int number_OF_stripes: } </P>
            <P>关 键 词extends来 定 义 对 象 有 的 子 类.Zebra是Horse的 子 类。Horse类里 的 所 有 特 征 
            都 将 拷 贝 到 Zebra类 里,而Zebra类 里 可 以 定 义 自己 的 成 员 函 数 和 实 例 变 量。Zebra称 
            为Horse的 派 生 类 或 继 承。另 外,你 也 许 还 想 覆 盖 基 类 的 成 员 函 数。 用ClassOne说 明,下 
            面是 一 个 派 生 类 覆 盖Add_i功 能 的 例 子. </P>
            <P>import ClassOne; public class NewClass extends ClassOne { public 
            void Add_i(int j) { i=i+(j/2); } } </P>
            <P>当NewClass类 的 实 例 创 建 时,变 量i初 始 化 值 为10,但 调 用Add_i产生 不 同 的 结 果。 
            NewClass mnc; mnc=new NewClass(); mnc.Add_i(10); </P>
            <P>访 问 控 制 Java里 当 你 创 建 一 个 新 类 时,你 可 以 标 明 变 量 和成 员 函 数 的 访 问 层 次。 
            </P>
            <P>public public void AnyOneCanAccess(){} public实 例 变 量 和 成 员函 数 可 以 
            任 意 其 它 类 调 用。 </P>
            <P>protected protected void OnlySubClasses(){} protected实 例 变 量 和成 员 
            函 数 只 能 被 其 子 类 调 用. </P>
            <P>private private String CreditCardNumber; private实 例 变 量 和 成员 函 数 
            只 能 在 本 类 里 调 用. </P>
            <P>friendly void MyPackageMethod(){} 缺 省 的,如 果 没 有 定 义 任 何防 火 控 制,实 
            例 变 量 或 函 数 缺 省 定 义 成friendly,意 味 着 可 以被 本 包 里 的 任 意 对 象 防 问,但 其 它 包 
            里 的 对 象 不 可 防 问。 </P>
            <P>静 态 成 员 函 数 和 变 量 有 ?copy; 时 候,你 创 建 一 个 类,希 望这 个 类 的 所 有 实 例 都 公 
            用 一 个 变 量。 也 就 是 说,所 有 这 个类 的 对 象 都 只 有 实 例 变 量 的 同 一 个 拷 贝。 这 种 方 法 
            的 关键 词 是static， 例 如： </P>
            <P>class Block { static int number=50; } </P>
            <P>所 有 从Block类 创 建 的 对 象 的number变 量 值 都 是 相 同 的。 无任 在 哪 个 对 象 里 改 变 
            了number的 值, 所 有 对 象 的number都 跟 着改 变。 同 样 的,你 可 以 定 义static成 员 函 数,但 
            这 个 成 员 函 数 不能 访 问 非static函 数 和 变 量。 </P>
            <P>class Block { static int number = 50; int localvalue; static void 
            add_local(){ localvalue++;//没 有 运 行 } static void add_static() { 
            number++;//运行 } } </P>
            <H2 align=center>3.5 this和super </H2>
            <P>访 问 一 个 类 的 实 例 变 量 时,this关 键 词 是 指 向 这 个 类 本 身的 指 针,在 前 
            面ClassOne例 子 中,我 们 可 以 增 加 构 造 函 数 如 下： </P>
            <P>public class ClassOne { int i; public ClassOne() { i = 10; } </P>
            <P>public ClassOne (int value) this.i = value; } </P>
            <P>public void Add_i(int j) { i = i + j; } } </P>
            <P>这 里,this指 向ClassOne类 的 指 针。 如 果 在 一 个 子 类 里 覆 盖 了父 类 的 某 个 成 员 函 
            数,但 又 想 调 用 父 类 的 成 员 函 数,你 可 以用super 关 键 词 指 向 父 类 的 成 员 函 数。 </P>
            <P>import ClassOne; public class NewClass extends ClassOne { public 
            void Add_i (int j) { i = i+(j/2); super.Add_i (j); } } </P>
            <P>下 面 程 序 里,i变 量 被 构 造 函 数 设 成10,然 后15， 最 后 被 父 类(ClassOne)设成25。 
            </P>
            <P>NewClass mnc; mnc = new NewClass(); mnc.Add_i(10); </P>
            <H2 align=center>3.6 类 的 类 型 </H2>
            <P>至 今 为 止,我 用 在 类 前 面 只 用 了 一 个public关 键 词,其 实 它有 下 面4种 选 择： </P>
            <P>abstract 一 个abstract类 必 须 至 少 有 一 个 虚 拟 函 数,一 个abstract类不 能 直 接 创 
            建 对 象,必 须 继 承 子 类 后 才 能。 </P>
            <P>final 一 个final类 声 明 了 子 类 链 的 结 尾,用final声 明 的 类 不能 再 派 生 子 类。 
</P>
            <P>public public类 能 被 其 它 的 类 访 问。 在 其 它 包 里,如 果 想 使用 这 个 类 必 须 
            先import,否 则 它 只 能 在 它 定 义 的package里 使 用。 </P>
            <P>synchronicable 这 个 类 标 识 表 示 所 有 ?copy; 类 的 成 员 函 数都 是 同 步 的。 
</P>
            <H2 align=center>3.7 抽 象 类 </H2>
            <P>面 向 对 象 的 一 个 最 大 优 点 就 是 能 够 定 义 怎 样 使 用 这 个类 而 不 必 真 正 定 义 好 成 
            员 函 数。 如 果 程 序 由 不 同 的 用 户实 现 时 是 很 有 用 的， 这 不 需 用 户 使 用 相 同 的 成 员 函 
            数 名。 </P>
            <P>在java里Graphics类 里 一 个abstract类 的 例 子 如 下： public abstract class 
            Graphics { public abstract void drawLine(int x1,int y1,int x2, int 
            y2); public abstract void drawOval(int x,int y,int width, int 
            height); public abstract void drawRect(int x,int y,int width, int 
            height); ... } </P>
            <P>在Graphics类 里 声 明 了 几 个 成 员 函 数,但 成 员 函 数 的 实 际 代码 是 在 另 外 一 
            ?copy; 地 方 实 现 的。 </P>
            <P>public class MyClass extends Graphics { public void drawLine (int 
            x1,int y1,int x2,int y2) { &lt;画 线 程 序 代 码&gt; } } </P>
            <P>当 一 个 类 包 含 一 个abstract成 员 函 数,这 个 类 必 须 定 义 为abstract类。然 而 并 不 
            是abstract类 的 所 有 的 成 员 函 数 都 是abstract的。Abstract类不 能 有 私 有 成 员 函 数(它 
            们 不 能 被 实 现),也 不 能 有 静 态 成 员函 数。 </P>
            <H2 align=center>3.8 接 口</H2>
            <P>当 你 确 定 多 个 类 的 操 作 方 式 都 很 相 象 时，abstract成 员 函数 是 很 有 用 的。 但 如 果 
            你 需 要 使 用 这 ?copy;abstract成 员 函数， 必 须 创 建 一 个 新 类， 这 样 有 时 很 繁 琐。 接 
            口 提 ?copy; 了 一 种 抽 象 成 员 函 数 的 有 利 方 法。 一 个 接 口 包 含 了 在 另一 个 地 方 实 现 
            的 成 员 函 数 的 收 集。 成 员 函 数 在 接 口 里 定义 为public和 abstract。 接 口 里 的 实 例 变 
            量 是public,static和final。接 口 和 抽 象 的 主 要 区 别 是 一 个 接 口 提 ?copy; 了 封 装 
            成 员函 数 协 议 的 方 法 而 不 必 强 迫 用 户 继 承 类。 </P>
            <P>例 子： public interface AudiClip { //Start playing the clip. void 
            play(); //Play the clip in a loop. void loop(); //Stop playing the 
            clip void stop(); } </P>
            <P>想 使 用Audio Clip接 口 的 类 使 用implenents关 键 词 来 提 ?copy; 成 员 函 数 的 程 
            序 代 码。 class MyClass implements AudioClip { void play(){ &lt;实 现 代 
            码&gt; } void loop &lt;实 现 代 码&gt; } void stop &lt;实 现 代 码&gt; } } 
            </P>
            <P>优 点 一 个 接 口 类 可 以 被 任 意 多 的 类 实 现， 每 个 类 可 以共 享 程 序 接 口 而 不 必 关 心 
            其 它 类 是 怎 样 实 现 的。 class MyOtherClass implements AudioClip { void 
            stop(){ &lt;实 现 代 码&gt; } ... } </P>
            <P>内 部 成 员 函 数 Java还 提 ?copy; 了 调 用C和C++函 数 的 方 法。 用native关键 词 来 定 
            义C和C++的 函 数。 </P>
            <P>public class Date { int now; public Date() { now = time (); } 
            private native int time (); </P>
            <P>static { System.loadLibrary("time"); } } </P>
            <P>一 ?copy;Java代 码 写 好 后,就 需 要 以 下 步 骤 执 行： 1.用javah来创 建 头 文 件(.h) 
            2.用javah来 创 建stub文 件 3.用C和C++写native成 员函 数 的 代 码 4.编 译stub文 件 和.C文 件 
            成 一 个 动 态 可 加 载 库 5.用java运 行java程 序 或appletviewer运 行applet </P>
            <P>注 意：Native成 员 函 数 超 出 了 类 的 范 围。 </P>
            <H2 align=center>3.9 包(Packages)</H2>
            <P>包(Package)由 一 组 类(class)和 界 面(interface)组 成。 它 是 管 理大 型 名 字 空 间， 
            避 免 名 字 冲 突 的 工 具。 每 一 个 类 和 界 面 的名 字 都 包 含 在 某 个 包 中。 按 照 一 般 的 习 
            惯， 它 的 名 字 是 由“.” 号 分 隔 的 单 词 构 成， 第 一 个 单 词 通 常 是 开 发 这 个 包 的 组织 的 
            名 称。 </P>
            <P>定 义 一 个 编 译 单 元 的 包 编 译 单 元 的 包 由package语 句 定 义。如 果 使 用package语 
            句， 编 译 单 元 的 第 一 行 必 须 无 空 格， 也 无注 释。 其 格 式 如 下： package 
            packageName; 若 编 译 单 元 无package语句， 则 该 单 元 被 置 于 一 个 缺 省 的 无 名 的 包 
            中。 </P>
            <P>使 用 其 它 包 中 的 类 和 界 面 在Java语 言 里 提 ?copy; 一 个 包可 以 使 用 另 一 个 包 中 
            类 和 界 面 的 定 义 和 实 现 的 机 制。 用import关键 词 来 标 明 来 自 其 它 包 中 的 类。 一 个 编 
            译 单 元 可 以 自 动把 指 定 的 类 和 界 面 输 入 到 它 自 己 的 包 中。 在 一 个 包 中 的代 码 可 以 有 
            两 种 方 式 来 定 义 来 自 其 它 包 中 的 类 和 界 面： * 在 每 个 引 用 的 类 和 界 面 前 面 给 出 它 
            们 所 在 的 包 的 名 字; //前 缀 包 名 法 acme. project.FooBar obj=new acme. 
            project. FooBar( ); * 使 用import语 句， 引 入 一 个 类 或 一 个 界 面， 或 包 含 它 们 
            的包。 引 入 的 类 和 界 面 的 名 字 在 当 前 的 ?字 空 间 可 用。 引 入一 个 包 时， 则 该 包 所 有 的 
            公 有 类 和 界 面 均 可 用。 其 形 式 如下： // 从 acme.project 引 入 所 有 类 import 
            acme.project.*; 这 个 语句 表 示acme.project中 所 有 的 公 有 类 被 引 入 当 前 包。 以 下 
            语 句从acme. project包 中 进 入 一 个 类Employec_List。 //从 acme. project而引 入 
            Employee_List import acme.project.Employee_list; Employee_List obj = 
            new Employee_List( ); 在 使 用 一 个 外 部 类 或 界 面 时， 必 须 要声 明 该 类 或 界 面 所 
            在 的 包， 否 则 会 产 生 编 译 错 误。 </P>
            <P>import(引 用) 类 包(class package)用import关 键 词 调 入,指 定package名字 如 路 径 
            和 类 名,用*匹 配 符 可 以 调 入 多 于 一 个 类 名。 </P>
            <P>import java.Date; import java.awt.*; </P>
            <P>如 果java源 文 件 不 包 含package,它 放 在 缺 省 的 无 名package。 这与 源 文 件 同 目 录，