发信人: Only (在水一方), 信区: Java
标 题: java教程(九)
发信站: 饮水思源 (Wed Nov 27 19:05:41 1996)
JAVA程序设计语言讲座(第11讲)
郁欣 孙元 王曦东 王克宏
第 一 部 分 Java入 门
第 六 章 对 象 、 类 、 包 和 接 口
6.2.6 构 造 方 法
构造方法是一种特殊的方法。Java中的每个类都有构造方法,用来初始化该类的一个
新的对象。构造方法具有和类名相同的名称,而且不返回任何数据类型,在构造方法的实
现中,也可以进行方法重写 。
例6.5
class point {
int x,y;
point (){
x=0; y=0;
}
point (int x, int y){
this.x=x; this.y=y;
}
}
上 例 中 ,我 们 对 类 Point实 现 了 两 个 构 造 方 法 ,方 法 名 均 为 Poin t,与 类 名 相 同 。 而 且 我 们 使
用 了 方 法 重 写 ,根 据 不 同 的 参 数 分 别 对 点 的 x、 y坐 标 赋 与 不 同 的 初 值 。
回 忆 在 例 6.2中 ,我 们 曾 用 init()方 法 对 点 的 x、 y坐 标 进 行 初 始 化 。 二 者 完 成 相 同 的 功 能
,那 么 用 构 造 方 法 的 好 处 在 哪 里 呢 ?
当 用 运 算 符 new为 一 个 对 象 分 配 内 存 时 ,要 调 用 对 象 的 构 造 方 法 ,而 当 创 建 一 个 对 象 时
,必 须 用 new为 它 分 配 内 存 。 因 此 用 构 造 方 法 进 行 初 始 化 避 免 了 在 生 成 对 象 后 每 次 都 要 调
用 对 象 的 初 始 化 方 法 。 如 果 没 有 实 现 类 的 构 造 方 法 ,则 Java运 行 时 系 统 会 自 动 提 供 缺 省 的
构 造 方 法 ,它 没 有 任 何 参 数 。
另 外 ,构 造 方 法 只 能 由 new运 算 符 调 用 。 我 们 将 在 § 6.3中 进 行 详 细 介 绍 。 对 构 造 方 法 同
样 也 有 访 问 权 限 的 限 制 (见 § 6.6)。
6.2.7 finalize()方 法
在对对象进行垃圾收集前,Java运行时系统回自动调用对象的finalize()方法来释放系统资
源,如打开的文件或socket。该方法的声明必须如下所示 :
protected void finalize() throws throwable
finalize()方法在类java.lang.Object中实现。如果要在一个所定义的类中实现该方法以释放
该类所占用的资源(即要重载父类的finalize()方法),则在对该类所使用的资源进行翻译后,一
般要调用父类的finalize()方法以清除对象使用的所有资源,包括由于继承关系而获得的资源
。通常的格式应为 :
protected void finalize () throws throwable{
…… // clean up code for this class
super. finalize();
}
该例中,通 过super来调用其父类的finalize()方法,有关super我们将在§6.4中讲述,对 类
java.lang.Ob-ject,我们也将在§6.4中讲述 。
§ 6.3 对 象
把类实例化,我们可以生成多个对象,这些对象通过消息传递来进行交互(消息传递即
激活指定的某个对象的方法以改变其状态或让它产生一定的行为),最终完成复杂的任务
。
一 个 对 象 的 生 命 期 包 括 三 个 阶 段 :生 成 、 使 用 和 清 除 。 下 面 我 们 分 别 讲 述 :
6.3.1 对 象 的 生 成
对 象 的 生 成 包 括 声 明 、 实 例 化 和 初 始 化 三 方 面 的 内 容 。 通 常 的 格 式 为 :
type objectName = new type ( [paramlist] );
1. type objectName; 声 明 了 一 个 类 型 为 type的 对 象 。 其 中 type是 组 合 类 型 (包 括 类 和 接 口 )。
对 象 的 声 明 并 不 为 对 象 分 配 内 存 空 间 。
2. 运 算 符 new为 对 象 分 配 内 存 空 间 ,实 例 化 一 个 对 象 。 new调 用 对 象 的 构 造 方 法 ,返 回 对
该 对 象 的 一 个 引 用 (即 该 对 象 所 在 的 内 存 地 址 )。 用 new可 以 为 一 个 类 实 例 化 多 个 不 同 的 对
象 。 这 些 对 象 分 别 占 用 不 同 的 内 存 空 间 ,因 此 改 变 其 中 一 个 对 象 的 状 态 不 会 影 响 其 它 对 象
的 状 态 。
3. 生 成 对 象 的 最 后 一 步 是 执 行 构 造 方 法 ,进 行 初 始 化 。 由 于 对 构 造 方 法 可 以 进 行 重 写
,所 以 通 过 给 出 不 同 个 数 或 类 型 的 参 数 会 分 别 调 用 不 同 的 构 造 方 法 。
以 例 6.5中 所 定 义 的 类 Point 为 例 ,我 们 生 成 类 Point的 对 象 :
Point p1 = new Point();
Point p2 = new Point(5,10);
这 里 ,我 们 为 类 Point生 成 了 两 个 对 象 p1、 p2,它 们 分 别 调 用 不 同 的 构 造 方 法 ,p1调 用 缺 省
的 构 造 方 法 (即 没 有 参 数 ),p2则 调 用 带 参 数 的 构 造 方 法 。 p1、 p2 分 别 对 应 于 不 同 的 内 存 空 间
, 它 们 的 值 是 不 同 的 ,可 以 完 全 独 立 地 分 别 对 它 们 进 行 操 作 。
虽 然 new运 算 符 返 回 对 一 个 对 象 的 引 用 ,但 与 C、 C++中 的 指 针 不 同 ,对 象 的 引 用 是 指 向
一 个 中 间 的 数 据 结 构 ,它 存 储 有 关 数 据 类 型 的 信 息 以 及 当 前 对 象 所 在 的 堆 的 地 址 ,而 对 于
对 象 所 在 的 实 际 的 内 存 地 址 是 不 可 操 作 的 ,这 就 保 证 了 安 全 性 。
6.3.2 对 象 的 使 用
对 象 的 使 用 包 括 引 用 对 象 的 成 员 变 量 和 方 法 ,通 过 运 算 符 · 可 以 实 现 对 变 量 的 访 问 和
方 法 的 调 用 ,变 量 和 方 法 可 以 通 过 设 定 一 定 的 访 问 权 限 (见 § 6.6) 来 允 许 或 禁 止 其 它 对 象 对
它 的 访 问 。
我 们 先 定 义 一 个 类 Point,它 在 例 6.5的 定 义 中 添 加 了 一 些 内 容 。
例6.6
class Point{
int x,y;
String name = "a point";
Point(){
x = 0;
y = 0;
}
Point( int x, int y, String name ){
this.x = x;
this.y = y;
this.name = name;
}
int getX(){
return x;
}
int getY(){
return y;
}
void move( int newX, int newY ){
x = newX;
y = newY;
}
Point newPoint( String name ){
Point newP = new Point( -x, -y, name );
return newP;
}
boolean equal( int x, int y ){
if( this.x==x && this.y==y )
return true;
else
return false;
}
void print(){
System.out.println(name+" : x = "+x+" y = "+y);
}
}
public class UsingObject{
public static void main( String args[] ){
Point p = new Point();
p.print(); //call method of an object
p.move( 50, 50 );
System.out.println("** after moving **");
System.out.println("Get x and y directly");
System.out.println("x = "+p.x+" y = "+p.y); //access variabl
es of an object
System.out.println("or Get x and y by calling method");
System.out.println("x = "+p.getY()+" y = "+p.getY());
if( p.equal(50,50) )
System.out.println("I like this point!!!! ");
else
System.out.println("I hate it!!!!! ");
p.newPoint( "a new point" ).print();
new Point( 10, 15, "another new point" ).print();
}
}
运行结果为:
C:\java UsingObject
a point : x = 0 y = 0
**** after moving *****
Get x and y directly
x = 50 y = 50
or Get x and y by calling method
x = 50 y = 50
I like this point!!!!
a new point : x = -50 y = -50
another new point : x = 10 y = 15
1. 引 用 对 象 的 变 量
要 访 问 对 象 的 某 个 变 量 ,其 格 式 为 :
objectReference.variable
其 中 objectReference是 对 象 的 一 个 引 用 ,它 可 以 是 一 个 已 生 成 的 对 象 ,也 可 以 是 能 够 生 成 对
象 引 用 的 表 达 式 。
例 如 :我 们 用 Point p=new Point();生 成 了 类 Point的 对 象 p后 ,可 以 用 p.x,p.y来 访 问 该 点 的 x、 y坐
标 ,如
p.x = 10; p.y = 20;
或 者 用 new生 成 对 象 的 引 用 ,然 后 直 接 访 问 ,如 :
tx = new point().x;
2. 调 用 对 象 的 方 法
要 调 用 对 象 的 某 个 方 法 ,其 格 式 为 :
objectReference.methodName ( [paramlist] );
例 如 我 们 要 移 动 类 Point的 对 象 p,可 以 用
p.move(30,20);
虽 然 我 们 可 以 直 接 访 问 对 象 的 变 量 p.x、 p.y来 改 变 点 p的 坐 标 ,但 是 通 过 方 法 调 用 的 方
式 来 实 现 能 更 好 地 体 现 面 向 对 象 的 特 点 ,建 议 在 可 能 的 情 况 下 尽 可 能 使 用 方 法 调 用 。
同 样 ,也 可 以 用 new生 成 对 象 的 引 用 ,然 后 直 接 调 用 它 的 方 法 ,如
new point(). move (30,20);
前 面 已 经 讲 过 ,在 对 象 的 方 法 执 行 完 后 ,通 常 会 返 回 指 定 类 型 的 值 ,我 们 可 以 合 法 地 使
用 这 个 值 ,如 :例 6.6中 类 Point的 方 法 equal返 回 布 尔 值 ,我 们 可 以 用 它 来 作 为 判 断 条 件 分 别 执 行
不 同 的 分 支 。 如 :
if (p.equal (20,30)){
…… //statements when equal
}else {
…… //statements when unequal
}
另 外 ,类 Point的 方 法 newPoint返 回 该 点 关 于 原 点 的 对 称 点 ,返 回 值 也 是 一 个 Point类 型 , 我 们
可 以 访 问 它 的 变 量 或 调 用 它 的 方 法 ,如 :
px = p.newPoint().x 或
px = p.newPoint(). getX();
(未 完 待 续 )