第 一 部 分 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.2.7 finalize()方 法 



     在 对 对 象 进 行 垃 圾 收 集 前 ,Java运 行 时 系 统 回 自 动 调 用 对 象 的

 finalize()方 法 来 释 放 系 统 资



     protected void finalize() throws throwable 



     finalize()方 法 在 类 java.lang.Object中 实 现 。 如 果 要 在 一 个 所 定 义

 的 类 中 实 现 该 方 法 以 释 放

该 类 所 占 用 的 资 源 (即 要 重 载 父 类 的 finalize()方 法 ),则 在 对 该 类 所

 使 用 的 资 源 进 行 翻 译 后 ,一

般 要 调 用 父 类 的 finalize()方 法 以 清 除 对 象 使 用 的 所 有 资 源 ,包 括 

? 于 继 承 关 系 而 获 得 的 资 源



    ……        // clean up code for this class

    super. finalize();

    }









 

将 在 § 6.4中 讲 述 ,对 类

java.lang.Ob-ject,我 们 也 将 在 § 6.4中 讲 述 。 







递

 来 进 行 交 互 (消 息 传 递 即

激 活 指 定 的 某 个 对 象 的 方 法 以 改 变 其 状 态 或 让 它 产 生 一 定 的 行 

为 ),最 终 完 成 复 杂 的 任 务



 

我 们 分 别 讲 述 :





     对 象 的 生 成 包 括 声 明 、 实 例 化 和 初 始 化 三 方 面 的 内 容 。 通 

? 的 格 式 为 : 







     1. type objectName; 声 明 了 一 个 类 型 为 type的 对 象 。 其 中 type是 组 

合 类 型 (包 括 类 和 接 口 )。

对 象 的 声 明 并 不 为 对 象 分 配 内 存 空 间 。 



 

对 象 的 构 造 方 法 ,返 回 对

该 对 象 的 一 个 引 用 (即 该 对 象 所 在 的 内 存 地 址 )。 用 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. 调 用 对 象 的 方 法 

     要 调 用 对 象 的 某 个 方 法 ,其 格 式 为 : 

















 

,但 是 通 过 方 法 调 用 的 方

式 来 实 现 能 更 好 地 体 现 面 向 对 象 的 特 点 ,建 议 在 可 能 的 情 况 下 尽



? 











型

 的 值 ,我 们 可 以 合 法 地 使

用 这 个 值 ,如 :例 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();