📄 5.html
字号:
class UniversityCreateAlt { public static void main(String args[])
{ University u = new University( ); System.out.println("大 学：" + u.name
+ " 城 市：" + u.city); } }
这 个 例 子 创 建 了 一 个University对 象， 调 用 了 第 二 个 构 造
函 数。 下 面 是 它 的 运 行 结 果。
C:\>java UniversityCreateAlt 大 学： 北 ?copy; 大 学 城 市： 北 ?copy;
一 个 构 造 函 数 可 以 调 用 另 一 个 构 造 函 数 来 创 建 实 例。 例
如：
class University { String name, city; University(String name, String city)
{ this.name = name; this.city = city; } University( ) { this("北 ?copy;
大 学", "北 ?copy;"); } }
第 二 个 构 造 函 数 调 用 了 第 一 个 构 造 函 数 来 完 成 实 例 的
初 始 化。 你 也 可 以 用 重 载 来 创 建 一 般 的 成 员 函 数。 下 面
这 个 例 子 里 有University类 的 两 个 版 本 的 samecity成 员 函 数。
samecity判 断 一 个 大 学 是 否 在 一 个 城 市 里 或 一 个 大 学 和
另 一 个 大 学 是 否 在 同 一 个 城 市 里。 一 个 成 员 函 数 用city
作 参 数， 另 一 个 用University对 象 作 参 数。
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); } }
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)); } }
下 面 是 该 程 序 的 运 行 结 果。
C:\>java UniversityCity u1 = 北 ?copy; 大 学, 北 ?copy; u2 = 清 华 大
学, 北 ?copy; city = 上海 u1.samecity(u2) = true u1.samecity(city) =
false
5.10 继 承
第 二 个 基 本 的 面 向 对 象 机 制 是 继 承。 继 承 是 关 于 有 层 次
关 系 的 类 ?reg; 间 的 概 念。 一 个 类 的 后 代 可 以 继 承 它 的 祖
先 的 所 有 变 量 和 成 员 函 数， 就 象 创 建 自 己 的 一 样。 一 个
类 的 直 接 父 亲 叫 做 它 的 超 类（superclass?copy;。 一 ?copy; 你 创
建 了 一 个 象University这 样 的 类， 创 建 它 的 子 类 是 很 简 单
的。 一 个 类 的 子 类 是 它 的 继 承 了 实 例 变 量 和 成 员 函 数 的
特 殊 的 版 本。 在 这 个 例 子 里， 我 们 把University类 派 生 为 含
有 叫 做country的 第 三 个 元 素 的 子 类。
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;", "中 国"); } }
关 键 词extends用 来 表 示 我 们 要 创 建University的 子 类。name和
city不 需 再 在UniversityWorld 中 进 行 声 明， 因 为 它 们 是 从
University中 继 承 的。Java允 许 在UniversityWorld中 声 明 变 量name
和city， 但 这 会 隐 藏University中 的name和city， 是 与 使 用 子 类
的 目 的 相 矛 盾 的， 应 当 避 免。 在 UniversityWorld的 实 例 中，
name、city和country的 地 位 是 一 样 的。
5.11 super 在UniversityWorld的 例 子 里， 有 一 段 代 码 和 它 的 超
类University的 重 复， 这 段 代 码 是 初 始 化 name和city的，
this.name = name; this.city = city;
就 象 在University例 子 中 用this指 向 第 一 个 构 造 函 数 一 样，
在Java里 有 另 一 个 变 量 叫 做 super， 它 直 接 指 向 超 类 的 构
造 函 数。 下 面 这 个 例 子 用super来 初 始 化 变 量name和city， 然
后 打 印 出 这 个 对 象 的 内 容。
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); } }
下 面 是 运 行 结 果。
C:\>java UniversityWorld 大 学： 北 ?copy; 大 学 城 市： 北 ?copy; 国
家： 中 国
5.12 成 员 函 数 的 覆 盖
这 个University的 新 的 子 类 继 承 了 它 的 超 类 的 成 员 函 数
samecity。 但 这 个 成 员 函 数samecity 判 断 的 是 两 个 城 市 的 名
字， 这 是 不 够 的， 因 为 有 可 能 两 个 两 个 名 字 一 样 的 城 市
属 于 不 同 的 国 家， 我 们 要 用 同 时 判 断 城 市 和 国 家 的 成 员
函 数 来 覆 盖 它。 下 面 就 是 实 现 覆 盖 的 例 子。
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); } }
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) && country.equals(u.country)) return
true; else return false; } boolean samecity(UniversityWorld other)
{ return distance(other.city, other.country); } }
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)); } }
下 面 是 输 出 结 果。
C:\>java UniversityWorldCity u1 = 北 ?copy; 大 学, 北 ?copy;, 中 国 u2
= 清 华 大 学, 北 ?copy;, 中 国 city = 上海, country = 中 国
u1.samecity(u2) = true u1.samecity(city, country) = false
5.13 动 态 成 员 函 数 发 送
当 你 用 点 操 作 符 调 用 一 个 对 象 实 例 的 成 员 函 数 时， 对 象
实 例 所 属 的 类 在 编 译 时 要 被 检 查， 以 确 保 调 用 的 成 员 函
数 在 该 类 中 是 存 在 的。 在 运 行 时， 对 象 实 例 可 以 指 向 所
声 明 类 型 的 子 类 的 实 例。 在 这 ?copy; 情 况 下， 如 果 子 类 覆
盖 了 要 调 用 的 成 员 函 数，Java就 用 实 例 来 决 定 调 用 哪 一
个 成 员 函 数。 如 下 面 的 例 子， 两 个 类 是 子 类 和 超 类 的 关
系， 子 类 覆 盖 了 超 类 的 成 员 函 数。
class A { void callme( ) { System.out.println("在A的callme成 员 函 数
里"); } }
class B extends A { void callme( ) { System.out.println("在B的callme
成 员 函 数 里"); } }
class Dispatch { public static void main(String args[]) { A a = new B( );
a.callme( ); } }
有 趣 的 是， 在 成 员 函 数main里， 我 们 把 变 量a声 明 为 类 型A，
然 后 把 类B的 一 个 实 例 存 放 到 它 上 面。 我 们 在a上 调 用 成
员 函 数callme，Java编 译 器 确 定 在 类A确 实 有 成 员 函 数callme，
但 是 在 运 行 时， 由 于a事 实 上 是B的 实 例， 所 以 调 用B的
callme， 而 不 调 用A的。 下 面 是 运 行 结 果：
C:\>java Dispatch 在B的callme成 员 函 数 里
5.14 final
在 缺 省 情 况 下， 所 有 的 成 员 函 数 和 实 例 变 量 都 可 以 被 覆
盖。 如 果 你 希 望 你 的 变 量 或 成 员 函 数 不 再 被 子 类 覆 盖，
可 以 把 它 们 声 明 为final。 这 意 味 着 将 来 的 实 例 都 依 赖 这
个 定 义。 例 如：
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;
final变 量 用 大 写 标 识 符 是 一 个 一 般 的 约 定。
5.15 静 态
如 果 你 想 要 创 建 一 个 可 以 在 实 例 的 外 部 调 用 的 成 员 函
数， 那 么 你 只 需 声 明 它 为 静 态 的 （static?copy;， 它 就 会 正 常
运 行。 静 态 成 员 函 数 只 能 直 接 调 用 其 他 静 态 成 员 函 数，
而 不 能 以 任 何 方 式 使 用this或super。 你 也 可 以 把 变 量 声 明
为 静 态 的。 如 果 你 想 初 始 化 一 个 静 态 变 量， 你 可 以 用
static声 明 一 个 恰 好 在 类 调 用 时 执 行 一 次 的 程 序 块。 下
面 的 例 子 是 一 个 带 有 一 个 静 态 成 员 函 数， 几 个 静 态 变
量， 和 一 个 静 态 初 始 块 的 类。
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); } }
一 ?copy; 这 个 类 被 调 用， 所 有 的 静 态 变 量 都 被 初 始 化，a
被 赋 为3， 然 后 运 行static块， 这 将 打 印 出 一 段 消 息， 并 且
把b赋 为a*4， 即12。 然 后 解 释 器 调 用main成 员 函 数， 它 调 用
了 成 员 函 数 method， 参 数x为42。 这 三 个println语 句 打 印 了 两
个 静 态 变 量a、b和 局 部 变 量x。 下 面 是 运 行 结 果：
C:\>java Static 静 态 初 始 块 x = 42 a = 3 b = 12
一 个 静 态 成 员 函 数 可 以 通 过 它 所 属 的 类 名 来 调 用。 象 调
用 实 例 变 量 一 样， 你 可 以 用 点 操 作 符 通 过 类 名 来 调 用 静
态 成 员 函 数 和 静 态 变 量。Java就 是 这 样 实 现 了 全 局 函 数
和 全 局 变 量。 下 面 的 例 子 里， 我 们 创 建 了 带 有 一 个 静 态
成 员 函 数 和 两 个 静 态 变 量 的 类。 第 二 个 类 可 以 通 过 名 字
直 接 来 调 用 第 一 个 类 的 静 态 成 员 函 数 和 静 态 变 量。
class staticClass { static int a = 42; static int b = 99; static void
callme( ) { System.out.println("a = " + a); } }
class StaticByName { public static void main(String args[])
{ StaticClass.callme( ); System.out.println("b = " + staticClass.b); } }
下 面 是 运 行 结 果：
C:\>java staticByName a = 42 b = 99
5.16 抽 象
有 时 你 需 要 定 义 一 个 给 出 抽 象 结 构、 但 不 给 出 每 个 成 员
函 数 的 完 整 实 现 的 类。 如 果 某 个 成 员 函 数 没 有 完 整 实
现， 必 须 要 由 子 类 来 覆 盖， 你 可 把 它 声 明 为 抽 象
（abstract?copy; 型。 含 有 抽 象 型 成 员 函 数 的 类 必 须 声 明 为
抽 象 的。 为 了 把 一 个 类 声 明 为 抽 象 的， 你 只 需 在 类 定 义
的class关 键 词 前 放 置 关 键 词abstract。 这 ?copy; 类 不 能 直 接
用new操 作 符 生 成 实 例， 因 为 它 们 的 完 整 实 现 还 没 有 定
义。 你 不 能 定 义 抽 象 的 构 造 函 数 或 抽 象 的 静 态 成 员 函
数。 抽 象 类 的 子 类 或 者 实 现 了 它 的 超 类 的 所 有 抽 象 的 成
员 函 数， 或 者 也 被 声 明 为 抽 象 的。 下 面 例 子 是 一 个 带 有
抽 象 成 员 函 数 的 类， 其 后 是 一 个 实 现 了 该 成 员 函 数 的
类。
abstract class A { abstract void callme( ) ; void metoo( )
{ system.out.println("在A的metoo成 员 函 数 里"); } }
class B extends A { void callme( ) { System.out.println("在B的callme
成 员 函 数 里"); } }
class Abstract { public static void main(String args[]) { A a = new B( );
a.callme( ); a.metoo( ); } }
下 面 是 运 行 结 果：
C:\>java Abstract 在B的callme成 员 函 数 里 在A的metoo成 员 函 数
里
本 章 小 结
1. 类 是Java语 言 面 向 对 象 编 程 的 基 本 元 素， 它 定 义 了 一
个 对 象 的 结 构 和 功 能。 2. Java通 过 在 类 定 义 的 大 括 号 里
声 明 变 量 来 把 数 据 封 装 在 一 个 类 里， 这 里 的 变 量 称 为 实
例 变 量。 3. 成 员 函 数， 是 类 的 功 能 接 口， 是 类 定 义 里 的 一
个 子 程 序， 在 类 的 定 义 里 和 实 例 变 量 处 于 同 一 级 别。
</pre></div></td></tr></table><hr width=90% color=#7A7A71><!--end_content--> <br> </TD> <TD bgColor=#c6bba4 vAlign=top width="1%"></TD> <TD bgColor=#c6bba4 vAlign=bottom width="11%"><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_end1--></b><br></TD> </TR></TABLE><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%"> <br> <center> <iframe width=468 height=60 marginwidth=0 marginheight=0 hspace=0 vspace=0 frameborder=0 scrolling=no bordercolor="#000000" src="/banner4.html"></iframe> </center> <center> <script language="JavaScript" src="http://www.myrice.com/bottom.js"></script> </center> </TD> <TD bgColor=#c6bba4 vAlign=top width="12%" align="left"></TD> </TR></TABLE><center> <script language="JavaScript" src="/bottom.js"></script></center></BODY></HTML>⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -