5.1.1. 变量赋值¶

现在我们已经声明了变量，接下来想要使用它们来存储值。我们通过赋值语句来实现这一点

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

此示例展示了一个变量声明，后接一条赋值语句。在 Java 中，所有局部变量都必须赋予初始值，我们使用相同的 "=" 字符来表示变量声明中存储的值。然而，在声明一个变量之后，我们可以随时 更改 其值，这通过 赋值语句 实现。此处，我们先写出变量本身，接着是一个等号（ = ），再后跟希望该变量存储的新值。赋值语句 会改变变量中存储的值，因此下次使用该变量时，其对应值将为新值。请记住，“变量”这一名称反映了其值可在程序运行过程中 随时间变化（或变动） 的特性，而赋值正是改变该值的方法。

程序员可以使用诸如“设置 ageInYears 为 21”、“赋值 21 到 ageInYears ”或“修改 ageInYears 为 21”的短语。这里的词汇可能令人困惑，但其概念却很简单：

• 当你声明一个变量时，你创建了一个命名的存储位置，并为其赋予一个初始值。

• 当您向变量赋值时，会更新其值，替换掉它之前持有的任何值。

通常情况下，变量的类型必须与所赋值的类型相同。例如，您无法将字符串存入 ageInYears ，因为它只能存储整数。我们之后会看到一些看似违反此规则的例子，但稍后会解释原因。

变量在声明时必须始终被初始化（首次赋值），你可以在同一行上写出：

int ageInYears = 29;

5.1.2. 关于等号 = 的说明¶

让我们来看一下下面这个代码示例：

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

因为 Java 使用 = 符号表示赋值，因此很容易将赋值语句 a = b 解释为等式陈述。它并非如此！

相等关系具有对称性，而赋值不具有。例如，在数学中若 a = 7 则 7 = a 。在 Java 中 a = 7; 是合法的赋值语句，但 7 = a; 不是。这是因为赋值语句 是一种动作，它通过将左侧变量的值设置为右侧 = 符号所出现的值来改变左侧的变量。因此，赋值语句的左侧必须是一个存储位置，如变量。

此外，在数学中，等式陈述在所有时间都成立。如果 a = b 现在成立，那么 a 一直等于 b。在 Java 中，赋值语句可以使两个变量相等，但它们不必一直保持相等：

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

第一行声明变量 a 并将其初始化为值 5。第二行声明变量 b 并将其初始化为 a 的值，此时该值为 5。第三行将 a 的值更改为 3，但不会更改 b 的值，因此它们不再相等。 a 现在的值为 3，而 b 的值为 5。

5.1.3. 算术运算符¶

运算符是代表简单计算的符号。例如，加法运算符是 + ，减法是 - ，乘法是 * ，除法是 / 。

下列程序将一天中的时间转换为分钟数：

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

在本程序中， hour * 60 + minutes 是一个 表达式，表示需要计算的单一值。运算符为 * 和 + ，分别代表乘法与除法。参与运算的变量称为 操作数 （这是参数的另一种说法）。当程序运行时，每个变量将被其当前值替换，随后应用运算符。

因此，尽管你输入 hour * 60 + minutes ，Java 仍会将其计算为 11 * 60 + 59 ，并将 timeAsMinutes 的值设为 719。表达式通常由数字、变量和运算符组合而成。在编译并执行时，它们会被求值以生成单一数值。还应注意的是，Java 中的运算顺序与数学中的规则一致。由于乘法的优先级高于加法，因此 11 * 60 会在 59 相加前先被计算。

虽然加法（+）、减法（-）、乘法（*）和除法（/）都是编程中可使用的数学运算符，但 Java 还支持两个你可能未曾见过的单目运算符。它们是 ++ 和 -- 。这两个运算符分别用于加一或减一，常用于在计算过程中逐步增加或减少变量中存储的值。

5.1.4. 关于整数与除法的一点说明¶

加法、减法和乘法的结果符合你的预期，但除法的结果可能会让你感到意外。例如，以下代码片段试图计算已过去的时间占一小时的分数：

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

fractionOfHour 在此情况下将实际被赋值为 0！这一结果常令人困惑。 minutes 的值是 59，而 59 除以 60 应为 0.98333，而非 0。当操作数为整数时，Java 执行“整数除法”，如本例所示。根据设计，整数除法始终向零舍入，即使在下一个整数非常接近的情况下也是如此。此外， fractionOfHour 被声明为一个 int 变量，因此它只能存储整数值，而不能存储小数部分。

作为一种替代方案，我们可以计算百分比而非分数：

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

现在， fractionOfHour 被赋值为 98。结果再次向下取整，但至少此时已大致正确。

5.1.5. 新类型：双精度¶

虽然上述示例均使用了数据类型 int ，我们也可以使用变量来存储不仅仅是整数值的内容。

创建准确的 fractionOfHour 变量的一种更通用的方法是使用一种称为 double （双精度）的数据类型，该类型不仅能表示整数，还能表示分数。double 值实际上是数学意义上的 实数 的数字近似表示。您可以使用与其它类型相同的语法创建 double 变量并为其赋值：

double pi = 3.14159;

当一个或多个操作数为 double 值时，Java 执行“浮点除法”。因此我们可以解决上一节中遇到的问题：

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

现在， fractionOfHour 被设置为值 0.9833333333333333。

尽管浮点数很有用，但它们可能带来混淆。例如，Java 将整数值 1 与浮点数值 1.0 区分开来，尽管它们看起来是同一个数字。它们属于不同的数据类型，严格来说，不允许在不同类型之间进行赋值。

以下语句非法，因为被声明的变量是 int 类型，而右侧的初始值是 double 类型：

int x = 1.1; // compiler error

很容易忘记这条规则，因为在许多情况下 Java 会自动将一种类型转换为另一种类型：

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

上述示例应属非法，但 Java 允许通过自动将 int 值 1 转换为 double 值 1.0 来处理。这种宽松性虽方便，却常给初学者带来困扰。例如：

double y = 1 / 3; // common mistake

你可能会期望变量 y 获得值 0.333333，这确实是 double 类型的一个合法值。但实际它获得的值是 0.0。右侧的表达式进行的是两个整数的除法，因此 Java 执行整数除法，结果为 int 值 0。该 int 值随后被隐式转换为 double ，以便用作 y 的初始值，因此赋给 y 的值为 0.0。

5.1.6. 使用布尔值作为变量¶

在前两个模块学习条件语句时，你可能记得频繁提到布尔值。与 int 和 double 一样， boolean 是 Java 提供的另一种数据类型。与 int 或 double 不同， boolean 值只能是 true 或 false 。

我们使用这些结构来处理 while 循环或 if 语句，例如：

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

• 如果该 jeroo 拥有花朵，则它将跳跃。 hasFlower() 是一个方法，其返回值为 true 或 false ，具体取决于该 jeroo 是否拥有花朵。

我们可以将该布尔值存储在变量中，如下所示：

boolean pocketIsFull = this.hasFlower();

这里我们声明了一个布尔型变量，命名为 pocketIsFull ，并将其赋值为 hasFlower() 方法返回的结果。

如果我们愿意，就可以在条件语句中使用该变量：

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

这是写出相同 if 语句的另一种方式！

此外，我们可以将 boolean 变量赋值给复合条件表达式的计算结果：

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

之前我们声明并初始化了一个由数学表达式计算得到的 int 变量。这里的情况相同，Java 将会计算 this.hasFlower() && this.seesNet(AHEAD) ，该复合表达式将产生一个值，该值要么是 true ，要么是 false ，然后这个值将作为变量 shouldToss 的初始值使用。

最后，如果你只需要一个 boolean 值，可以使用关键字 true 或 false 来初始化一个 boolean 变量。

boolean x = true;
boolean y = false;

5.1.7. 局部变量的作用域¶

局部变量可以是非常有用的工具。你应该在 需要多次引用同一值时 使用局部变量，因为局部变量允许你为一个值命名，从而可以在多个位置使用该名称。如果你只需要一次使用某个值，命名可能并没有太大意义。

然而，局部变量用于表示仅在单个方法内（或甚至仅在方法内的少数几条语句中）使用的本地名称。编程语言使用术语 作用域 来指代名称可被使用的程序文本区域。对于局部变量而言，每个变量声明都出现在某对大括号（ { } ）之内，例如包围方法主体的那对大括号。这对大括号构成了程序语句块的起始与结束。该局部变量的作用域是其声明位置与包含该声明的语句块末尾的大括号（ } ）之间的所有语句。该名称在该块外部将不会被识别。最重要的是，这意味着该变量声明在其他方法中不可见（无法使用）。

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
   {
       ...
   }
}

上述代码中，局部变量 x 在方法 doSomeStuff() 的开始处声明，因此该变量可在该方法内的任何位置使用。然而， x 的作用域在 doSomeStuff() 结束时终止，即方法末尾的右大括号所标记的位置。

这就是为什么 局部变量 被称为 局部 的原因：它们只能在程序文本的一个小范围、局部区域内使用，仅限于下一个右大括号之前。作为进一步的例子：

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
}

局部变量可以在任意一对用于标记一系列语句的花括号内声明。然而，它们始终仅对该语句块 局部有效，不能在该语句块外部使用。此处， x 在第一个 if 语句的 true 分支内声明，因此 x 局限于该语句块内，无法在声明它的花括号对之外使用。

变量在作用域之外不可见，也无法使用。其作用域是指变量可见的文本区域。在 Java 中，作用域通常由一对花括号（ { } ）标记。

5.3.1. 作用域说明¶

变更方法的主体同时使用了字段和参数。需要注意的是，这两种变量的使用位置存在差异。请记住，名称或方法的 作用域 指的是它在程序中可以被使用的范围。

参数的作用域是其被声明的方法体。

例如考虑下面的 setLength() 方法：

public class Rectangle
{
    private int length;

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

在此代码中，参数名 len 无法在 setLength() 方法之外被引用。它在包围方法体的花括号（{ }）之外完全不可见。

字段则在包围整个类的花括号（ { } ）内声明，因此其作用域为整个类——可以在类内的任何位置、任意方法中使用。例如，字段 length 是在 setLength() 方法之外声明的，可在类内的任何位置访问。

记住，声明在方法体内部的局部变量的作用域从其声明位置延伸到其声明所在代码块的末尾。

总而言之：

• 字段在类内部声明，因此其作用域为整个类。可以在类中的任何方法内引用它们。

• 参数在方法声明的参数列表中声明，因此其作用域为该整个方法。可以在该方法体内的任何位置引用它们，但无法在声明它们的方法外部访问。

• 局部变量在由大括号包围的语句块（ { } ）中声明。可以从声明位置开始，到标记该代码块结束的大括号（ } ）为止，访问该块内的任何位置。

5.6.1. 回溯至访问方法¶

为字段编写访问方法必须具有返回类型，因为所有字段都有类型。

public class Rectangle
{
    private int length;

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

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

在此情况下，我们的 length 字段类型为 int ，因此该字段的访问方法也需返回一个 int 。

5.6.2. 编写带返回值的更复杂方法¶

有时你可能会觉得有必要编写多个 return 语句，例如在条件语句的每个分支中各写一个：

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

由于这些 return 语句位于条件语句中，因此只会执行其中一个。一旦其中任意一个被执行，方法立即终止，后续的任何语句都不会再执行。当然，这意味着在到达 return 语句之后，方法的其他部分将不会被执行。此外，由于返回值的方法必须 始终 使用 return 语句，无论方法以何种方式结束，因此你必须在每个分支中都包含 return 语句，而不仅仅是在第一个分支中。

由于这些限制，一些初学者发现始终编写一个返回语句并将其放在方法的最后一条语句会更容易——这能确保方法总是返回一个值，并且不会意外跳过任何重要步骤。随着技能的发展，你可能会在某些情况下发现使用多个返回语句更方便，但请始终记住它们需要更多的注意，且更容易出错，因此当你遇到困难时，应退回到使用单一返回语句的方式：

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

以下是一个示例： calculateArea 接受一个 double 类型的参数，并返回以该半径对应的圆的面积：

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

这最后一行是一个返回语句。该语句表示：“立即从本方法中退出，并使用后面的表达式作为返回值。” 另外，请注意使用了来自内置 Java 工具类 Math 的常量 PI 。Java Math 类提供了许多有用且常见的数学函数，以及常量 PI 和 E 的定义。在 Java 中，按照惯例，程序员将常量名称全部用大写字母书写，以便与变量或字段区分开来。

您提供的条目中包含未解析的占位符 return ，根据规则需保留原样放置的特殊符号占位符，不得增删。修正后重译如下：

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

出现在 return 语句之后（在同一块内）或任何永远无法执行的位置的代码称为 死代码。如果代码的一部分是死代码，编译器会给出“不可达语句”的错误提示。例如，此方法包含死代码：

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

那最后一行， x = 5 永远不会被执行，因为方法在到达该行之前总会返回一个值（结束方法执行）。

如果你将 return 语句放在条件语句内部，就必须确保程序的每条可能执行路径都最终会到达一个 return 语句。如果情况并非如此，编译器会提示你。例如，以下方法是不完整的：

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

当 x 为 0 时，两个条件都不成立，因此该方法在未遇到 return 语句的情况下结束。此情况下的错误信息可能类似于“缺少 return 语句”，这令人困惑，因为已经存在两条 return 语句了。但希望你能理解其含义。

同样地，如果你遇到困难，通常一个简单的解决方法是调整方法的结构，使得方法末尾仅有一个 return 语句。

5.6.3. 使用方法的结果¶

调用一个无返回值的方法时，调用语句通常单独占一行。例如，以下是 Jeroo 的一个简单跳跃并拾取方法。

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

这就是它的调用方式：

this.hopAndPick();

另一方面，当你调用一个具有返回类型的函数时，必须对返回值进行处理。我们通常将其赋值给变量，或作为表达式的一部分使用。

以这个方法为例：

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

此方法接收某个数 x ，并返回该数的平方值。

我们可以随后调用该方法并实例化一个新变量以保存结果：

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

在此情况下， raised 被设置为值 9（即计算 3 * 3 的结果）。

此外，我们还可以将一个方法的结果作为另一个方法调用的参数：

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

这个新变量 raisedAgain 将被设为 81。对 square() 的调用按“由内而外”顺序求值，括号内的调用最先执行。因此，在第一次调用中， base 被作为参数传递给 square() ，返回值为 9。第一次调用的返回值 9 被用作第二次调用 square() 的参数值，该调用随后返回 9 * 9 = 81。

这可能会让你想起在代数课程中处理函数的情形。在那些课程中，我们可能会看到同样的概念被这样写出：

假设 f(x) = x * x，f(3) 的值是多少？f(f(3)) 的值是多少？

Java 使用了同样的原理，尽管涉及多种不同类型的数据，事情可能会变得稍微复杂一些。