6. 类再生

2022-01-14 09:58:18 作者：互联网

Version:1.0 StartHTML:0000000153 EndHTML:0000187906 StartFragment:0000041067 EndFragment:0000187866 SourceURL:file:///Z:/thinking_in_java/new.docx

在象C 那样的程序化语言里，代码的重复使用早已可行，但效果不是特别显著。与Java 的其他地方一样，这个方案解决的也是与类有关的问题。我们通过创建新类来重复使用代码，但却用不着重新创建，可以直接使用别人已建好并调试好的现成类。

但这样做必须保证不会干扰原有的代码。在这一章里，我们将介绍两个达到这一目标的方法。第一个最简

单：在新类里简单地创建原有类的对象。我们把这种方法叫作“合成”，因为新类由现有类的对象合并而

成。我们只是简单地重复利用代码的功能，而不是采用它的形式。

第二种方法则显得稍微有些技巧。它创建一个新类，将其作为现有类的一个“类型”。我们可以原样采取现有类的形式，并在其中加入新代码，同时不会对现有的类产生影响。这种魔术般的行为叫作“继承”

（Inheritance），涉及的大多数工作都是由编译器完成的。对于面向对象的程序设计，“继承”是最重要的

基础概念之一。它对我们下一章要讲述的内容会产生一些额外的影响。

对于合成与继承这两种方法，大多数语法和行为都是类似的（因为它们都要根据现有的类型生成新类型）。

在本章，我们将深入学习这些代码再生或者重复使用的机制。

6.1 合成的语法

就以前的学习情况来看，事实上已进行了多次“合成”操作。为进行合成，我们只需在新类里简单地置入对

象句柄即可。举个例子来说，假定需要在一个对象里容纳几个 String 对象、两种基本数据类型以及属于另一个类的一个对象。对于非基本类型的对象来说，只需将句柄置于新类即可；而对于基本数据类型来说，则需在自己的类中定义它们。

class WaterSource {

private String s;

WaterSource() {

System.out.println("WaterSource()");

s = new String("Constructed");

}

public String toString() { return s; }

}

public class SprinklerSystem {

private String valve1, valve2, valve3, valve4;

WaterSource source;

int i;

float f;

void print() {

System.out.println("valve1 = " + valve1);

System.out.println("valve2 = " + valve2);

System.out.println("valve3 = " + valve3);

System.out.println("valve4 = " + valve4);

System.out.println("i = " + i);

System.out.println("f = " + f);

System.out.println("source = " + source);

}

public static void main(String[] args) {

SprinklerSystem x = new SprinklerSystem();

x.print();

}

} ///:~

WaterSource 内定义的一个方法是比较特别的：toString()。大家不久就会知道，每种非基本类型的对象都

有一个 toString()方法。若编译器本来希望一个String，但却获得某个这样的对象，就会调用这个方法。所

以在下面这个表达式中：

System.out.println("source = " + source) ;

编译器会发现我们试图向一个 WaterSource 添加一个String 对象（"source ="）。这对它来说是不可接受

的，因为我们只能将一个字串“添加”到另一个字串，所以它会说：“我要调用 toString()，把source 转

换成字串！”经这样处理后，它就能编译两个字串，并将结果字串传递给一个System.out.println()。每次

随同自己创建的一个类允许这种行为的时候，都只需要写一个 toString()方法。

valve1 = null

valve2 = null

valve3 = null

valve4 = null

i = 0

f = 0.0

source = null

在类内作为字段使用的基本数据会初始化成零，就象第 2 章指出的那样。但对象句柄会初始化成null。而且假若试图为它们中的任何一个调用方法，就会产生一次“违例”。这种结果实际是相当好的（而且很有

用），我们可在不丢弃一次违例的前提下，仍然把它们打印出来。

编译器并不只是为每个句柄创建一个默认对象，因为那样会在许多情况下招致不必要的开销。如希望句柄得到初始化，可在下面这些地方进行：

(1) 在对象定义的时候。这意味着它们在构建器调用之前肯定能得到初始化。

(2) 在那个类的构建器中。

(3) 紧靠在要求实际使用那个对象之前。这样做可减少不必要的开销——假如对象并不需要创建的话。

6.2 继承的语法

继承与 Java（以及其他 OOP 语言）非常紧密地结合在一起。我们早在第1 章就为大家引入了继承的概念，并在那章之后到本章之前的各章里不时用到，因为一些特殊的场合要求必须使用继承。除此以外，创建一个类时肯定会进行继承，因为若非如此，会从 Java 的标准根类 Object 中继承。

用于合成的语法是非常简单且直观的。但为了进行继承，必须采用一种全然不同的形式。需要继承的时候，

我们会说：“这个新类和那个旧类差不多。”为了在代码里表面这一观念，需要给出类名。但在类主体的起

始花括号之前，需要放置一个关键字extends，在后面跟随“基础类”的名字。若采取这种做法，就可自动

获得基础类的所有数据成员以及方法。下面是一个例子（super关键字：Java 提供了一个 super 关键字，它引用当前类已从中继承的一个“超类”（Superclass）。所以表达式super.scrub()调用的是方法 scrub()的基础类版本。）

class Cleanser {

private String s = new String("Cleanser");

public void append(String a) { s += a; }

public void dilute() { append(" dilute()"); }

public void apply() { append(" apply()"); }

public void scrub() { append(" scrub()"); }

public void print() { System.out.println(s); }

public static void main(String[] args) {

Cleanser x = new Cleanser();

x.dilute(); x.apply(); x.scrub();

x.print();

}

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

x.print();

System.out.println("Testing base class:");

Cleanser.main(args);

}

} ///:~

这个例子向大家展示了大量特性。首先，在Cleanser append()方法里，字串同一个s 连接起来。这是用

“+=”运算符实现的。同“+”一样，“+=”被Java 用于对字串进行“过载”处理。

其次，无论 Cleanser 还是Detergent 都包含了一个main()方法。我们可为自己的每个类都创建一个

main()。通常建议大家象这样进行编写代码，使自己的测试代码能够封装到类内。即便在程序中含有数量众

多的类，但对于在命令行请求的public 类，只有main()才会得到调用。所以在这种情况下，当我们使用

“java Detergent”的时候，调用的是 Degergent.main()——即使Cleanser 并非一个public 类。采用这种

将main()置入每个类的做法，可方便地为每个类都进行单元测试。而且在完成测试以后，毋需将main()删

去；可把它保留下来，用于以后的测试。

需要着重强调的是 Cleanser 中的所有类都是public 属性。请记住，倘若省略所有访问指示符，则成员默认为“友好的”。这样一来，就只允许对包成员进行访问。在这个包内，任何人都可使用那些没有访问指示符

的方法。例如，Detergent 将不会遇到任何麻烦。然而，假设来自另外某个包的类准备继承Cleanser，它就

只能访问那些public 成员。所以在计划继承的时候，一个比较好的规则是将所有字段都设为private，并将

所有方法都设为public（protected 成员也允许衍生出来的类访问它；以后还会深入探讨这一问题）。当

然，在一些特殊的场合，我们仍然必须作出一些调整，但这并不是一个好的做法。

注意Cleanser 在它的接口中含有一系列方法：append()，dilute()，apply()，scrub()以及print()。由于

Detergent 是从Cleanser 衍生出来的（通过 extends 关键字），所以它会自动获得接口内的所有这些方法——即使我们在 Detergent 里并未看到对它们的明确定义。这样一来，就可将继承想象成“对接口的重复利

用”或者“接口的再生”（以后的实施细节可以自由设置，但那并非我们强调的重点）。

正如在 scrub()里看到的那样，可以获得在基础类里定义的一个方法，并对其进行修改。在这种情况下，我

们通常想在新版本里调用来自基础类的方法。但在 scrub()里，不可只是简单地发出对scrub()的调用。那样

便造成了递归调用，我们不愿看到这一情况。为解决这个问题，Java 提供了一个 super 关键字，它引用当前类已从中继承的一个“超类”（Superclass）。所以表达式super.scrub()调用的是方法 scrub()的基础类版

本。

进行继承时，我们并不限于只能使用基础类的方法。亦可在衍生出来的类里加入自己的新方法。这时采取的做法与在普通类里添加其他任何方法是完全一样的：只需简单地定义它即可。extends 关键字提醒我们准备将新方法加入基础类的接口里，对其进行“扩展”。foam()便是这种做法的一个产物。

在Detergent.main()里，我们可看到对于Detergent 对象，可调用Cleanser 以及Detergent 内所有可用的

方法（如foam()）。

6.2.1 初始化基础类

由于这儿涉及到两个类——基础类及衍生类，而不再是以前的一个，所以在想象衍生类的结果对象时，可能会产生一些迷惑。从外部看，似乎新类拥有与基础类相同的接口，而且可包含一些额外的方法和字段。但继承并非仅仅简单地复制基础类的接口了事。创建衍生类的一个对象时，它在其中包含了基础类的一个“子对象”。这个子对象就象我们根据基础类本身创建了它的一个对象。从外部看，基础类的子对象已封装到衍生类的对象里了。

当然，基础类子对象应该正确地初始化，而且只有一种方法能保证这一点：在构建器中执行初始化，通过调用基础类构建器，后者有足够的能力和权限来执行对基础类的初始化。在衍生类的构建器中，Java 会自动插入对基础类构建器的调用。下面这个例子向大家展示了对这种三级继承的应用：

//: Cartoon.java

// Constructor calls during inheritance

class Art {

Art() {

System.out.println("Art constructor");

}

class Drawing extends Art {

Drawing() {

System.out.println("Drawing constructor");

}

public class Cartoon extends Drawing {

Cartoon() {

System.out.println("Cartoon constructor");

}

public static void main(String[] args) {

Cartoon x = new Cartoon();

}

} ///:~

该程序的输出显示了自动调用：

Art constructor

Drawing constructor

Cartoon constructor

可以看出，构建是在基础类的“外部”进行的，所以基础类会在衍生类访问它之前得到正确的初始化。

即使没有为 Cartoon()创建一个构建器，编译器也会为我们自动合成一个默认构建器，并发出对基础类构建

器的调用。

1. 含有自变量的构造器

上述例子有自己默认的构建器；也就是说，它们不含任何自变量。编译器可以很容易地调用它们，因为不存在具体传递什么自变量的问题。如果类没有默认的自变量，或者想调用含有一个自变量的某个基础类构建器，必须明确地编写对基础类的调用代码。这是用 super 关键字以及适当的自变量列表实现的，如下所示：

class Game {

Game(int i) {

System.out.println("Game constructor");

}

class BoardGame extends Game {

BoardGame(int i) {

super(i);

System.out.println("BoardGame constructor");

}

public class Chess extends BoardGame {

Chess() {

super(11);

System.out.println("Chess constructor");

}

public static void main(String[] args) {

Chess x = new Chess();

}

} ///:~

如果不调用 BoardGames()内的基础类构建器，编译器就会报告自己找不到Games()形式的一个构建器。除此以外，在衍生类构建器中，对基础类构建器的调用是必须做的第一件事情（如操作失当，编译器会向我们指出）。

2. 捕获基本构建器的违例

正如刚才指出的那样，编译器会强迫我们在衍生类构建器的主体中首先设置对基础类构建器的调用。这意味着在它之前不能出现任何东西。正如大家在第 9 章会看到的那样，这同时也会防止衍生类构建器捕获来自一个基础类的任何违例事件。显然，这有时会为我们造成不便。

6.3 合成与继承的结合

class Plate {

Plate(int i) {

System.out.println("Plate constructor");

}

class DinnerPlate extends Plate {

DinnerPlate(int i) {

super(i);

System.out.println(

"DinnerPlate constructor");

}

class Utensil {

Utensil(int i) {

System.out.println("Utensil constructor");

}

class Spoon extends Utensil {

Spoon(int i) {

super(i);

System.out.println("Spoon constructor");

}

class Fork extends Utensil {

Fork(int i) {

super(i);

System.out.println("Fork constructor");

}

class Knife extends Utensil {

Knife(int i) {

super(i);

System.out.println("Knife constructor");

}

// A cultural way of doing something:

class Custom {

Custom(int i) {

System.out.println("Custom constructor");

}

public class PlaceSetting extends Custom {

Spoon sp;

Fork frk;

Knife kn;

DinnerPlate pl;

PlaceSetting(int i) {

super(i + 1);

sp = new Spoon(i + 2);

frk = new Fork(i + 3);

kn = new Knife(i + 4);

pl = new DinnerPlate(i + 5);

System.out.println(

"PlaceSetting constructor");

}

public static void main(String[] args) {

PlaceSetting x = new PlaceSetting(9);

}

} ///:~

尽管编译器会强迫我们对基础类进行初始化，并要求我们在构建器最开头做这一工作，但它并不会监视我们是否正确初始化了成员对象。所以对此必须特别加以留意。

Super关键字和this关键字的区别：

1.在子类的成员方法中，访问父类的成员变量。

2.在子类的成员方法中，访问父类的成员方法。

3.在子类的构造方法中，访问父类的构造方法。

public class Zi extends Fu {

int num = 20;

public Zi(){

super();

}

public void methodZi(){

System.out.println(super.num); //父类中的num

}

public void method(){

super.method(); //访问父类中的method

System.out.println("子类方法");

}

父类：

public class Fu {

int num = 10;

public void method(){

System.out.println();

}

super关键字用来访问父类内容，而this 关键字用来访问本类内容，用法也有三种：

1.在本类的成员方法中，访问本类的成员变量。

2.在本类的成员方法中，访问本类的另一个成员方法。

3.在本类的构造方法中，访问本类的另一个构造方法。

在第三种用法中要注意：

a. this(..)调用也必须是构造方法的第一语句，唯一一个

b.super和this两种构造调用，不能同时使用。

public class Zi extends Fu{

int num = 20;

public Zi(){

// super();

this(134); //本类的无参构造，调用本类的有参构造

}

public Zi(int n ){

}

public Zi(int n, int m ){

}

public void showNum(){

int num = 10;

System.out.println(num); //局部变量

System.out.println(this.num); //本类中的成员变量

System.out.println(super.num); //父类中的成员变量

}

父类：

public class Fu {

int num =30;

}

6.3.1 确保正确的清除（子类调父类/基类的方法使用super关键字）

6.3.2 名字的隐藏

6.4 到底选择合成还是继承

无论合成还是继承，都允许我们将子对象置于自己的新类中。大家或许会奇怪两者间的差异，以及到底该如何选择。

如果想利用新类内部一个现有类的特性，而不想使用它的接口，通常应选择合成。也就是说，我们可嵌入一个对象，使自己能用它实现新类的特性。但新类的用户会看到我们已定义的接口，而不是来自嵌入对象的接口。考虑到这种效果，我们需在新类里嵌入现有类的private 对象。

有些时候，我们想让类用户直接访问新类的合成。也就是说，需要将成员对象的属性变为public。成员对象会将自身隐藏起来，所以这是一种安全的做法。而且在用户知道我们准备合成一系列组件时，接口就更容易理解。

现在我们已理解了继承的概念，protected 这个关键字最后终于有了意义。在理想情况下，private 成员随时都是“私有”的，任何人不得访问。但在实际应用中，经常想把某些东西深深地藏起来，但同时允许访问衍生类的成员。protected 关键字可帮助我们做到这一点。它的意思是“它本身是私有的，但可由从这个类继承的任何东西或者同一个包内的其他任何东西访问”。也就是说，Java 中的protected 会为进入“友好”状态。

我们采取的最好的做法是保持成员的private 状态——无论如何都应保留对基础的实施细节进行修改的权利。在这一前提下，可通过protected 方法允许类的继承者进行受到控制的访问：

class Villain {

private int i;

protected int read() {

return i;

}

protected void set(int ii) {

i = ii;

System.out.println(i);

}

public Villain(int ii) {

i = ii;

}

public int value(int m) {

return m*i;

}

public class Car extends Villain {

private int j;

public static void main(String[] args) {

Car car=new Car(1);

car.change(222);

}

public Car(int jj) {

super(jj);

j = jj;

System.out.println(j);

}

public void change(int x) {

set(x);

System.out.println(x);

}

} ///:~

可以看到，change()拥有对 set()的访问权限，因为它的属性是 protected（受到保护的）。

6.6 累积开发

继承的一个好处是它支持“累积开发”，允许我们引入新的代码，同时不会为现有代码造成错误。这样可将新错误隔离到新代码里。通过从一个现成的、功能性的类继承，同时增添成员新的数据成员及方法（并重新定义现有方法），我们可保持现有代码原封不动（另外有人也许仍在使用它），不会为其引入自己的编程错误。一旦出现错误，就知道它肯定是由于自己的新代码造成的。这样一来，与修改现有代码的主体相比，改正错误所需的时间和精力就可以少很多。

类的隔离效果非常好，这是许多程序员事先没有预料到的。甚至不需要方法的源代码来实现代码的再生。最多只需要导入一个包（这对于继承和合并都是成立的）。

大家要记住这样一个重点：程序开发是一个不断递增或者累积的过程，就象人们学习知识一样。当然可根据要求进行尽可能多的分析，但在一个项目的设计之初，谁都不可能提前获知所有的答案。如果能将自己的项目看作一个有机的、能不断进步的生物，从而不断地发展和改进它，就有望获得更大的成功以及更直接的反馈。

尽管继承是一种非常有用的技术，但在某些情况下，特别是在项目稳定下来以后，仍然需要从新的角度考察自己的类结构，将其收缩成一个更灵活的结构。请记住，继承是对一种特殊关系的表达，意味着“这个新类属于那个旧类的一种类型”。我们的程序不应纠缠于一些细树末节，而应着眼于创建和操作各种类型的对象，用它们表达出来自“问题空间”的一个模型。

6.7 final关键字

由于语境（应用环境）不同，final 关键字的含义可能会稍微产生一些差异。但它最一般的意思就是声明 “这个东西不能改变”。之所以要禁止改变，可能是考虑到两方面的因素：设计或效率。由于这两个原因颇有些区别，所以也许会造成final 关键字的误用。在接下去的小节里，我们将讨论final 关键字的三种应用场合：数据、方法以及类。

6.8.1 final数据

许多程序设计语言都有自己的办法告诉编译器某个数据是“常数”。常数主要应用于下述两个方面：

(1) 编译期常数，它永远不会改变

(2) 在运行期初始化的一个值，我们不希望它发生变化

对于编译期的常数，编译器（程序）可将常数值“封装”到需要的计算过程里。也就是说，计算可在编译期间提前执行，从而节省运行时的一些开销。在 Java 中，这些形式的常数必须属于基本数据类型（Primitives），而且要用 final 关键字进行表达。在对这样的一个常数进行定义的时候，必须给出一个值。

无论static 还是 final 字段，都只能存储一个数据，而且不得改变。

若随同对象句柄使用final，而不是基本数据类型，它的含义就稍微让人有点儿迷糊了。对于基本数据类型，final 会将值变成一个常数；但对于对象句柄，final 会将句柄变成一个常数。进行声明时，必须将句柄初始化到一个具体的对象。而且永远不能将句柄变成指向另一个对象。然而，对象本身是可以修改的。Java对此未提供任何手段，可将一个对象直接变成一个常数（但是，我们可自己编写一个类，使其中的对象具有“常数”效果）。这一限制也适用于数组，它也属于对象。

下面是演示 final 字段用法的一个例子：

class Value {

int i = 1;

}

public class FinalData {

// Can be compile-time constants

final int i1 = 9;

static final int I2 = 99;

// Typical public constant:

public static final int I3 = 39;

// Cannot be compile-time constants:

final int i4 = (int)(Math.random()*20);

static final int i5 = (int)(Math.random()*20);

Value v1 = new Value();

final Value v2 = new Value();

static final Value v3 = new Value();

//! final Value v4; // Pre-Java 1.1 Error:

// no initializer

// Arrays:

final int[] a = { 1, 2, 3, 4, 5, 6 };

public void print(String id) {

System.out.println(

id + ": " + "i4 = " + i4 +

", i5 = " + i5);

}

public static void main(String[] args) {

FinalData fd1 = new FinalData();

//! fd1.i1++; // Error: can't change value

fd1.v2.i++; // Object isn't constant!

fd1.v1 = new Value(); // OK -- not final

for(int i = 0; i < fd1.a.length; i++)

fd1.a[i]++; // Object isn't constant!

//! fd1.v2 = new Value(); // Error: Can't

//! fd1.v3 = new Value(); // change handle

//! fd1.a = new int[3];

fd1.print("fd1");

System.out.println("Creating new FinalData");

FinalData fd2 = new FinalData();

fd1.print("fd1");

fd2.print("fd2");

}

} ///:~/:~

由于i1 和 I2 都是具有 final 属性的基本数据类型，并含有编译期的值，所以它们除了能作为编译期的常数使用外，在任何导入方式中也不会出现任何不同。I3 是我们体验此类常数定义时更典型的一种方式：public表示它们可在包外使用；Static 强调它们只有一个；而 final 表明它是一个常数。注意对于含有固定初始化值（即编译期常数）的 fianl static 基本数据类型，它们的名字根据规则要全部采用大写。也要注意i5 在编译期间是未知的，所以它没有大写。

不能由于某样东西的属性是final，就认定它的值能在编译时期知道。i4 和i5 向大家证明了这一点。它们在运行期间使用随机生成的数字。例子的这一部分也向大家揭示出将final 值设为 static 和非static 之间的差异。只有当值在运行期间初始化的前提下，这种差异才会揭示出来。因为编译期间的值被编译器认为是相同的。这种差异可从输出结果中看出：

fd1: i4 = 15, i5 = 9

Creating new FinalData

fd1: i4 = 15, i5 = 9

fd2: i4 = 10, i5 = 9

注意对于fd1 和 fd2 来说，i4 的值是唯一的，但 i5 的值不会由于创建了另一个FinalData 对象而发生改变。那是因为它的属性是static，而且在载入时初始化，而非每创建一个对象时初始化。

从v1 到v4 的变量向我们揭示出final 句柄的含义。正如大家在main()中看到的那样，并不能认为由于v2属于final，所以就不能再改变它的值。然而，我们确实不能再将v2 绑定到一个新对象，因为它的属性是final。这便是final 对于一个句柄的确切含义。我们会发现同样的含义亦适用于数组，后者只不过是另一种类型的句柄而已。将句柄变成 final 看起来似乎不如将基本数据类型变成 final 那么有用。

i5不发生改变的原因是因为i5的值是static final会，static关键字会只保证初始化一次，而i4发生改变的原因是只有final关键字，当new一个新对象的时候会再给这个句柄的对象初始化一下这个variable。

2.空白final

Java 1.1 允许我们创建“空白final”，它们属于一些特殊的字段。尽管被声明成 final，但却未得到一个初始值。无论在哪种情况下，空白 final 都必须在实际使用前得到正确的初始化。而且编译器会主动保证这一规定得以贯彻。然而，对于 final 关键字的各种应用，空白 final 具有最大的灵活性。举个例子来说，位于类内部的一个final 字段现在对每个对象都可以有所不同，同时依然保持其“不变”的本质。下面列出一个例子：

class Poppet {

}

class BlankFinal {

final int i = 0; // Initialized final

final int j; // Blank final

final Poppet p; // Blank final handle

// Blank finals MUST be initialized

// in the constructor:

BlankFinal() {

j = 1; // Initialize blank final

p = new Poppet();

}

BlankFinal(int x) {

j = x; // Initialize blank final

p = new Poppet();

}

public static void main(String[] args) {

BlankFinal bf = new BlankFinal();

}

} ///:~

现在强行要求我们对final 进行赋值处理——要么在定义字段时使用一个表达式，要么在每个构建器中。这样就可以确保final 字段在使用前获得正确的初始化

3.final自变量

Java 1.1 允许我们将自变量设成 final 属性，方法是在自变量列表中对它们进行适当的声明。这意味着在一个方法的内部，我们不能改变自变量句柄指向的东西。如下所示：

class Gizmo {

public void spin() {}

}

public class FinalArguments {

void with(final Gizmo g) {

//! g = new Gizmo(); // Illegal -- g is final

g.spin();

}

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

}

} ///:~

注意此时仍然能为 final 自变量分配一个null（空）句柄，同时编译器不会捕获它。这与我们对非 final 自变量采取的操作是一样的。

方法f()和 g()向我们展示出基本类型的自变量为 final 时会发生什么情况：我们只能读取自变量，不可改变它。

6.8.2 final方法

之所以要使用final 方法，可能是出于对两方面理由的考虑。第一个是为方法“上锁”，防止任何继承类改变它的本来含义。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。

采用final 方法的第二个理由是程序执行的效率。将一个方法设成 final 后，编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。只要编译器发现一个final 方法调用，就会（根据它自己的判断）忽略为执行方法调用机制而采取的常规代码插入方法（将自变量压入堆栈；跳至方法代码并执行它；跳回来；清除

堆栈自变量；最后对返回值进行处理）。相反，它会用方法主体内实际代码的一个副本来替换方法调用。这样做可避免方法调用时的系统开销。当然，若方法体积太大，那么程序也会变得雍肿，可能受到到不到嵌入代码所带来的任何性能提升。因为任何提升都被花在方法内部的时间抵消了。Java 编译器能自动侦测这些情况，并颇为“明智”地决定是否嵌入一个 final 方法。然而，最好还是不要完全相信编译器能正确地作出所有判断。通常，只有在方法的代码量非常少，或者想明确禁止方法被覆盖的时候，才应考虑将一个方法设为final。

类内所有private 方法都自动成为final。由于我们不能访问一个 private 方法，所以它绝对不会被其他方法覆盖（若强行这样做，编译器会给出错误提示）。可为一个 private 方法添加final 指示符，但却不能为那个方法提供任何额外的含义。

6.8.3 final类

如果说整个类都是 final（在它的定义前冠以 final 关键字），就表明自己不希望从这个类继承，或者不允许其他任何人采取这种操作。换言之，出于这样或那样的原因，我们的类肯定不需要进行任何改变；或者出于安全方面的理由，我们不希望进行子类化（子类处理）。

除此以外，我们或许还考虑到执行效率的问题，并想确保涉及这个类各对象的所有行动都要尽可能地有效。如下所示：

//: Jurassic.java

//Making an entire class final

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++;

System.out.println(n.i+" "+n.j);

}

} ///:~

注意数据成员既可以是 final，也可以不是，取决于我们具体选择。应用于 final 的规则同样适用于数据成员，无论类是否被定义成final。将类定义成 final 后，结果只是禁止进行继承——没有更多的限制。然而，由于它禁止了继承，所以一个 final 类中的所有方法都默认为final。因为此时再也无法覆盖它们。所以与我们将一个方法明确声明为final 一样，编译器此时有相同的效率选择。

可为final 类内的一个方法添加final 指示符，但这样做没有任何意义。

6.9 初始化和类装载

在许多传统语言里，程序都是作为启动过程的一部分一次性载入的。随后进行的是初始化，再是正式执行程序。在这些语言中，必须对初始化过程进行慎重的控制，保证 static 数据的初始化不会带来麻烦。比如在一个static 数据获得初始化之前，就有另一个 static 数据希望它是一个有效值，那么在 C++中就会造成问题。

Java 则没有这样的问题，因为它采用了不同的装载方法。由于 Java 中的一切东西都是对象，所以许多活动变得更加简单，这个问题便是其中的一例。正如下一章会讲到的那样，每个对象的代码都存在于独立的文件中。除非真的需要代码，否则那个文件是不会载入的。通常，我们可认为除非那个类的一个对象构造完毕，否则代码不会真的载入。由于 static 方法存在一些细微的歧义，所以也能认为“类代码在首次使用的时候载入”。

首次使用的地方也是static 初始化发生的地方。装载的时候，所有static 对象和 static 代码块都会按照本来的顺序初始化（亦即它们在类定义代码里写入的顺序）。当然，static 数据只会初始化一次。

class Insect {

int i = 9;

int j;

Insect() {

prt("i = " + i + ", j = " + j);

j = 39;

}

static int x1 =

prt("static Insect.x1 initialized");

static int prt(String s) {

System.out.println(s);

return 47;

}

public class Beetle extends Insect {

int k = prt("Beetle.k initialized");

Beetle() {

prt("k = " + k);

prt("j = " + j);

}

static int x2 =

prt("static Beetle.x2 initialized");

static int prt(String s) {

System.out.println(s);

return 63;

}

public static void main(String[] args) {

prt("Beetle constructor");

Beetle b = new Beetle();

}

} ///:

该程序的输出如下：

static Insect.x initialized

static Beetle.x initialized

Beetle constructor

i = 9, j = 0

Beetle.k initialized

k = 63

j = 39

对Beetle 运行Java 时，发生的第一件事情是装载程序到外面找到那个类。在装载过程中，装载程序注意它有一个基础类（即 extends 关键字要表达的意思），所以随之将其载入。无论是否准备生成那个基础类的一个对象，这个过程都会发生（请试着将对象的创建代码当作注释标注出来，自己去证实）。

若基础类含有另一个基础类，则另一个基础类随即也会载入，以此类推。接下来，会在根基础类（此时是Insect）执行 static 初始化，再在下一个衍生类执行，以此类推。保证这个顺序是非常关键的，因为衍生类的初始化可能要依赖于对基础类成员的正确初始化。

此时，必要的类已全部装载完毕，所以能够创建对象。首先，这个对象中的所有基本数据类型都会设成它们的默认值，而将对象句柄设为 null。随后会调用基础类构建器。在这种情况下，调用是自动进行的。但也完全可以用super 来自行指定构建器调用（就象在Beetle()构建器中的第一个操作一样）。基础类的构建采用与衍生类构建器完全相同的处理过程。基础顺构建器完成以后，实例变量会按本来的顺序得以初始化。最后，执行构建器剩余的主体部分。

标签：int,final,public,static,println,再生,class
来源： https://blog.csdn.net/weixin_37573305/article/details/122487921