4.1.1. 变量¶

编程语言最强大的特性之一是能够定义和操作变量。 变量 是一个命名的位置，用于存储一个值。值可以是数字、文本、图像、声音以及其他类型的数据。要存储一个值，你首先必须声明一个变量。

int x = 7;

每个变量都有一个类型，该类型决定了它可以存储的值的种类。此语句是一个 声明，因为它声明了名为 x 、类型为 int 的变量，并为其赋予初始值 7。

请注意， x 是变量的任意名称。一般来说，应使用能表明变量所代表含义的名称——无论是它所持有的值，还是其扮演的角色。例如，如果你看到以下声明，大概可以猜出将存储的值：

int ageInYears = 21;
int studentID = 1234;

本例声明了两个变量，每个变量的类型均为 int。当变量名包含多个单词时，如 ageInYears ，通常将除首个单词外的每个单词首字母大写，这与方法命名方式一致。这种大小写约定称为 camel case （有时写作 CamelCase），其中大写字母在名称中形成周期性的“驼峰”。在 Java 中，如同大多数编程语言，名称区分大小写，因此 ageInYears 与 ageinyears 或 AgeInYears 并不相同。请记住，变量名始终以小写字母开头，而首字母大写则保留用于类名和接口名。

你可以为变量使用任意名称，但有大约 50 个保留字，称为关键字，你不能将其用作变量名。这些关键字包括 public 、 class 、 static 、 void 和 int ，它们由编译器用于分析程序的结构。你可以在线查找 完整关键字列表，但不必死记硬背。大多数编程编辑器提供“语法高亮”功能，可使程序的不同部分以不同颜色显示。

int ageInYears = 29; // 29 is the initial value for ageInYears
ageInYears = 21;  // set ageInYears to now store 21

int ageInYears = 29;

int a = 5;
int b = 7;
a = b;

int a = 5;
int b = a; //a and b are now equal
a = 3;     //a and b are no longer equal!

int hour = 11;
int minutes = 59;
int timeAsMinutes = hour * 60 + minutes;

int minutes = 59;
int fractionOfHour = minutes / 60;

int minute = 59;
int fractionOfHour = (minute * 100) / 60;

double pi = 3.14159;

double minutes = 59.0;
double fractionOfHour = minutes / 60;

int x = 1.1; // compiler error

double y = 1; // legal, but bad style

double y = 1 / 3; // common mistake

if (this.hasFlower())
{
    this.hop();
}

boolean pocketIsFull = this.hasFlower();

boolean pocketIsFull = this.hasFlower();
if (pocketIsFull)
{
    this.hop();
}

boolean shouldToss = this.hasFlower() && this.seesNet(AHEAD);
if (shouldToss)
{
    this.toss();
}

boolean x = true;
boolean y = false;

4.1.2. 布尔运算符：与、或、非及短路求值¶

条件有两种形式：简单 和 复合。简单条件是一个不包含任何其他 boolean 表达式的 boolean 表达式（例如单个传感器方法调用，如 jeroo.isWater(AHEAD) ）。复合条件 是通过使用 Java 逻辑运算符将两个或多个简单条件连接而成：与（ && ）、或（ || ）和非（ ! ）。

public void doSomeStuff()
{
    int x = 17;  // declared here
    ...
    if (jeroo.getX() == 17)    // OK to use here, inside scope
    {
        ...
    }

    // scope of x ends at closing brace
}

public void doOtherStuff()
{
   if (x == 17)  // compiler error! x can't be referenced
   {
       ...
   }
}

public void doSomeStuff()
{
    ...
    if (jeroo.hasFlower())
    {
        int x = 17;  // declared here
        ...
        if (jeroo.getX() == 17)    // OK to use here, inside scope
        {
            ...
        }

        // scope of x ends at closing brace
    }

    x = 4;  // compiler error! x can't be referenced
}

4.1.3. 字段与局部变量¶

编写面向对象的程序在很大程度上是设计类，并在 Java 中为这些类编写定义。设计一个类就是指定该类型对象所特有的所有属性和行为。

到目前为止，我们一直使用属性和动作这两个术语来描述对象的特征。然而，在讨论编程语言时，更常见的说法是通过字段和方法来描述对象的特征。 字段 是一类我们在类开始时定义的变量，帮助我们描述类的特性。

例如，假设我们正在编写一个绘图程序。程序中需要的一种对象是矩形。一个 Rectangle 对象具有两个关键属性：其长度和宽度。在类内部，我们可以声明两个字段来存储这些属性的值：一个 length 和一个 width 。有了这两个字段，我们就可以定义矩形的典型操作，例如计算其面积以及绘制自身的能力。识别对象的字段与操作正是开发面向对象程序时所涉及的设计活动。

我们可以声明字段在我们的 Rectangle 类中：

public class Rectangle
{
    private int length;
    private int width;
    private int xCoord;
    private int yCoord;

    // other parts of the class go here ...
}

我们的矩形有四个属性。前两个， length 和 width ，存储矩形的尺寸。后两个， xCoord 和 yCoord ，存储绘制矩形时的位置信息，类似于我们确定 jeroo 在岛屿上的位置方式。请注意，这些属性均无具体数值。这是因为该类代表的是矩形的一般类型，而每个具体的矩形将拥有自己独立的属性值。声明仅指定了所有矩形共有的特征，而不代表任何一个特定的矩形。如同制作饼干的模具一般，类给出了对象的一般形状。任何具体对象的具体数值并不包含在内。

显著的是，这些字段也使用关键字 private ，表示它们只能在此类内部被访问和操作。按照惯例，我们 始终 包含关键字 private ，以确保只有类内部的代码才能访问或修改这些字段。这贯彻了一种软件工程设计原则，称为 信息隐藏，即只有类自身负责管理其相关信息，类外部的任何代码均无法干扰或更改此类内部信息。

一个字段对于不同的对象将具有不同的值——也就是说，对于类的不同实例。例如，各个 Rectangle 实例的 length 、 width 、 xCoord 和 yCoord 字段将具有不同的值。例如，我们可以创建两个不同的 Rectangle 对象：

要创建两个不同的 Rectangle 对象，我们需要一个构造函数。回想一下，构造函数的主要职责之一是初始化对象中存储的数据（即其字段中的数据）。由于我们的 Rectangle 类使用字段来存储属性值，因此构造函数需要初始化这些值。有时，你可能会将字段初始化为所有对象的固定值，但通常希望创建对象的代码能够指定初始值。如果此处我们希望实现这一点，就需要一个 Rectangle 构造函数，该构造函数接受 4 个整数作为参数：

public class Rectangle
{
    private int length;
    private int width;
    private int xCoord;
    private int yCoord;

    public Rectangle(int myLength, int myWidth, int initialX, int initialY)
    {
        this.length = myLength;
        this.width = myWidth;
        this.xCoord = initialX;
        this.yCoord = initialY;
    }

    // other parts of the class go here ...
}

然后，如果我们想要调用这个构造函数，可以说：

Rectangle rectangle1 = new Rectangle(2, 5, 0, 0);

哪一项会将 length 设为 2， width 设为 5，坐标设为 (0, 0)。

4.1.4. 修改私有变量：修改方法¶

回忆一下， Rectangle 的字段是私有的。我们可以在 Rectangle 类内部任何位置访问它们，但不能在类外部访问。

public class Runner
{
    public void myProgram()
    {
        Rectangle rectangle1 = new Rectangle(0, 0, 2, 5);
        int w = rectangle1.width;  // compiler error! Can't access field
    }
}

因为 length 是私有的，上述代码在编译时将导致错误。这是一种防止字段被意外修改或在不需要时被修改的便捷方式，相当于强制实现信息隐藏。信息隐藏有助于限制意外引入错误的可能性，也有助于在错误发生时缩小排查范围。此外，如果我们的 Rectangle 类将来发生变化，上述代码很可能也需要随之修改，这意味着此 Runner 类依赖于 Rectangle 类的内部细节。这会使未来的修改更加困难。因此，信息隐藏能够 减少引入错误的机会，也能 减少排查错误时需要检查的代码量，还能 降低未来修改的成本。这就是我们在此类中始终将字段声明为 private 的原因。最终，你将学习到关于字段的其他选项，但请记住，放宽信息隐藏会带来显著代价。

另一方面，这个 Runner 类可能需要访问并更改 Rectangle 类中的字段——例如，为了将其移动到新位置。为了避免直接访问字段，面向对象编程的一种惯例是：在设计合适时，为对象的某些属性提供公共方法以设置和获取其值。

获取或检索属性值的方法称为 访问器方法，或更通俗地称为 getter 方法。将对象的属性设置为新值的方法称为 修改器方法，或更通俗地称为 setter 方法。通常情况下，访问器和修改器方法会直接与对象的字段进行操作，如果属性是直接存储在字段中的。

由类的设计者根据该类所代表的抽象来决定哪些属性需要访问器方法和/或修改器方法。某些字段可能仅用于内部使用，不表示外部可见的属性。其他属性可能存储在字段中，但更适合只读使用，仅提供访问器方法。在其他情况下，类可能同时支持读取和修改属性，此时访问器和修改器都适用。

如果正在设计一个 BankAccount 类，例如，您可能希望提供一个公共的 getAccountNumber() 方法，以便客户端能够检索其银行账户的信息，但您可能不会希望提供一个公共的 setAccountNumber() 来让客户端修改该信息，也不会提供一个公共的 getAccountPassword() 用于应仅限内部使用的数据。

我们将在下面讨论访问器方法，但首先让我们看看修改器方法。对于我们的 Rectangle 示例，假设我们希望其他类能够更改 xCoord 和 yCoord 属性，以移动 Rectangle 在屏幕上的位置。修改器方法可以简单如以下所示：

public class Rectangle
{
    // field declarations from above go here

    public void setXCoord(int newValue)
    {
        this.xCoord = newValue;
    }

    public void setYCoord(int newValue)
    {
        this.yCoord = newValue;
    }
}

这段代码还展示了为直接存储在字段中的任何属性提供修改方法的简单模式。该模式的关键要素是：

• 变量修改方法是 public ，因为我们希望它可以在任何位置被访问。

• 它的返回类型是 void ，因为此方法不 return 任何操作。

• 此方法通过在所更改属性名称前加上 set 作为前缀来命名，使用我们复合名称的大写约定。

• 此方法接受一个与字段类型相同的参数。

• 方法体使用赋值语句将字段设置为新值。

这种模式使用得如此频繁，以至于程序员在提到“设置方法”或说“为它添加一个设置方法”时，几乎总是指这种模式。

public class Rectangle
{
    private int length;

    public void setLength(int len)
    {
        this.length = len;
    }
}

4.1.5. 访问方法¶

创建访问器方法时，如果相应的属性存储在字段中，也会遵循一个非常简单的模式，尽管有一个我们之前未涉及的细节。

public class Rectangle
{
    private int length;
    // other field declarations from above go here

    public int getLength()
    {
        return this.length;
    }
}

此代码展示了为直接存储在字段中的任何属性提供访问方法的简单模式。该模式的关键要素是：

• 访问器方法为 public ，因为我们希望它可以在任何位置被访问。

• 在关键字 public 之后，我们不再使用 void ，而是列出字段中存储的数据类型，该类型与本方法将返回的数据类型相同。

• 该方法通过在所访问属性名称前添加 get 作为前缀来命名，遵循复合名称的大写规范。

• 该方法不接受任何参数。

• 该方法的主体使用 return 语句返回字段的值。

这种模式使用频率极高，几乎总是程序员在提到“获取方法”或说“为其添加一个获取方法”时所指的内容。

不同之处在于返回类型不再是 void （而是字段的类型），并且用到了新的 return 关键字，我们将在下一节中讨论这一点。目前最重要的是要注意，方法的返回类型必须与字段类型一致。因此，由于 length 被定义为 int 类型，此访问器方法的返回类型也必须是 int 。

4.1.6. 返回关键字¶

在返回类型为 void 的方法之外，你在 Java 中编写的其他所有方法都必须指定一个返回类型——即该方法将返回的 答案 或 结果 的类型。到目前为止，我们主要使用了 void 方法，这类方法不返回任何结果——实际上， void 表示“无”，我们调用这些方法是出于它们执行的动作，而非计算出的值。

用来为我们计算值的方法在被调用时“返回”这些值。当我们说“返回一个值”时，意思是“给我们一个答案”或“产生一个结果”。与 void 方法相比，返回值的方法在两个方面有所不同：

• 它们声明了返回值的类型（返回类型）。

• 它们至少使用一条 return 语句来提供一个 返回值。

例如，如果你要编写如下方法：

public boolean isRaining()
{
    // no code yet
}

当你编译时会看到语法错误，提示“缺少返回语句”。这是因为关键字 public 后使用 boolean 指定了该方法 将 返回一个 boolean 结果，但方法体中并未说明返回什么值。要解决此问题，我们需要返回一个值。

public boolean isRaining()
{
    return false;
}

方法的 return 语句用于指定调用该方法时所生成的值。在关键字 return 之后，您可以使用任意表达式，包括常量（如上文的 false ）、变量、字段、数学表达式，甚至其他方法调用的组合。

语句 return 中表达式的类型必须与方法声明的返回类型相匹配。当你声明返回类型为 double 时，你实际上是在承诺该方法最终将产生一个 double 值。如果你尝试使用无表达式，或表达式类型错误的 return ，编译器将会生成错误。

public class Rectangle
{
    private int length;

    public Rectangle()
    {
        this.length = 4;
    }

    public int getLength()
    {
        return this.length;
    }
}

public double absoluteValue(double x)
{
    if (x < 0)
    {
        return -x;
    }
    else
    {
        return x;
    }
}

public double absoluteValue(double x)
{
    double answer = x;
    if (x < 0)
    {
        answer = -x;
    }
    return answer;
}

public double calculateArea(double radius)
{
   // Note that Math.PI is a constant with the value of pi
   double result = Math.PI * radius * radius;
   return result;
}

public double calculateArea(double radius)
{
   return Math.PI * radius * radius;
}

public double absoluteValue(double x)
{
   if (x < 0)
   {
      return -x;
   }
   else
   {
      return x;
   }
   x = 5;    // can never be executed
 }

public double absoluteValue(double x)
{
   if (x < 0)
   {
      return -x;
   }
   else if (x > 0)
   {
      return x;
   }
   // syntax error
}

public void hopAndPick()
{
    this.hop();
    this.pick();
}

this.hopAndPick();

public int square(int x)
{
    return x * x;
}

int base = 3;
int raised = square(base);

int base = 3;
int raisedAgain = square(square(base));

4.1.7. 在测试中使用字段¶

上周，我们为一个Jeroo创建了一些简单的测试套件。你可能还记得，在每个测试开始时需要做大量设置工作，以确保Jeroo的位置完全符合预期，并且拥有正确数量的花朵。

然而，如果你连续有多个测试都需要相同的初始起始条件该怎么办？为了使测试过程更加高效，你可以声明 字段 而不是局部变量来保存大多数或全部测试中使用的公共对象。这样做后，就不必在每个测试方法中重复声明它们为局部变量，而是将它们声明为字段，使其对 所有 测试方法都可见，从而只需声明一次即可。

此外，与其在每个测试方法中重复编写设置初始条件的代码，不如只写一次，而不是在每个测试方法中重复。

为了了解其工作原理，请考虑软件测试模块中的这个示例测试方法：

public void testPickFlowers()
{
    // 1. set up initial conditions
    Lab04Island island = new Lab04Island();
    FlowerPicker picker = new FlowerPicker();
    island.addObject(picker, 1, 2);

    // 2. call the method
    picker.pickFlowers();

    // 3. check expected results
    assertThat(picker.getX()).isEqualTo(6);
    assertThat(picker.getY()).isEqualTo(2);
    assertThat(picker.getFlowers()).isEqualTo(5);
    assertThat(picker.getHeading()).isEqualTo(EAST);
}

现在假设你正在编写一个包含多个测试的测试类：

public class FlowerPickerTest
    extends TestCase
{
    public void testPickFlowers()
    {
        // 1. set up initial conditions
        Lab04Island island = new Lab04Island();
        FlowerPicker picker = new FlowerPicker();
        island.addObject(picker, 1, 2);

        ...
    }

    public void testPickFlowersAgain()
    {
        // 1. set up initial conditions
        Lab04Island island = new Lab04Island();
        FlowerPicker picker = new FlowerPicker();
        island.addObject(picker, 1, 2);

        // turn picker south and move forward 1
        // for this test

        ...
    }
}

此处，两个测试均使用了 island ，且均使用了 picker 。它们都必须创建 island ，创建 picker ，并将 picker 放置在 island 上。这仅仅是重复的代码。

重复的代码是 代码异味 的一个例子，也就是设计可以改进的警示信号。有时你查看代码时，会本能地觉得有更好的实现方式——这就是一种 代码异味。如果你有这种感觉，几乎可以肯定存在更好的实现方式，修改代码将使其得到改善。

首先，与其在每个方法中使用名为 island 和 picker 的局部变量，不如将它们移至字段中：

public class FlowerPickerTest
    extends TestCase
{
    private Lab04Island island;
    private FlowerPicker picker;

    public void testPickFlowers()
    {
        // 1. No extra setup needed
        ...
    }

    public void testPickFlowersAgain()
    {
        // 1. set up initial conditions
        // turn picker south and move forward 1
        // for this test

        ...
    }
}

但我们在哪里放置用于创建对象的初始化代码呢？虽然构造函数似乎是个不错的选择，但构造函数仅在创建对象时执行一次。而这段初始化代码需要在我们类中的每一个测试方法中都执行，而不仅仅是一次。

在测试类中，我们使用一个名为 setUp() 的特殊方法来实现此目的（请注意大小写！）。该方法将在类中的每个测试执行前自动运行。明确地说，这意味着如果你有三个名为 test1() 、 test2() 和 test3() 的测试，那么 setUp() 方法会在 test1() 执行前运行，同时也在 test2() 之前和 test3() 之前运行。它为类中的 所有 测试方法提供通用的初始化步骤。

我们可以使用此 setUp() 方法中的字段，高效地设置初始条件。程序员通常将一个类中所有测试所使用的常见初始条件集合称为 测试夹具。

public class FlowerPickerTest
    extends TestCase
{
    private Lab04Island island;
    private FlowerPicker picker;

    public void setUp()
    {
        this.island = new Lab04Island();
        this.picker = new FlowerPicker();
        this.island.addObject(this.picker, 1, 2);
    }

    public void testPickFlowers()
    {
        // 1. No extra setup needed
        ...
    }

    public void testPickFlowersAgain()
    {
        // 1. set up initial conditions
        // turn picker south and move forward 1
        // for this test

        ...
    }
}

注意，这些字段的写法与原始的局部变量声明略有不同。它们前面包含了关键字 private ，因为我们的所有字段都是 private 的。你永远不能在方法内部的局部变量前使用 private ，只能用于字段，但我们 始终 在字段前使用它。

另外，在 setUp() 内部可以看到，每一行开头都没有类型。我们并未在该方法内部 声明 局部变量。每当在名称前指定类型时，你实际上是在以某种方式声明一个新名称。

4.1.8. 子类中的构造函数与 super(...)¶

我们知道，当创建一个 子类 时，它会 继承 其 扩展 的类中的所有方法和属性。如果你创建一个名为 PlantingJeroo 的 Jeroo 子类，那么任何 PlantingJeroo 对象都可以执行任何 Jeroo 所知道的所有方法——因为一个 PlantingJeroo 是 Jeroo 的一种特殊类型。 PlantingJeroo 类从 Jeroo 类继承了所有方法和属性，同时也理解你编写的新方法，例如 platRowsOfFour() 方法。计算机科学家有时将这种关系称为 is-a 关系，因为每个 PlantingJeroo 对象在同时 是 Jeroo ——只不过是一个功能更强大的Jeroo。

此外，正如我们之前所读到的， 构造函数 是一种特殊的函数，用于初始化一个全新的对象。然而，尽管子类会自动继承其父类的所有（普通）方法和属性， 却不会继承构造函数 。这意味着，在上例中对 Ali 的对象实例化实际上无法通过编译—— 除非我们为 PlantingJeroo 子类提供适当的构造函数 。

子类不会自动继承构造函数的一个原因是，子类除了新增方法外还可能添加新的属性，而这些属性必须被初始化，无论怎样都如此。但父类的任何构造函数都不了解子类新增的属性，也无法适当地对其进行初始化。因此，子类必须始终显式地定义它们所支持的每一个构造函数。

幸运的是，尽管构造函数不会被继承，但定义它们存在一种简单的模式。在我们的 PlantingJeroo 中，可以添加如下构造函数：

// ----------------------------------------------------------
/**
 * Create a new Jeroo facing east.
 * @param flowers   The number of flowers the Jeroo is holding.
 */
public PlantingJeroo(int flowers)
{
    super(flowers);
}

虽然我们尚未涵盖这段小代码中的所有特性，但其核心思想是明确的。构造函数的声明方式与普通方法类似，只是 省略了 void 一词，且其名称 与类名完全相同。此处，我们正在为我们的 PlantingJeroo 子类定义一个构造函数，该构造函数接受一个数字（整数）作为参数，表示其袋中花朵的数量。

此构造函数的主体仅包含一行，使用了特殊的 Java 关键字 super 。该关键字只能作为子类构造函数中的首个词使用，允许我们调用父类构造函数，并传递其可能需要的信息。因此，此处我们表示，在我们的 PlantingJeroo 构造函数中，第一个（也是唯一一个）操作是调用其父类（ Jeroo ）的构造函数，并传入花的数量。这使得父类能够根据给定信息正确初始化其所有属性。如果子类还需要更多初始化操作，我们将在子类构造函数体中后续的语句里完成。

但目前，这个构造函数已足够满足我们的 PlantingJeroo 类需求。它允许我们通过指定位置和花朵数量来创建一个 PlantingJeroo 对象。这将使我们能够顺利实例化前例中的 Ali Jeroo。

4.1.9. 方法的更多内容¶

方法 对应一种动作或行为，是可被调用或 调用 以执行一组预先定义好的操作的命名代码块。

方法定义由两部分组成：方法头和方法体。一般来说，方法头采用以下形式，其中包含一些可选部分：

修饰符_可选 返回类型 方法名(参数列表_可选 )

合起来，一个方法定义可能看起来像这样：

public int addHops()

上方，该方法以访问修饰符 public 开始，用于声明此方法可被其他类访问或引用。方法头的下一部分是方法的返回类型。这是方法返回的值的类型（如果有的话）。在上方的方法声明中，我们指定该方法返回一个 int 类型的值作为结果。到目前为止，我们编写的都是如下形式的方法：

public void pickFlowersAndDisableNets()

这里不是 int ，我们看到的是关键字 void ，表示该方法不返回任何内容，仅因其执行的动作而被调用，且不期望返回某种答案。我们稍后会更详细地讨论返回类型。

在方法声明中，方法名位于方法的返回类型之后。这是调用方法时所使用的名称。我们可以随意命名方法，但不能包含空格。方法名之后是方法的 参数列表，我们将在下一节中讨论。

public void turnAndDisable(RelativeDirection direction)
{
    this.turn(direction);
    this.toss();
}

turnAndDisable(RIGHT);

public void turnThenHop(RelativeDirection direction, int hops)
{
    this.turn(direction);
    this.hop(numHops);
}

turnThenHop(RIGHT, 7);

4.1.10. 条件判断的良好习惯¶

与添加注释一样，可读性在编写条件语句时也是一个重要因素。

if (!this.isClear(AHEAD))
{
    this.toss();
}
else
{
    this.hop();
}

if (this.isClear(AHEAD))
{
    this.hop();
}
else
{
    this.toss();
}

if (this.isClear(AHEAD))
{
    this.hop();
}
else if (!this.isClear(AHEAD))
{
    this.toss();
}
else
{
    this.turn(RIGHT);
}

if (this.isClear(AHEAD))
{
    // do nothing
}
else
{
    this.turn(RIGHT);
}

if (this.isClear(AHEAD))
{
    // do nothing
}
else
{
    this.turn(RIGHT);
}

if (!this.isClear(AHEAD))
{
    this.turn(RIGHT);
}

if (this.isClear(AHEAD))
{
    if (this.seesNet(RIGHT))
    {
        this.turn(RIGHT);
    }
}

if (this.isClear(AHEAD) && this.seesNet(RIGHT))
{
    this.turn(RIGHT);
}

if (molly.isFacing(NORTH))
{
    molly.hop();
}
else if (molly.isFacing(SOUTH))
{
    molly.hop(2);
}
else if (molly.isFacing(EAST))
{
    molly.hop(3);
}
else
{
    molly.hop();
    molly.toss();
}

if (molly.isFacing(WEST))
{
    molly.hop();
    molly.toss();
}
else
{
    if (molly.isFacing(NORTH))
    {
        molly.hop();
    }
    else if (molly.isFacing(SOUTH))
    {
        molly.hop(2);
    }
    else
    {
        molly.hop(3);
    }
}

4.1.11. 一种不同类型的复杂条件语句¶

另一种 if 语句可以变得更复杂的方式是创建更长的复合条件。

例如，

if ((caroline.isFacing(NORTH) && caroline.hasFlower())
    || caroline.seesNet(AHEAD))

此语句可推广至 if (A || B) ，其中：

• A = caroline.isFacing(NORTH) && caroline.hasFlower()

• B = caroline.seesNet(AHEAD)

如果 jeroo 面向北方且携带花朵，或者其前方可见渔网，则此 if 语句将被触发。值得注意的是，若 jeroo 仅携带花朵，逻辑与运算将使表达式 caroline.isFacing(NORTH) && caroline.hasFlower() 为假。因此，jeroo 必须在前方看到渔网，此 if 语句才会被触发。

逻辑非也可以否定一个复合语句。

if (!(caroline.isFacing(NORTH) && caroline.hasFlower()))

记住，要使 caroline.isFacing(NORTH) && caroline.hasFlower() 为真，jeroo 必须持有花且朝向北方。只要括号内的复合条件为假， !(caroline.isFacing(NORTH) && caroline.hasFlower()) 就为真。

在观察这类复杂操作时，很容易混淆。在考虑被否定的复合条件时，根据 德摩根定律 对其进行重写可能会对你有所帮助：

• !(A && B) 与 !A || !B 相同

• !(A || B) 与 !A && !B 相同

使用这个，而不是编写

if (!(caroline.isFacing(NORTH) && caroline.hasFlower()))

它在逻辑上等价于写作：

if (!caroline.isFacing(NORTH) || !caroline.hasFlower())

再次，如果我们使用真值表，可以看出这两列是匹配的：

4.1.12. 短路求值¶

布尔运算符的另一个重要特性是它们采用一种称为短路求值的求值方式。在 短路求值 中，布尔表达式从左到右进行求值，一旦表达式的值可以确定，无论其是否包含更多运算符和操作数，求值过程即刻终止。例如，在表达式

basil.isFacing(WEST) && basil.seesNet(AHEAD)

如果 basil.isFacing(WEST) 为假，则 AND 表达式必为假。由于计算机已知整个 AND 表达式为假，因此不会评估 basil.seesNet(AHEAD) ，因为已无必要。

同样地，在表达式中：

basil.isFacing(NORTH) || basil.seesNet(AHEAD)

如果 basil.isFacing(NORTH) 为真，则计算机知道整个OR表达式也必为真，因此无需再计算 basil.seesNet(AHEAD) ，因为该部分已无必要。

4.1.13. 编程实践 4¶