荔园在线

荔园之美，在春之萌芽，在夏之绽放，在秋之收获，在冬之沉淀

[回到开始] [上一篇][下一篇]

发信人: icefire (冰火), 信区: Java
标  题: [转载] java教程(九) (转载)                    DLW (转寄)
发信站: 深大荔园晨风站 (Sun Mar  1 14:47:45 1998), 转信

【 以下文字转载自 icefire 的信箱 】
【 原文由 icefire.bbs@bbs.sjtu.edu.cn 所发表 】
发信人: DLW (飞鸟), 信区: program
标  题: java教程(九) (转载)
发信站: 饮水思源站 (Wed Aug 27 15:56:38 1997) , 转信



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();


     (未 完 待 续 )



--
��������������������������������������������������?
?           You are the Only one                  ?
?<a href=//www.shnet.edu.cn/~sryang1/Only>Only</a>?
��������������������������������������������������?

※ 来源:．饮水思源 bbs.sjtu.edu.cn．[FROM: 202.120.3.150]
--
※ 转载:．深大荔园晨风站 bbs.szu.edu.cn．[FROM: bbs.szu.edu.cn]

[回到开始] [上一篇][下一篇]

荔园在线首页 友情链接：深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店