?? 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 + -