如何在 Java 中使用运算符

2023-11-09

作者选择了免费开源基金接受捐赠作为为捐款而写程序。

介绍

An operator是一个或多个符号的组合，比如著名的算术运算符减号(-) 并加上 (+）或更高级的instanceof。当您对值或变量应用运算符时，您会得到运算结果。此类操作是编程的基础，因为它们的结果被分配给变量或进一步评估，直到实现程序的最终目标。

对于本教程，您必须熟悉operand，这是应用运算符的值或变量。根据操作数的数量，运算符可以分为三组。一、当运算中只有一个操作数时，调用运算符unary。相似地，二元运算符涉及两个操作数。最后，当有三个操作数时，运算符为ternary。按照这种分类，本教程针对每种类型的运算符分为三个主要部分。

在本教程中，您将使用所有三种类型的运算符来操作原始数据类型，例如数学方程。您还将在更高级的场景中使用运算符参考类型并探索一些运算符优先级的规则。

先决条件

要学习本教程，您将需要：

您可以在其中执行 Java 程序以跟随示例的环境。要在本地计算机上进行设置，您将需要以下内容：
- 您的计算机上安装了 Java（版本 11 或更高版本），并使用 Java 开发工具包 (JDK) 提供的编译器。对于 Ubuntu 和 Debian，请按照以下步骤操作Option 1在我们的教程中，如何在 Ubuntu 22.04 上使用 apt 安装 Java。对于其他操作系统，包括 Mac 和 Windows，请参阅Java 安装的下载选项.
- 为了编译和运行代码示例，本教程使用Java外壳，这是一个读取-评估-打印循环 (REPL)从命令行运行。要开始使用 JShell，请查看JShell简介 guide.
熟悉 Java 和面向对象编程，您可以在我们的教程中找到这些知识，如何用 Java 编写您的第一个程序.
了解我们的教程中讨论的 Java 数据类型，了解 Java 中的数据类型.

一元运算符

一元运算符应用于一个操作数，这使得它们最简单。一元运算符经常被使用，因为它们使您的代码更加简洁和可读。它们取代了显式描述操作（例如增加和减少值）的需要。然而，当与其他运算符结合使用时，一元运算符也可能难以使用，您将在本节后面发现。

接下来，您将使用一元运算符来增加和减少值以及翻转布尔值。

自增和自减运算符

增量 and 递减顾名思义，运算符可以增加和减少数字。增量运算符是两个加号的组合 (++) 减运算符是两个减号 (--）。这些运算符在操作数之前和之后使用。

预增和预减

当您在操作数之前使用运算符时，您是预递增 or 预减取决于你是否使用++ or --。当您使用pre运算符，您可以在使用操作数之前更改其值。因此，当您实际使用该值时，它已经发生了变化。

Info:要按照本教程中的示例代码进行操作，请通过运行以下命令在本地系统上打开 Java Shell 工具jshell命令。然后，您可以复制、粘贴或编辑示例，方法是将它们添加到jshell>提示并击中ENTER。退出jshell, type /exit.

要使用预自增运算符，请在其中键入以下内容jshell:


答案= 42;

System.out.println("Preincrementing: " + ++theAnswer);

在第一行，定义一个变量theAnswer与价值42。在第二行，您使用println()打印它的方法，从而展示它是如何改变的。

上例中的预自增运算符是++，并且它被放置在之前theAnswer。通过以这种方式使用预递增运算符，您首先递增theAnswer to 43。之后，当println()处理它，它已经是43，因此您会看到打印的内容：

OutputtheAnswer ==> 42
Preincrementing: 43

预减的工作原理类似，但不是递增，而是递减操作数的值。作为练习，修改上面的示例，以便代替预自增运算符++，您使用预减--.

后递增和后递减

相比之下pre运营商，post运算符在使用操作数后更改其值。有一些具体的案例，post or pre运算符很常用，但总体来说，这是个人喜好的问题。

演示如何post运算符工作时，您将增加以下值theAnswer并检查其值如何变化。将以下行添加到jshell:


答案= 42;

System.out.println("Postincrementing: " + theAnswer++);

系统输出打印文件(“最终值：”+ 答案);

变量theAnswer第一个等于42。然后，它被打印并后递增。在最后一行，您再次打印它以查看其最终值。

你的输出应该是：

OutputtheAnswer ==> 42
Postincrementing: 42
Final value: 43

如你看到的，theAnswer遗迹42在后增量期间。当你在后递增之后再次打印它时，它是43 (Final value: 43).

后递减的工作方式相同。该值首先被检索和使用，只有在此之后，它才会递减。作为练习，尝试替换后增量运算符++与后减运算符--，甚至包括其中之一pre运营商。

NOT 运算符

The NOT运算符，也称为逻辑补运算符，翻转布尔操作数的值。它用感叹号表示!。通常，您使用NOT当您有一个布尔变量或值，并且您希望将其与相反的值一起重用时，请使用运算符。因此，您不必不必要地创建另一个具有相反值的变量。

下面是一个示例，说明如何NOT操作员工作。为简单起见，您将翻转以下值true:


boolean isJavaFun = !true;

系统输出打印文件(是JavaFun);

您定义布尔变量isJavaFun as true。但是，那NOT运算符先于true;因此，值true被翻转到false。当您运行上述代码时，将打印以下输出：

OutputisJavaFun ==> false
false

这就是如何NOT操作员工作。有时它可能会令人困惑并且很难发现它，因此您应该谨慎使用它。

在上述情况下，而不是!true，你可以使用false。这是正确的方法，因为它更干净、更直观。作为一般规则，最佳实践是直接使用文字或方法，而不是需要额外操作的替代方案。然而，在某些情况下，它可能并不总是有意义甚至不可能。例如，通常使用NOT运算符翻转布尔方法的结果。

例如，要检查一个字符串是否包含另一个字符串，可以使用以下方法contains()。但是，如果您想检查相反的情况（即，当一个字符串不包含另一个字符串时），则没有替代的内置方法。你需要使用contains()与NOT操作员。

想象一下你有字符串Java is smart.并且您想检查是否：

该字符串包含smart.
该字符串不包含hard.

要检查这些，您将使用以下代码：


字符串 javaIsSmart= “Java 很聪明。”;

boolean isSmartPartOfJava=javaIsSmart.contains("smart");

boolean isHardNotPartOfJava = !javaIsSmart.contains("hard");

在第一行，您定义一个String多变的javaIsSmart。在第二行，定义一个布尔变量isSmartPartOfJava作为该方法的操作结果contains()— 在这种情况下，字符串是否smart是的一部分javaIsSmart细绳。同样，在第三行，定义一个布尔变量isHardNotPartOfJava，这取决于是否hard is not在发现javaIsSmart.

当您运行此代码时jshell，您将得到以下输出：

OutputjavaIsSmart ==> "Java is smart."
isSmartPartOfJava ==> true
isHardNotPartOfJava ==> true

根据上面的输出：

isSmartPartOfJava is true因为smart发现于javaIsSmart.
isHardNotPartOfJava也是true因为hard未找到于javaIsSmart.

在本节中，您探索了使用一个操作数的递增、递减和 NOT 运算符。尽管这些运算符只有一个操作数，但使用它们可能具有挑战性，如NOT操作员。在下一步中，您将通过使用具有两个操作数的运算符来巩固这些知识。

二元运算符

二元运算符作用于两个操作数，通常与加法和减法等算术运算相关。还有其他非数学相关的二元运算符，例如逻辑运算符和特殊关系运算符instanceof。在本节中，您将从算术二元运算符开始，这可能是您更熟悉的。

算术二元运算符

这些是用于算术运算的众所周知的运算符，例如加法 (+）和减法（-）。这是一个添加的例子：


int theAnswer = 40 + 2;

系统输出打印文件(“结果是：”+ 答案);

在第一行，您添加40 to 2并将结果分配给theAnswer多变的。当你打印它时，你会得到最终的值42:

OutputThe result is: 42

**注意：**除了算术运算之外，加号 (+) 也用于连接字符串。您已经在我们的大多数带有打印值的示例中看到了它的实际效果，例如上面的示例。在那里，使用加号，您已经连接了"The result is: "与变量theAnswer。但是，加号的这种使用是一个例外，并且不能在引用类型上类似地使用其他算术运算符。因此，例如，您不能使用减号来删除字符串的一部分。

如需额外练习，请尝试使用其他算术运算符，您可以在Java 文档.

赋值运算符

赋值运算符将左操作数赋给右操作数的值。通常，左操作数是变量，右操作数是值或对象的引用。这听起来可能很熟悉，因为您在所有示例中都使用了此类分配。在本节中，您将练习使用基本赋值运算符、一些复合赋值运算符和强制转换运算符。

基本赋值运算符 (=) 是众所周知且常用的运算符。

int x = 1;

在此示例中，您声明一个int多变的x并为其赋值1。使用等号 (=) 是为变量赋值的方式。

复合赋值运算符

复合赋值运算符 (+=, -=, *=, \=）将赋值与附加算术运算（例如加法或减法）结合起来。这些运算符使您可以避免样板代码，尤其是在易于遵循和理解的算术运算中。

例如，使用化合物+=赋值运算符将加法和赋值结合起来，如下所示：


int x = 1;

int y = 1;

x += y;

系统输出打印文件("x is: " + x);

在前两行中，您声明了两个名为x and y，两者的值为1。接下来，您重新分配x使用该化合物+=赋值，这意味着x被添加到y然后被分配回x.

上面的代码将返回与此类似的输出：

Outputx ==> 1
y ==> 1
$11 ==> 2
x is: 2

根据上面的输出，x and y得到一个值为1。第三行有一个临时变量，其名称是随机分配的（$11）。它持有的价值x作为复合赋值操作的结果。最后一行的值是x打印：2.

可以在不使用复合赋值运算符的情况下重写相同的代码，如下所示：


int x = 1;

int y = 1;


x = x + y;

系统输出打印文件("x is: " + x);

与前面的示例相反，您可以编写额外的代码来显式描述添加x plus y在第 3 行。

运行此代码将返回以下输出：

Outputx ==> 1
y ==> 1
x ==> 2
x is: 2

最终，在这两个例子中，x equals 2。然而，在第二个例子中，jshell没有打印临时变量名称，例如$11。相反，它使用了x直接表明它的值已经改变（x ==> 2）。这种详细的输出对于学习非常有帮助，并且只能在jshell.

其余复合运算符结合减法 (-=), 乘法 (*=）和除法（/=）以及作业。尝试更改上面的示例，看看它们是如何工作的。

了解复合运算符很有好处，因为它们经常使用。然而，使用它们并没有性能优势，因此使用复合运算符是个人选择的问题。如果它们看起来不必要地令人困惑，那么您不必使用它们。

铸造操作员

您要查看的最后一个赋值运算符是强制转换运算符，它是一种用括号括起来的数据类型：(data type)。转换运算符用于转换值，即将一种数据类型解释为另一种数据类型。

但数据类型必须兼容。一种数据类型是否与另一种数据类型兼容取决于它们之间的关系，例如一个类是否是另一个类的父类或同级。例如，您可以投射int to short因为这两种数据类型都用于存储整数。但是，您不能施放int to boolean因为这两种数据类型不兼容。

在本节中，您将探讨一些常见的铸造示例和问题。出于教育目的，您将从不正确且不兼容的转换开始：

boolean y = (boolean) 1;

通过这一行，您试图转换整数1为布尔值并将其分配给变量y。当你粘贴这个jshell，你会得到以下错误：

Output|  Error:
|  incompatible types: int cannot be converted to boolean
|  boolean y = (boolean) 1;
|

正如错误消息所解释的，您无法转换int值对一个boolean。布尔值是true or false，并且无法确定哪个布尔值1应该。

现在，您将尝试使用兼容数据类型的示例。您将使用两种基本类型来存储整数：int and short。区别在于它们的容量，即可用于存储信息的内存量。int具有更大的容量，因此可以存储更大的数字。

将以下行添加到jshell:


国际奖= 32767;

short wonPrize = (short) prize;

系统输出打印文件(“你赢了： ”+ 获奖);

在第一行中，您将彩票奖金定义为int原始类型的值为32767。然而，在第二行，您决定short原始类型会更适合该值wonprize，然后你投射prize to short using (short).

当你运行上面的代码时jshell，输出为：

Outputprize ==> 32767
wonPrize ==> 32767
You won: 32767

上面的输出证实了prize and wonPrize值已正确设置为32767。最后一行使用wonPrize变量来说明您赢了多少钱。

如果是int and short，铸造可能看起来没有必要，并且您可能不会在现实中看到这样的铸造。然而，这个例子对于演示强制转换的想法很有用。

选角看似简单，但有一个警告。当您从容量较大的数据类型转换为容量较小的数据类型时，可能会超出较小的容量限制，这称为overflow。为了演示这个问题，重用前面的例子并增加奖励32767 to 32768，像这样：


国际奖= 32768;

短期获奖=  (short) prize;

系统输出打印文件(“你赢了： ”+ 获奖);

当你运行上面的命令时jshell，您将得到以下输出：

Outputprize ==> 32768
wonPrize ==> -32768
You won: -32768

在这种情况下，您会丢失信息并得到意想不到的结果。当投射到short，的价值32768变成-32768。这是因为short的存储容量范围为 -32768 to 32767。当您尝试存储大于最大值的值时，它会溢出并从头开始。在这种情况下，您超出了最大容量（32767) by 1当你尝试存储时32768。因此，将从尽可能低的值开始分配下一个值。在这种情况下，这是最小值-32768.

这就是为什么上面的输出看起来出乎意料——最终的奖品变成了负数。此类问题并不总是容易发现，因此您应该谨慎使用铸造。您可以在更复杂的场景中使用转换，这将在 Java 系列的未来教程中解决。

关系运算符

关系运算符比较两个操作数并返回布尔结果。如果关系成立，则结果为true。如果不是，结果是false.

第一种关系运算符是等于==且不等于!=。它们用于断言值和对象的平等。对于原始值和文字，它们的使用类似于数学。

要演示 equals 相等运算符，请比较两个整数文字。事实上，它将是同一个数字：1。你将比较它是否等于它自己，这样你就可以得到true结果。将以下代码粘贴到jshell:

System.out.println(1==1);

在上面的代码中，您断言是否1 equals 1。由于数字相等，因此该表达式的计算结果为 true。因此，println() prints true:

Outputtrue

作为练习，尝试更改其中一个值以获得错误结果。

Note:确保区分运算符以确保相等==和赋值运算符=。即使您知道它们是不同的，也很容易将它们混淆。您的代码中可能并不总是出现语法错误，这可能会导致难以调试的问题。

与比较原始值相比，比较对象是否相等更为复杂，因为您要断言两个变量是否指向同一个对象。尝试比较两个Integers举个例子：


整数我的答案=整数valueOf(42);

将你的答案取整数=整数valueOf(42);

System.out.println(myAnswer == yourAnswer);

在上面的代码中，您创建了两个Integer变量，每个变量的值为42。在最后一行，比较它们是否相等并打印true如果它们相等。来自我们之前的教程了解 Java 中的数据类型，你可能知道Integer.valueOf()首先检查缓存中是否有具有相同值的对象，如果已经存在具有该值的对象，则返回相同的对象。双方都是这样myAnswer and yourAnswer接收同一个对象。

当您将上面的代码粘贴到jshell，您将得到以下输出：

OutputmyAnswer ==> 42
yourAnswer ==> 42
true

这种对象比较看起来很简单，但有时却很有挑战性。最令人困惑的例子是字符串。尝试比较具有相同值的两个字符串：


字符串答案1=新字符串("yes");

字符串答案2=新字符串("yes");

System.out.println(answer1 == answer2);

首先，你声明两个新的String变量（answer1 and answer2）与值"yes"。但是，您使用了new关键字来创建新的String对象。因此，这两个变量并不指向同一个对象——它们实际上指向两个不同的对象（具有相同的值）。

当您将上面的代码粘贴到jshell，您将得到以下输出：

Outputanswer1 ==> "yes"
answer2 ==> "yes"
false

虽然answer1 and answer2具有相同的值（"yes"），他们的平等被评估为false，这意味着它们不相等。如果您打算比较值（例如两个答案是否都是肯定的）并且您对底层对象不感兴趣，则可能会感到困惑。为此，许多课程，包括String，有专门的方法来断言平等。

对于 String 来说，这个方法是equals()。尝试更改要使用的代码equals()（代替==）像这样：


字符串答案1=新字符串("yes");

字符串答案2=新字符串("yes");

System.out.println(answer1.equals(answer2));

The equals()方法验证比较对象中包含的字符串是否相等。

当您将此代码粘贴到jshell，您将得到以下输出：

Outputanswer1 ==> "yes"
answer2 ==> "yes"
true

上面的输出与前面的输出类似，但它以true，确认两个对象的值相等。此示例表明您在比较引用类型时必须小心，并在可用时使用相应的方法。

另一种相等运算符，不等于!=, 的用法类似，但它断言两个变量或值是否不相同（或不相等）。作为练习，尝试替换== with !=在前面的一些例子中。

如同== and !=，接下来的四个关系运算符也来自数学：小于<, 小于或等于<=，比...更棒>，并且大于或等于=>.

这是使用大于运算符的示例：

System.out.println(4 > 5);

当您运行此代码时jshell，您将得到以下输出：

Outputfalse

上面的代码首先比较是否4大于5。因为不是，所以表达式的计算结果为false。比较结果（false）然后由println() method.

最后一个关系运算符是instanceof，它评估变量是否是给定类（或子类）的实例或接口的实现。正如我们所解释的了解 Java 中的数据类型在教程中，接口是具有一组需求的抽象实体。

使用以下示例来探索如何instanceof works:


字符串问候语= "hello";

System.out.println(greeting instanceof String);

首先，您创建一个String变量称为greeting。然后，您在括号中评估是否greeting是一个实例String.

当您将代码粘贴到jshell，您将得到以下输出：

Outputgreeting ==> "hello"
true

Since greeting是一个实例String，表达式的计算结果为true，它打印在屏幕上println().

逻辑运算符

逻辑运算符是逻辑运算符AND (&），逻辑OR (|），并且独家OR (^）。他们都评估两个值如下：

Logical AND当两个值都为 true 时为 truetrue.
Logical OR当至少有一个值是时为 truetrue.
独家的OR如果一个值为 true，则为 truetrue另一个是false.

当逻辑运算符根据上述条件不为真时，它们为假。

要使用逻辑 AND (&) 运算符，将以下示例粘贴到jshell:


布尔值 isJavaFun= true;

boolean isJava强大= true;

System.out.println(isJavaFun & isJavaPowerful);

前两行定义boolean变量isJavaFun and isJavaPowerful两者都true。在第三行的括号中，您执行逻辑AND操作于isJavaFun and isJavaPowerful结果打印为println().

当您将此代码粘贴到jshell，您将得到以下输出：

OutputisJavaFun ==> true
isJavaPowerful ==> true
true

两个变量都设置为true，以及最终的true打印为逻辑结果AND手术。

要扩展您的技能，请尝试使用前面的代码示例并进行一些变体。您可以尝试在之间切换变量的值true and false。您还可以尝试将逻辑运算符更改为逻辑 OR (|) 和异或 (^).

逻辑运算符的扩展版本是所谓的短路逻辑运算符：短路AND (&&）和短路OR (||）。它们类似于常规逻辑AND and OR运算符，但它们有一个重要的区别：如果计算第一个运算符足以完成操作，则不会计算第二个运算符。因此，为了短路AND确实如此，围绕它的双方都必须是true。但是，如果左侧是false，右侧不进行评估。同样，对于短路OR，如果左边是false，右侧不进行评估。

这是一个短路示例OR:


布尔值 isJavaFun= true;

布尔值是NullFun= null;

System.out.println(isJavaFun || isNullFun);

首先，您分配变量isJavaFun to true。为了与前面的示例保持一致，该变量是原始类型boolean。然而，对于下一个变量，isNullFun，你使用Boolean引用类型，以便您可以将其分配给null。例如，重要的是您有一个null指向变量，但正如您可能还记得上的教程了解 Java 数据类型，基元类型不能为 null，这就是您使用引用类型的原因。

当短路时OR发生在括号内，isNullFun被忽略，因为左侧是true，这足以使整个表达式为true。因此，当您运行代码时jshell，将打印以下输出：

OutputisJavaFun ==> true
isNullFun ==> null
true

第一行和第二行确认变量已分配给true and null。第三行打印true因为短路OR操作已恢复true.

上面的例子是专门选择的null为了演示短路运算符如何工作以及isNullFun不会被评估。查看isNullFun评估后，尝试改变短路OR与定期的OR像这样：


布尔值 isJavaFun= true;

布尔值是NullFun= null;

System.out.println(isJavaFun | isNullFun);

常规逻辑OR对表达式的两边进行求值。

当您运行此代码时jshell，您将得到以下输出：

isJavaFun ==> true
isNullFun ==> null
|  Exception java.lang.NullPointerException
|        at (#3:1)

当逻辑OR试图评估null，你得到java.lang.NullPointerException。因此，短路运算符是首选，并且几乎总是用来代替常规逻辑运算符。

作为练习，练习使用短路&& and ||，这是最流行和最有用的。

在本节中，您在一系列示例中使用了二元运算符，从基本算术到涉及强制转换和比较对象是否相等的更具挑战性的操作。在下一节中，您将使用三个操作数。

三元运算符

在前面的部分中，您练习了使用具有一个和两个操作数的运算符。在最后一部分中，您将使用三元运算符，它是三个操作数的唯一运算符。它的语法是这样的：first operand ? second operand : third operand。第一个操作数必须是布尔值。如果是true，然后从表达式返回第二个操作数。如果第一个操作数是false，然后返回第三个操作数。

三元运算符很流行并且经常使用，因为它可以使您免于编写复杂的语句（例如条件语句）并将其结果存储在临时变量中。

通过以下示例尝试使用三元运算符：


布尔值 isJavaFun= true;

String shouldILearnJava = isJavaFun ? "yes" : "no";

系统输出打印文件(“我应该学习Java吗：”+ 应该学习Java);

isJavaFun被设定为true，以及变量shouldILearnJava由它在三元运算中确定。因为第一个操作数，isJavaFun，为true，返回第二个操作数，即字符串"yes"。为了验证这一点，第三行打印变量shouldILearnJava，这应该是yes在此刻。

当您运行上面的代码时，您将得到以下输出：

OutputShould I learn Java: yes

如需额外练习，请尝试使用NOT前面的运算符isJavaFun:


布尔值 isJavaFun= true;

String shouldILearnJava = !isJavaFun ? "yes" : "no";

系统输出打印文件(“我应该学java吗：”+ 应该学习Java);

通过翻转的值isJavaFun，你将其设置为true to false。结果，三元表达式将返回最后一个操作数，即"no".

三元表达式可能会令人困惑，尤其是当您使用其他运算符（例如NOT操作员。然而，它们可以为您节省一些样板代码，这就是它们受欢迎的原因。

运算符优先级

一旦了解了重要的运算符，您就能够使用甚至组合它们。但在开始组合它们之前，您需要了解运算符优先级的规则。

运算符优先级决定了运算符的计算顺序。由于您可能会使用多个运算符，因此了解运算符优先级非常重要。虽然规则并不总是直观的，但在实践中您可能只需要了解一些基本规则。

了解运算符优先级有助于您编写干净的代码，这是现代编程事实上的标准。编写干净的代码意味着编写可理解和可维护的代码。关于运算符，干净的代码范例转化为使用尽可能少的运算符并创建单独的语句，而不是嵌套和组合运算符。

例如，应避免使用以下语句，因为它们太令人困惑：

布尔值 isThisCleanCode= !true || false && true;

即使你咨询操作员文档，你可能无法猜到最终结果（isThisCleanCode is false).

以下是一些最重要和最常用的优先级规则，从优先级最高的规则开始：

Pre and post自增和自减运算符：它们具有最高优先级，并且在任何其他运算符之前生效。
数学中的算术规则：所有在数学中有效的规则在 Java 中也有效。例如，除法/优先级高于加法+。括号覆盖优先级；也就是说，您可以使用括号对运算进行分组，并且它们将被优先计算。
相等和关系运算符：由于它们评估相等或关系，因此它们还处理其操作数的最终值，因此必须完成所有其他操作。
Logical OR and AND操作员（包括短路）：与三元运算符类似，它们都需要操作数的最终值，因此优先级较低。
三元运算符：三元运算符需要第一个操作数的最终值。为此，必须完成所有其他操作。这就是三元运算符优先级如此低的原因。
赋值运算符：它们最后被评估，以便所有其他操作都已完成，并且最终结果可以分配给左侧的操作数。举个例子，想想到目前为止您用等号分配的每个变量。

现在，您将使用数学问题来探索运算符优先级：

int x = 1 + 10 / 2;

当您将上面的代码粘贴到jshell，您将得到以下输出：

Outputx ==> 6

根据上面的输出，x得到的值6。这是因为以下操作已完成，优先级递减：

10 / 2首先被评估。结果是5.
1添加到第一个操作的结果中（5）。这导致6.
赋值运算符发挥作用并使用最终结果（6) 将其分配给变量x.

尽管这个数学方程相对简单，但您始终可以使其更加详细，并确保通过使用括号可以轻松理解优先级。考虑像这样重写：

int x = 1 + (10 / 2);

当您将以上内容粘贴到jshell，将打印与之前相同的结果：

Outputx ==> 6

在上一个示例中，您没有通过使用括号来更改优先级10 / 2。相反，它们的目的只是为了让它们内部的操作的优先级更加明显。使用这样的括号可以帮助您使代码更加简洁和易于理解，这在操作更加复杂时尤其重要。

优先规则很有趣，花一些时间学习它们是个好主意。请记住干净的代码范例，并考虑这样一个事实：不必要的运算符嵌套和组合被视为代码中的弱点。

结论

在本教程中，您了解了 Java 中的主要运算符。您编写了一些测试代码片段，在其中您看到了一些与运算符相关的最有用和最有趣的场景。您还了解了干净的代码以及不应过度使用运算符的事实。

有关 Java 的更多信息，请查看我们的如何用 Java 编码 series.

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

development

Java