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()构造器中的第一步操作)。基类构造器和导出类的构造器一样，
以相同的顺序来经历相同的过程。在基类构造器完成之后，实例变量按其次序被初始化。最后，
构造器的其余部分被执行。
----------------