3.1.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;

3.1.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。

3.1.1.3. 算术运算符¶

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

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

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

在此程序中， hour * 60 + minutes 是一个 表达式，表示要计算的单个值。运算符是 * 和 + ，分别表示乘法和除法。参与运算的对象称为 操作数 （这是对参数的花哨称呼）。当程序运行时，每个变量都会被其当前值替换，然后应用运算符。

因此，即使你编写了 hour * 60 + minutes ，Java 也会将其计算为 11 * 60 + 59 ，并将值 719 赋给 timeAsMinutes 。表达式通常是数字、变量和运算符的组合。在编译和执行时，它们会被求值以产生单个值。同样重要的是要注意，运算顺序在 Java 中与在数学中一样适用。由于乘法的优先级高于加法， 11 * 60 会在 59 相加之前先被计算。

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

3.1.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。结果再次向下取整，但至少现在是近似正确的。

3.1.1.5. 一种新类型：Double¶

虽然上述示例都使用了数据类型 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。

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

在处理前两个模块中的条件时，你可能记得经常听到关于布尔值的内容。就像 int 和 double 一样， boolean 是 Java 提供的另一种数据类型。与 int 或 double 不同， boolean 值只能是 true 或 false。

我们在使用 while 循环或 if 语句时会用到这些，例如：

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

在此代码中，如果 Jeroo 有花，它将跳跃。 hasFlower() 是一个方法，将根据 Jeroo 是否有花返回 true 或 false 。

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

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;

3.1.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 语句的真分支内声明，因此 x 局部于该语句块，不能在声明它的那对花括号之外使用。

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

3.1.4.1. 关于作用域的说明¶

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

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

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

public class Rectangle
{
    private int length;

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

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

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

请记住，在方法主体内声明的局部变量，其作用域从声明点开始，延伸至其所在代码块的末尾。

总之：

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

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

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

3.1.9.1. 返回访问器方法¶

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

public class Rectangle
{
    private int length;

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

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

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

3.1.9.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 语句。

3.1.9.3. 使用方法的结果¶

当你调用一个 void 方法时，该调用通常单独占一行。例如，这里是一个用于 Jeroos 的简单 hop 和 pick 方法。

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 也使用这一原则，但由于存在许多不同的数据类型，情况可能会变得稍微复杂一些。