📄 5.html
字号:
<HTML><HEAD><TITLE>黄金书屋</TITLE><META content="text/html; charset=gb2312" http-equiv=Content-Type><link rel="stylesheet" href="/cssset.css"></HEAD><BODY bgColor=#ffffff leftMargin=0 link=#000000 topMargin=0 vLink=#000000><center> <script language="JavaScript" src="/top.js"></script></center><TABLE background=images/bj.jpg border=0 cellSpacing=0 width="100%"> <TR> <TD bgColor=#c6bba4 vAlign=top width="12%"></TD> <TD background=/images/bj.jpg vAlign=top width="76%"> <center> <iframe width=468 height=60 marginwidth=0 marginheight=0 hspace=0 vspace=0 frameborder=0 scrolling=no bordercolor="#000000" src="/banner3.html"></iframe> </center> <br> </TD> <TD bgColor=#c6bba4 vAlign=top width="12%"></TD> </TR></TABLE><TABLE background=images/bj.jpg border=0 cellSpacing=0 width="100%"> <TR> <TD bgColor=#c6bba4 vAlign=top width="11%" align="right"> <br><br><br> <b><a href="/index.html">回首页</a><br><br><a href='4.html'>上一页</a><br><br><a href='6.html'>下一页</a><br><br><a href='http://pub.goldnets.com:81/bbs/post.php?job=new&topic=12210' target=_blank> 我有话说 </a><br><br><a href='http://pub.goldnets.com:81/bbs/bbslist.php?topic=12210' target=_blank> 评论一览 </a></center><br><!--title_end--></b> </TD> <TD bgColor=#c6bba4 vAlign=top width="1%"></TD> <TD background=/images/bj.jpg vAlign=top width="76%"> <br> <hr align="center" width="98%" size="1"> <br> <font color="blue">Java语言入门</font> >> <font color=red>第 五 章 Java的 类</font><hr width=90% color=#7A7A71><table width=88% border=0 align=center><tr><td><div style=font-size:12pt><pre> Java语言入门
第 五 章 Java的 类
类 是Java语 言 面 向 对 象 编 程 的 基 本 元 素， 它 定 义 了 一 个
对 象 的 结 构 和 行 为。 在Java程 序 里， 你 要 表 达 的 概 念 封 装
在 某 个 类 里。 一 个 类 定 义 了 一 个 对 象 的 结 构 和 它 的 功 能
接 口， 功 能 接 口 称 为 成 员 函 数。 当Java程 序 运 行 时， 系 统 用
类 的 定 义 创 建 类 的 实 例， 类 的 实 例 是 真 正 的 对 象。 类 定
义 的 一 般 形 式 如 下：
class classname extends superclassname { type instance-variable1; type
instance-variable2; ................................. type
instance-variableN; type methodname1(parameter-list) { method-body; }
type methodname2(parameter-list)
{ method-body; } ....................................................
type methodnameN(parameter-list) { method-body; } }
这 里，classname和superclassname是 合 法 的 标 识 符。 关 键 词extends
用 来 表 明classname是 superclassname派 生 的 子 类。 有 一 个 类 叫
做Object， 它 是 所 有Java类 的 根。 如 果 你 想 定 义Object 的 直 接
子 类， 你 可 以 省 略extends子 句， 编 译 器 会 自 动 包 含 它。 下 面
是 一 个 简 单 的 类 的 定 义。
class University { }
5.1 对 象 实 例
类 名 可 以 作 为 变 量 的 类 型 来 使 用， 如 果 一 个 变 量 的 类 型
是 某 个 类， 那 么 它 将 指 向 这 个 类 的 实 例， 称 为 对 象 实 例。
所 有 对 象 实 例 和 它 们 的 类 型（某 个 类?copy; 的 子 类 的 实 例
都 是 相 容 的。 就 象 可 以 把byte型 的 值 赋 给int型 的 变 量 一
样， 你 可 以 把Object的 子 类 的 任 何 实 例 赋 给 一 个Object型 的
变 量。 一 个 实 例 是 类 模 板 的 单 独 的 拷 贝， 带 有 自 己 的 称
为 实 例 变 量 的 数 据 集。 每 个 实 例 也 可 以 作 为 一 个 对 象。
当 你 定 义 一 个 变 量 的 类 型 是 某 个 类 时， 它 的 缺 省 值 是
null，null是Object的 一 个 实 例。 对 象null没 有 值， 它 和 整 数0
不 同。 下 面 这 个 例 子 中， 声 明 变 量u的 类 型 是 类University。
University u;
这 里， 变 量u的 值 是null。
5.2 实 例 变 量
Java通 过 在 类 定 义 的 大 括 号 里 声 明 变 量 来 把 数 据 封 装
在 一 个 类 里。 这 里 的 变 量 称 为 实 例 变 量。 下 面 的 例 子 定
义 了 一 个 叫 做University的 类， 它 有 两 个 实 例 变 量：name和
city。
class University{ String name, city; }
5.3 new操 作 符
操 作 符new用 来 生 成 一 个 类 的 实 例， 下 面 这 个 例 子 生 成 了
类University的 一 个 实 例， 存 放 在 变 量u中。
University u = new University( );
在 此 例 中， 变 量u指 向 这 个 对 象， 但 并 不 真 正 包 含 这 个 对
象。 你 可 以 用 多 个 变 量 指 向 同 一 个 对 象。 下 面 的 例 子 中，
创 建 了 一 个University的 对 象， 但 创 建 了 两 个 指 向 它 的 变
量。
University u = new University(); University u2 = u;
对u2所 指 向 的 对 象 的 任 何 改 动 都 会 对u所 指 向 的 对 象 起
作 用， 因 为 它 们 是 同 一 个 对 象。 对u和u2的 赋 值 只 是 把 它 们
指 向 这 个 对 象， 既 没 有 分 配 内 存， 也 没 有 复 制 这 个 对 象
的 任 何 部 分。 对u的 再 赋 值 只 是 简 单 地 去 掉 了u和 原 来 对
象 的 联 系， 并 不 影 响 对 象 本 身， 下 面 的 例 子 说 明 了 这 种
情 况。
University u = new University( ); University u2 = u; u = null;
尽管u被 赋 值 为null，u2仍 指 向 原 来 由 操 作 符new创 建 的 对 象。
在 前 面 的 例 子 里， 我 们 生 成 了 一 个 对 象 并 且 指 向 了 它 两
次。 这 就 允 许 两 个 变 量 改 变 同 一 个 对 象。 创 建 一 个 新 的
对 象 时， 可 直 接 对 它 的 实 例 变 量 赋 值。 每 个 对 象 都 有 它
所 属 类 的 实 例 变 量 的 拷 贝， 每 个 对 象 的 实 例 变 量 都 是 和
其 他 对 象 的 实 例 变 量 分 离 的， 所 以 改 变 一 个 对 象 的 实 例
变 量 不 会 影 响 其 他 对 象 的 实 例 变 量。 下 面 的 例 子 创 建 了
两 个University的 对 象， 并 对 它 们 分 别 赋 值：
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); } }
这 个 例 子 创 建 了 两 个University的 对 象， 并 且 对 它 们 的name、
city分 别 赋 了 不 同 的 值， 这 说 明 这 两 个 对 象 是 真 正 分 离
的。 下 面 是 该 程 序 运 行 后 的 输 出 结 果。
C:\>java TwoUniversity 大 学： 北 ?copy; 大 学 城 市： 北 ?copy; 大 学：
清 华 大 学 城 市： 北 ?copy;
5.4 点（.?copy; 操 作 符
点（.?copy; 操 作 符 用 来 接 收 一 个 对 象 的 实 例 变 量 和 成 员
函 数。 下 面 是 用 点 操 作 符 来 接 收 实 例 变 量 的 一 般 形 式。
objectreference.variablename
这 里objectreference是 一 个 对 象 实 例，variablename是 这 个 对 象
里 你 想 接 收 的 实 例 变 量。 下 面 的 程 序 段 说 明 了 怎 样 用 点
操 作 符 来 给 实 例 变 量 赋 值。
u.name = "北 ?copy; 大 学"; u.city = "北 ?copy;";
下 面 说 明 怎 样 用 点 操 作 符 来 得 到 实 例 变 量 的 值。
System.out.println("大 学：" + u.name + " 城 市：" + u.city);
通 过 向 类University里 加 入 一 个 成 员 函 数main， 我 们 创 建 了
一 个 完 整 的 例 子， 它 使 用 了new 操 作 符 来 创 建 一 个
University， 用 点 操 作 符 来 赋 值， 然 后 打 印 结 果。
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); } }
运 行 这 个 程 序 后， 就 会 得 到 下 面 的 结 果。
C:\>java University 大 学： 北 ?copy; 大 学 城 市： 北 ?copy;
5.5 成 员 函 数 定 义
成 员 函 数， 是 类 的 功 能 接 口， 是 类 定 义 里 的 一 个 子 程 序，
在 类 的 定 义 里 和 实 例 变 量 处 于 同 一 级 别。 你 必 须 通 过 一
个 类 的 实 例 来 调 用 成 员 函 数。 成 员 函 数 可 以 不 用 点 操 作
符 而 直 接 使 用 实 例 变 量。 成 员 函 数 带 有 输 入 参 数， 具 有
某 种 类 型 的 返 回 值。 成 员 函 数 定 义 的 一 般 形 式 如 下：
type methodname ( formal-parameter-list ) { method-body; }
这 里type指 的 是 成 员 函 数 的 返 回 值 的 类 型， 如 果 没 有 返
回 值， 就 用 无 值（void?copy; 类 型。 methodname可 以 是 任 何 合 法
的 标 识 符， 但 不 能 与 当 前 的 类 名 相 同。formal-parameter-list
是 用 逗 号 分 隔 的 类 型、 标 识 符 对 的 序 列。 如 果 没 有 参 数，
括 号 里 就 是 空 的。 还 是 用 我 们 的University的 例 子， 下 面 的
成 员 函 数 用 来 初 始 化 两 个 实 例 变 量。 成 员 函 数 是 在 类 的
大 括 号 ?reg; 内 定 义 的， 和 实 例 变 量 所 处 的 范 围 相 同。
class University { String name, city; void init(String a, String b) { name
= a; city = b; } }
注 意， 我 们 这 里 直 接 给name和city赋 值， 而 没 有 象 以 前 那 样
用u1.name。 这 是 因 为 每 个 成 员 函 数 都 在 类 的 个 别 实 例 内
执 行。 我 们 创 建 的 类 的 实 例 具 有 它 自 己 的 实 例 变 量， 所
以 成 员 函 数 可 直 接 使 用 它 们。
5.6 成 员 函 数 调 用
可 以 用 点（.?copy; 操 作 符 来 调 用 一 个 类 的 实 例 的 成 员 函
数。 成 员 函 数 调 用 的 一 般 形 式 如 下：
objectreference.methodname( parameter-list );
这 里，objectreference是 指 向 某 个 对 象 的 变 量，methodname是
objectreference所 属 类 的 一 个 成 员 函 数，parameter-list是 用 逗
号 分 隔 的 变 量 或 表 达 式 的 序 列， 它 们 要 与 该 成 员 函 数 的
定 义 的 参 数 个 数 及 类 型 匹 配。 在 这 个 例 子 里， 我 们 可 以
对 任 何University对 象 调 用 成 员 函 数init来 给name和city赋 值。
下 面 的 程 序 段 说 明 了 怎 样 完 成 这 个 工 作。
University u = new University( ); u.init("北 ?copy; 大 学", "
北 ?copy;");
这 个 例 子 创 建 了University的 一 个 实 例， 存 放 在u中。 通 过 点
操 作 符 来 调 用 这 个 实 例 的init 成 员 函 数， 把"北 ?copy; 大 学
"和"北 ?copy;"分 别 传 递 给 参 数a和b。 在init成 员 函 数 内 部，
name和city 直 接 指 向u所 指 向 的 对 象 的 实 例 变 量。 把name 赋
值 为"北 ?copy; 大 学"，city赋 值 为"北 ?copy;"， 然 后 返 回。 在 这
个 例 子 里，init被 定 义 为 无 值（void?copy; 返 回 类 型。 在 进 行
这 个 成 员 函 数 调 用 后，u指 向 这 个name值 和city值 改 变 了 的
University对 象。
5.7 this
Java有 一 个 特 殊 的 实 例 值 叫this， 它 用 来 在 一 个 成 员 函 数
内 部 指 向 当 前 的 对 象。 在 前 面 的 例 子 里， 我 们 调 用u.init，
一 ?copy; 进 入init成 员 函 数 内 部，this就 会 指 向u所 指 向 的 对
象。 在Java里， 在 同 一 个 范 围 定 义 两 个 相 同 名 字 的 局 部 变
量 是 不 可 以 的。 有 趣 的 是， 局 部 变 量、 成 员 函 数 的 参 数 可
以 和 实 例 变 量 的 名 字 相 同。 前 面 我 们 没 有 用name和city作
为 成 员 函 数init的 参 数 名 字， 因 为 这 样 它 们 在 成 员 函 数
的 范 围 里 就 把 实 例 变 量name和city隐 藏 了， 即name指 向 参 数
name， 隐 藏 了 实 例 变 量name。this让 我 们 可 以 直 接 指 向 对 象
本 身。 下 面 是 另 一 个 版 本 的 init， 用name和city作 为 参 数 名
字， 用this来 接 收 当 前 对 象 的 实 例 变 量。
void init(String name, String city) { this.name = name; this.city = city; }
下 面 是 带 有 新 的init初 始 成 员 函 数 的TwoUniversity例 子。
class University { String name, city; void init(String name, String city)
{ this.name = name; this.city = city; } }
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); } }
5.8 构 造 函 数（Constructor?copy;
每 创 建 一 个 类 的 实 例 都 去 初 始 化 它 的 所 有 变 量 是 乏 味
的。 如 果 一 个 对 象 在 被 创 建 时 就 完 成 了 所 有 的 初 始 工
作， 将 是 简 单 的 和 简 洁 的。 因 此，Java在 类 里 提 ?copy; 了 一
个 特 殊 的 成 员 函 数， 叫 做 构 造 函 数（Constructor?copy;。 一 个
构 造 函 数 是 对 象 被 创 建 时 初 始 对 象 的 成 员 函 数。 它 具 有
和 它 所 在 的 类 完 全 一 样 的 名 字。 一 ?copy; 定 义 好 一 个 构
造 函 数， 创 建 对 象 时 就 会 自 动 调 用 它。 构 造 函 数 没 有 返
回 类 型， 即 使 是void类 型 也 没 有。 这 是 因 为 一 个 类 的 构 造
函 数 的 返 回 值 的 类 型 就 是 这 个 类 本 身。 构 造 函 数 的 任 务
是 初 始 一 个 对 象 的 内 部 状 态， 所 以 用new操 作 符 创 建 一 个
实 例 后， 立 刻 就 会 得 到 一 个 清 楚、 可 用 的 对 象。 下 面 这 个
例 子 里， 用 构 造 函 数 取 代 了 成 员 函 数init。
class University { String name, city; University(String name, String city)
{ this.name = name; this.city = city; } }
class UniversityCreate { public static void main(String args[])
{ University u = new University("北 ?copy; 大 学", "北 ?copy;");
System.out.println("大 学：" + u.name + " 城 市：" + u.city); } }
new语 句 中 类 名 后 的 参 数 是 传 给 构 造 函 数 的。
5.9 成 员 函 数 重 载
对 于 几 个 意 义 相 近 的 成 员 函 数， 有 时 使 用 相 同 的 名 字 便
于 理 解。 因 此，Java语 言 实 现 了 成 员 函 数 重 载， 即 可 以 创 建
几 个 名 字 相 同、 参 数 不 同 的 成 员 函 数。 成 员 函 数 重 载
提 ?copy; 了Java的 多 态 行 为。 下 面 的 例 子 用 到 了 重 载。
class University { String name, city; University(String name, String city)
{ this.name = name; this.city = city; } University( ) { name = "北 ?copy;
大 学"; city = "北 ?copy;"; } }
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -