ThinkJava-复用类

7 .2 继承语法

例子：

package com.cy.reusing;
 
import static com.java.util.Print.*;
 
class Cleanser {
  private String s = "Cleanser";
  public void append(String a) { s += a; }
  public void dilute() { append(" dilute()"); }
  public void apply() { append(" apply()"); }
  public void scrub() { append(" scrub()"); }
  public String toString() {
      return s;
  }
  public static void main(String[] args) {
    Cleanser x = new Cleanser();
    x.dilute(); x.apply(); x.scrub();
    print(x);
  }
}    
 
public class Detergent extends Cleanser {
  // Change a method:
  public void scrub() {
    append(" Detergent.scrub()");
    super.scrub(); // Call base-class version
  }
  // Add methods to the interface:
  public void foam() { append(" foam()"); }
  // Test the new class:
  public static void main(String[] args) {
    Detergent x = new Detergent();
    x.dilute();
    x.apply();
    x.scrub();
    x.foam();
    print(x);
    print("Testing base class:");
    Cleanser.main(args);
  }
}
/* Output:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()
*///:~

Cleanser中所有的方法都必须是public的，这一点非常重要。请记住，如果没有加任何访问

权限修饰词，那么成员默认的访问权限是包访问权限， 它仅允许包内的成员访问。因此，在此

包中，如果没有访问权限修饰词，任何人都可以使用这些方法。例如， Detergent就不成问题。

但是，其他包中的某个类若要从CIeanser中继承，则只能访问public成员。所以，为了继承， 一

般的规则是将所有的数据成员都指定为private ，将所有的方法指定为public (稍后将会学到，

protected成员也可以借助导出类来访问)。当然，在特殊情况下，必须做出调整，但上述方法的

确是一个很有用的规则。

正如我们在scrub()中所见，使用基类中定义的方法及对它进行修改是可行的。在此例中，

你可能想要在新版本中调用从基类继承而来的方法。但是在scrub()中，并不能直接调用scrub() ，

因为这样做将会产生递归，而这并不是你所期望的。为解决此问题， Java用super关键字表示超

类的意思，当前类就是从超类继承来的。为此，表达式super.scrub()将调用基类版本的scrub()

方法.

 

 

7.8 final关键字

7.8.1 final 数据

一个既是static又是final的域只占据一段不能改变的存储空间。

当对对象引用而不是基本类型运用final时， 其含义会有一点令人迷惑。对于基本类型，

final使数值恒定不变; 而用于对象引用， final使引用恒定不.变。一旦引用被初始化指向一个对

象，就无法再把它改为指向另一个对象。然而，对象其自身却是可以被修改的， Java并未提供

使任何对象恒定不变的途径(但可以自己编写类以取得使对象恒定不变的效果)。这一限制同样

适用数组，它也是对象。

 

fínal 参数：

Java允许在参数列表中以声明的方式将参数指明为final。这意味着你无法在方法中更改参数

引用所指向的对象:

package com.cy.reusing;
 
class Gizmo {
  public void spin() {}
}
 
public class FinalArguments {
  void with(final Gizmo g) {
    //! g = new Gizmo(); // Illegal -- g is final
  }
  void without(Gizmo g) {
    g = new Gizmo(); // OK -- g not final
    g.spin();
  }
  // void f(final int i) { i++; } // Can't change
  // You can only read from a final primitive:
  int g(final int i) {
      return i + 1;
  }
  public static void main(String[] args) {
    FinalArguments bf = new FinalArguments();
    bf.without(null);
    bf.with(null);
  }
} ///:~

 

方法f()和g()展示了当基本类型的参数被指明为final时所出现的结果:你可以读参数，但却

无法修改参数.这一特性主要用来向匿名内部类传递数据，我们将在第10章中学习它.

 

7.8.2 final 方法

使用final方法的原因有两个.第一个原因是把方法锁定，以防任何继承类修改它的含义.

这是出于设计的考虑:想要确保在继承中使方法行为保持不变，并且不会被覆盖。

过去建议使用final方法的第二个原因是效率。

类中所有的private方法都隐式地指定为是final的。由于无法取用private方法，所以也就无

法覆盖它.可以对private方法添加final 修饰词，但这并不能给该方法增加任何额外的意义。

这一问题会造成混淆.因为，如果你试图覆盖一个private方法(隐含是final的) ，似乎是奏

效的，而且编译器也不会绘出错误信息:

package com.cy.reusing;
 
import static com.java.util.Print.*;
 
class WithFinals {
  // Identical to "private" alone:
  private final void f() { print("WithFinals.f()"); }
  // Also automatically "final":
  private void g() { print("WithFinals.g()"); }
}
 
class OverridingPrivate extends WithFinals {
  private final void f() {
    print("OverridingPrivate.f()");
  }
 
  private void g() {
    print("OverridingPrivate.g()");
  }
}
 
class OverridingPrivate2 extends OverridingPrivate {
  public final void f() {
    print("OverridingPrivate2.f()");
  }
  public void g() {
    print("OverridingPrivate2.g()");
  }
}
 
public class FinalOverridingIllusion {
  public static void main(String[] args) {
    OverridingPrivate2 op2 = new OverridingPrivate2();
    op2.f();
    op2.g();
    // You can upcast:
    OverridingPrivate op = op2;
    // But you can't call the methods:
    //! op.f();
    //! op.g();
 
    // Same here:
    WithFinals wf = op2;
    //! wf.f();
    //! wf.g();
  }
}
/* Output:
OverridingPrivate2.f()
OverridingPrivate2.g()
*///:~

"覆盖"只有在某方法是基类的接口的一部分时才会出现。即，必须能将一个对象向上转型

为它的基本类型并调用相同的方法(这一点在下一章阐明）。 如果某方法为prlvåte ，它就不是基

类的接口的一部分。它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。但如

果在导出类中以相同的名称生成-个publlc 、protected或包访问权限方法的话，该方法就不会产

生在基类中出现的"仅具有相同名称"的情况。此时你并没有覆盖该方法，仅是生成了一个新

的方法。由于private方法无法触及而且能有效隐藏，所以除了把它看成是因为它所归属的类的

组织结构的原因而存在外，其他任何事物都不需要考虑到它。

 

7.8.3 final 类

当将某个类的整体定义为final时(通过将关键字final置于它的定义之前)， -就表明了你不打

算继承该类，而且也不允许别人这样傲。换句话说，出于某种考虑，你对该类的设计永不需要

做任何变动，或者出于安全的考虑，你不希望它有子类。

package com.cy.reusing;
 
class SmallBrain {}
 
final class Dinosaur {
  int i = 7;
  int j = 1;
  SmallBrain x = new SmallBrain();
  void f() {}
}
 
//! class Further extends Dinosaur {}
// error: Cannot extend final class 'Dinosaur'
 
public class Jurassic {
  public static void main(String[] args) {
    Dinosaur n = new Dinosaur();
    n.f();
    n.i = 40;
    n.j++;
  }
} ///:~

请注意， final类的域可以根据个人的意愿选择为是或不是final。不论类是否被定义为final ，

相同的规则都适用于定义为final的域。然而，由于final类禁止继承，所以final类中所有的方法

都隐式指定为是final的，因为无法覆盖色们。在final类中可以给方法添加final修饰词，但这不

会增添任何意义。

 

7.9 初始化及类的加载

7.9. 1 继承与初始化

了解包括继承在内的初始化全过程，以对所发生的一切有个全局性的把握，是很有益的。

请看下例:

package com.cy.reusing;
 
import static com.java.util.Print.*;
 
class Insect {
  private int i = 9;
  protected int j;
  Insect() {
    print("i = " + i + ", j = " + j);
    j = 39;
  }
 
  private static int x1 = printInit("static Insect.x1 initialized");
 
  static int printInit(String s) {
    print(s);
    return 47;
  }
}
 
public class Beetle extends Insect {
  private int k = printInit("Beetle.k initialized");
 
  public Beetle() {
    print("k = " + k);
    print("j = " + j);
  }
 
  private static int x2 = printInit("static Beetle.x2 initialized");
 
  public static void main(String[] args) {
    print("Beetle constructor");
    Beetle b = new Beetle();
  }
}
/* Output:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
*///:~

　　在Beetle上运行Java时，所发生的第-件事情就是试图访问Bettle.main() (一个static方法) ,

于是加载器开始启动并找出Beetle类的编译代码(在名为BattIe.class的文件之中)。在对它进行

加载的过程中，编译器注意到它有一个基类(这是由关键字extends得知的) .于是它继续进行加

载。不管你是否打算产生一个该基类的对象，这都要发生(请尝试将对象创建代码注释掉，以

证明这一点)。

　　如果该基类还有其自身的基类，那么第二个基类就会被加载，如此类推。接下来，根基类

中的static初始化(在此例中为Insect) 即会被执行，然后是下一个导出类，以此类推。这种方

式很重要，因为导出类的static初始化可能会依赖于基类成员能否被正确初始化。

　　至此为止，必要的类都已加载完毕，对象就可以被创建了。首先，对象中所有的基本类型

都会被设为默认值，对象引用被设为null——这是通过将对象内存设为二进制零值而一举生成的。

然后，基类的构造器会被调用。在本例中，它是被自动调用的。但也可以用super来指定对基类

构造器的调用（正如在Beetle()构造器中的第一步操作)。基类构造器和导出类的构造器一样，

以相同的顺序来经历相同的过程。在基类构造器完成之后，实例变量按其次序被初始化。最后，

构造器的其余部分被执行。

 

 

 

 

 

 

----------------