如何在Java中使用运算符

简介

运算符是由一个或多个符号组合而成，例如著名的算术运算符减号（-）和加号（+），或者更高级的instanceof。当你将运算符应用于值或变量时，会得到一个运算的结果。这些运算在编程中是基础的，因为它们的结果被赋给一个变量，或者通过进一步的计算直到程序达到最终的目标。

对于这个教程，你必须熟悉操作数，即被运算符应用的值或变量。根据操作数的数量，运算符可以分为三组。首先，当操作中只有一个操作数时，运算符被称为一元运算符。同样地，二元运算符涉及两个操作数。最后，当有三个操作数时，运算符为三元运算符。根据这种分类，这个教程针对每种类型的运算符分为三个主要部分组织。

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

先决条件

为了跟随这个教程，你需要准备：

• An environment in which you can execute Java programs to follow along with the examples. To set this up on your local machine, you will need the following:Java (version 11 or above) installed on your machine, with the compiler provided by the Java Development Kit (JDK). For Ubuntu and Debian, follow the steps for Option 1 in our tutorial, How To Install Java with Apt on Ubuntu 22.04. For other operating systems, including Mac and Windows, see the download options for Java installation.
  To compile and run the code examples, this tutorial uses Java Shell, which is a Read-Evaluate-Print Loop (REPL) run from the command line. To get started with JShell, check out the Introduction to JShell guide.
• Familiarity with Java and object-oriented programming, which you can find in our tutorial, How To Write Your First Program in Java.
• An understanding of Java data types, which is discussed in our tutorial, Understanding Data Types in Java
  .

一元运算符

一元运算符应用于一个操作数，这使它们变得最直接。一元运算符常被使用，因为它们使代码更简洁、易读。它们代替了明确描述增加和减少值等操作的需要。然而，当与其他运算符结合时，一元运算符也可能变得难以使用，稍后在本节中您将发现这一点。

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

递增和递减运算符

增量和减量运算符，正如它们的名字所表明的那样，用于增加和减少数字。增量运算符由两个加号（++）组成，而减量运算符由两个减号（–）组成。这些运算符在操作数之前和之后使用。

前增量和前减量

当你在操作数之前使用运算符时，根据使用的是++还是–，你是进行预增量或预减量操作。当你使用预操作符时，在使用操作数之前你会改变它的值。因此，当你实际使用这个值时，它已经发生了改变。

要使用前增量运算符，将以下内容输入到jshell中：

1. int theAnswer = 42;
2. System.out.println(“Preincrementing: “ + ++theAnswer);

 

在第一行，你用值为42来定义一个变量theAnswer。在第二行，你使用println()方法来打印出它，并展示它是如何改变的。

在上面的例子中，前缀自增运算符是++，它位于theAnswer之前。通过以这种方式使用前缀自增运算符，您首先将theAnswer的值增加到43。在此之后，当println()对其进行处理时，它已经是43，因此您看到输出的是43。

theAnswer ==> 42 Preincrementing: 43

预递减工作方式类似，但您是通过减少操作数的值来递减。作为练习，将上述示例修改为使用预递减运算符–而不是预递增运算符++。

后递增和后递减

与前置运算符相比，后置运算符是在使用操作数后更改其值的。有一些特定情况下常常使用后置或前置运算符，但整体而言，这是个人偏好的问题。

为了演示后置运算符的工作原理，您将对theAnswer的值进行后增操作，并检查其值的变化。在jshell中添加以下行：

1. int theAnswer = 42;
2. System.out.println(“Postincrementing: “ + theAnswer++);
3. System.out.println(“Final value: “ + theAnswer);

 

变量theAnswer首先等于42。然后，它被打印出来并进行后自增操作。在最后一行，你再次打印它以查看最终值。

你应该输出：

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

正如你所见，在后自增的过程中，答案仍然是42。只有在后自增后再次打印时，答案才变成了43（最终值：43）。

后递减的工作方式相同。首先获取并使用值，然后才进行递减操作。作为练习，请尝试将后递增运算符++替换为后递减运算符–，甚至可以包含其中一种前运算符。

非运算符

NOT运算符，也被称为逻辑非运算符，可以翻转布尔操作数的值。它用感叹号!表示。通常，当你有一个布尔变量或值，并且想要将其与相反的值一起重复使用时，你会使用NOT运算符。因此，你无需不必要地创建另一个具有相反值的变量。

这是一个 NOT 运算符如何工作的例子。为了简单起见，你会反转 true 的值：

1. boolean isJavaFun = !true;
2. System.out.println(isJavaFun);

 

你定义了一个布尔变量isJavaFun为true。然而，NOT运算符先于true；因此，true的值被翻转为false。当你运行上述代码时，将会打印以下输出。

isJavaFun ==> false false

这是NOT运算符的工作原理。有时它可能会让人困惑且难以察觉，因此你应该谨慎使用。

在上述情况下，你可以使用false而不是!true。这是正确的做法，因为它更清晰、更直观。一般来说，最好使用直接的文字或方法，而不是需要额外操作的替代方案。然而，在某些情况下，这种做法可能并不总是合理或可行的。例如，通常可以使用NOT运算符来翻转布尔方法的结果。

举个例子，要检查一个字符串是否包含另一个字符串，你可以使用contains()方法。然而，如果你想要检查相反情况（即一个字符串不包含另一个字符串时），没有其他内置方法可用。你需要将contains()与NOT运算符一起使用来实现。

想象你有一个字符串“Java is smart”，并且你想要检查以下内容：

1. 该字符串包含智能。

 

该字符串不包含困难。

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

1. String javaIsSmart = “Java is smart.”;
2. boolean isSmartPartOfJava = javaIsSmart.contains(“smart”);
3. boolean isHardNotPartOfJava = !javaIsSmart.contains(“hard”);

 

第一行，你定义了一个String变量javaIsSmart。第二行，你定义了一个布尔变量isSmartPartOfJava，它是通过contains()方法的操作结果确定的——在这种情况下，即字符串smart是否是javaIsSmart字符串的一部分。同样地，在第三行，你定义了一个布尔变量isHardNotPartOfJava，它是由于在javaIsSmart中找不到hard而确定的。

当你在jshell中运行这段代码时，你将会得到以下的输出。

javaIsSmart ==> “Java is smart.” isSmartPartOfJava ==> true isHardNotPartOfJava ==> true

根据上述输出:

• isSmartPartOfJava is true because smart is found in javaIsSmart.
• isHardNotPartOfJava is also true because hard is not found in javaIsSmart.

在本节中，您探索了使用一个操作数进行自增、自减和逻辑非操作符。尽管这些操作符只有一个操作数，但它们可能很难使用，正如逻辑非操作符所示。在下一步中，您将通过使用两个操作数的运算符来进一步建立这些知识。

二元操作符

二进制运算符作用于两个操作数，通常与算术运算（例如加法和减法）相关联。还有其他非数学相关的二进制运算符，例如逻辑运算符和特殊的关系运算符instanceof。在本节中，您将首先学习算术二进制运算符，这可能更为熟悉。

算术二进制运算符

以下是用于算术运算的众所周知的操作符，如加法（+）和减法（-）。以下是加法示例：

1. int theAnswer = 40 + 2;
2. System.out.println(“The result is: “ + theAnswer);

 

在第一行，你将2加上40，并将结果赋值给theAnswer变量。当你打印它时，你得到最终值42。

The result is: 42

为了进一步练习，尝试使用其他算术运算符，你可以在Java文档中找到。

赋值运算符 fù)

赋值运算符将左操作数赋予右操作数的值。通常情况下，左操作数是一个变量，右操作数是一个值或指向对象的引用。这可能听起来很熟悉，因为你在所有的例子中都使用过这样的赋值。在本节中，你将练习使用基本的赋值运算符、一些复合赋值运算符和强制类型转换运算符。

基本的赋值运算符(=)是一个众所周知和经常使用的运算符。

1. int x = 1;

 

在这个例子中，你声明一个整数变量x，并赋值为1。使用等号（=）是给变量赋值的方法。

复合赋值运算符

复合赋值运算符（+=、-=、*=、\=）将赋值与附加的算术运算（如加法或减法）结合起来。这些运算符可以避免冗余代码，特别适用于简单易懂的算术运算。

例如，使用复合 += 赋值运算符来将加法和赋值结合在一起，就像这样:

1. int x = 1;
2. int y = 1;
3. x += y;
4. System.out.println(“x is: “ + x);

 

在前两行中，你声明了两个整数变量x和y，它们的值都为1。接下来，你使用+=运算符重新为x赋值，这意味着x先与y相加，然后再赋值给x。

以上代码将返回类似于这样的输出。

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

根据上述输出，x和y的值都为1。在第三行，有一个临时变量，它的名称是随机分配的($11)。它通过复合赋值操作保存了x的值。在最后一行，打印出的x的值为2。

这段代码可以不使用复合赋值运算符进行重写，如下所示：

1. int x = 1;
2. int y = 1;
3. x = x + y;
4. System.out.println(“x is: “ + x);

 

与之前的例子相比，你需要在第3行编写额外的代码来明确描述x加y的相加过程。

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

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

最终，无论是第一个还是第二个例子中，x 都等于2。然而，在第二个例子中，jshell 没有打印一个临时变量名称，比如$11。相反，它直接使用了x来显示它的值已经改变（x ==> 2）。这样详细的输出对学习非常有帮助，而且只有在jshell中才能使用。

其余的复合运算符包括减法（-=）、乘法（*=）和除法（/=），与赋值一起结合使用。尝试更改上述示例来查看它们的工作方式。

了解复合运算符是很好的，因为它们经常被使用。然而，使用复合运算符并不会提高性能，因此使用复合运算符是个人选择的问题。如果它们看起来令人困惑，则可以选择不使用。

转型运算符

你将要回顾的最后一个赋值操作符是转换操作符，它是一个由括号括起来的数据类型：(数据类型)。转换操作符用于类型转换，即将一个数据类型解释为另一个数据类型。

数据类型必须是兼容的。数据类型之间是否兼容取决于它们之间的关系，比如一个类是否是另一个类的父类或同级类。例如，你可以将整数转换为短整型，因为这两种数据类型都用于存储整数。然而，你不能将整数转换为布尔型，因为这两种数据类型不兼容。

在这一节中，你将探索一些常见的类型转换示例和问题。为了教育目的，你将从一个错误和不匹配的转换开始。

1. boolean y = (boolean) 1;

 

使用这行代码，你试图将整数1转换为布尔值，并赋值给变量y。当你将其粘贴到JShell中时，你会得到以下错误。

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

根据错误信息所述，你不能将一个整数值转换为布尔值。布尔值只能是true或false，无法确定1应该是哪个布尔值。

现在，你将尝试一个具有兼容数据类型的例子。你将使用两种原始类型来存储整数：int 和 short。它们的区别在于它们的容量，也就是存储信息可用的内存量。int具有更大的容量，因此可以存储更大的数字。

将以下行添加到jshell中：

1. int prize = 32767;
2. short wonPrize = (short) prize;
3. System.out.println(“You won: “ + wonPrize);

 

在第一行中，你将彩票奖品定义为一个值为32767的int原始类型。然而，在第二行中，你决定使用short原始类型更合适来储存wonprize的值，并使用(short)将prize转换为short类型。

在jshell中运行上述代码时，输出结果是：

prize ==> 32767 wonPrize ==> 32767 You won: 32767

上面的输出确认了奖品和赢得奖品的值被正确设置为32767。最后一行使用wonPrize变量来说明你赢得了多少奖品。

就int和short而言，强制转换可能会显得没有必要，实际情况下可能不会看到这种转换。然而，这个例子对于展示强制转换的概念是有用的。

强制转换似乎很简单，但有一个注意事项。当你从具有较大容量的数据类型转换为具有较小容量的数据类型时，可能会超过较小容量的限制，这被称为溢出。为了展示这个问题，可以重用之前的例子，并将奖励从32767增加到32768，像这样：

1. int prize = 32768;
2. short wonPrize = (short) prize;
3. System.out.println(“You won: “ + wonPrize);

 

当你在jshell中运行上述命令时，将会得到如下输出：

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

在这种情况下，你会丢失信息并得到意想不到的结果。当将值32768转换为short类型时，其值变为-32768。这是因为short类型的存储容量范围是从-32768到32767。当你试图存储一个大于最大值的数时，会发生溢出并从最小值重新开始。在这个案例中，当你尝试存储32768时，超过了最大容量（32767）1个单位。因此，下一个值会从最小可能值开始分配。在这里，最小值为-32768。

这就是为什么上述的输出看起来出乎意料——最终的奖品成为了一个负数。这种问题并不总是容易发现，所以你应该谨慎使用类型转换。你可能会在更复杂的情境中使用类型转换，这将在Java系列的日后教程中介绍。

关系运算符

关系运算符比较两个操作数并返回一个布尔值结果。如果关系成立，则结果为真。如果不成立，则结果为假。

第一类关系运算符是等于（==）和不等于（!=）。它们用于判断值和对象的相等性。对于原始值和字面量，它们的使用类似于数学。

为了演示equals等于操作符，比较两个整数常量。实际上，它们将是同一个数字：1。你会比较它是否等于自己，以便你可以得到一个真正的结果。将以下代码粘贴到jshell中：

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

 

在上述代码中，你断言1是否等于1。由于这两个数字相等，该表达式得出的结果为true。因此，println()会打印出true。

true

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

与比较原始值相比，比较对象的相等性更加复杂，因为您要断定两个变量是否指向同一个对象。尝试以比较两个整数(Integer)的例子来说明。

1. Integer myAnswer = Integer.valueOf(42);
2. Integer yourAnswer = Integer.valueOf(42);
3. System.out.println(myAnswer == yourAnswer);

 

在以上代码中，你创建了两个整数变量，每个变量的值都为42。在最后一行，你比较它们是否相等，并且如果它们相等则打印true。根据我们之前的Java数据类型教程，你可能知道Integer.valueOf()首先在缓存中检查是否有具有相同值的对象，并且如果已经存在一个具有该值的对象，则返回同一个对象。这就是为什么myAnswer和yourAnswer都得到了相同的对象。

当你把以上的代码粘贴到jshell中时，你将会得到以下输出结果：

myAnswer ==> 42 yourAnswer ==> 42 true

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

1. String answer1 = new String(“yes”);
2. String answer2 = new String(“yes”);
3. System.out.println(answer1 == answer2);

 

首先，你声明了两个新的String变量（answer1和answer2），它们的值都为”yes”。然而，你使用了new关键字来创建新的String对象。因此，这两个变量并不指向同一个对象 – 它们实际上指向两个不同的对象（但值相同）。

当你将以上代码粘贴到jshell中时，你将得到以下输出结果。

answer1 ==> “yes” answer2 ==> “yes” false

即使回答1和回答2的值相同（都是“是”），它们的相等性评估结果却是假，这意味着它们是不相等的。如果您打算比较值，例如判断两个答案是否都是肯定的，而不关心底层对象，那么这可能令人困惑。为此，许多类（包括字符串）都有专门的方法用于断言相等性。

在字符串的情况下，此方法是equals()。尝试更改代码以使用equals()（而不是==），像这样：

1. String answer1 = new String(“yes”);
2. String answer2 = new String(“yes”);
3. System.out.println(answer1.equals(answer2));

 

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

当你将这段代码粘贴到JShell中时，你将得到以下输出结果：

answer1 ==> “yes” answer2 ==> “yes” true

以上输出与上一个输出相似，但它以true结尾，确认了两个对象的值是相等的。这个例子证明了在比较引用类型时，你必须小心，并在可用时使用相应的方法。

一个选择的等于操作符，不是等于！=，用法类似，但它断言两个变量或值是否不相同（或不等）。作为练习，在之前的一些示例中尝试使用！=替换==。

类似于==和！=，下面的四个关系运算符也源自数学：小于<，小于等于<=，大于>，大于等于>=。

这是一个使用大于操作符的示例。

1. System.out.println(4 > 5);

 

当你在jshell中运行这段代码时，你将会得到以下输出：

false

以上的代码首先比较了4是否大于5。由于不是，表达式的结果为 false。然后，println() 方法打印了比较的结果（false）。

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

使用以下示例来探索instanceof的工作原理：

1. String greeting = “hello”;
2. System.out.println(greeting instanceof String);

 

首先，你创建一个名为greeting的字符串变量。然后，在括号中评估greeting是否是一个字符串实例。

当你在jshell中粘贴代码时，你将获得以下输出：

greeting ==> “hello” true

由于问候语是一个字符串实例，所以表达式的值为true，通过println()函数在屏幕上打印。

逻辑运算符

逻辑运算符包括逻辑与(&)、逻辑或(|)和异或(^)。它们都按照以下方式对两个值进行评估。

• Logical AND is true when both values are true.
• Logical OR is true when at least one of the values is true.
• Exclusive OR is true if one value is true and the other is false.

当逻辑运算符不满足上述条件时，它们是假的。

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

1. boolean isJavaFun = true;
2. boolean isJavaPowerful = true;
3. System.out.println(isJavaFun & isJavaPowerful);

 

前两行定义了两个布尔变量isJavaFun和isJavaPowerful，都赋值为true。在第三行，你在括号中对isJavaFun和isJavaPowerful执行了逻辑与操作，并且结果由println()函数输出。

当你将这段代码粘贴到jshell中时，你将会得到以下输出：

isJavaFun ==> true isJavaPowerful ==> true true

两个变量都被设置为真，并通过逻辑与运算的结果打印出最后的真值。

要增加你的技能，尝试使用前面的代码示例并进行一些变化。你可以尝试在变量之间切换true和false的值。你也可以尝试将逻辑运算符改为逻辑或(|)和异或(^)。

逻辑运算符的扩展版本是所谓的短路逻辑运算符：短路与（&&）和短路或（||）。它们与常规的逻辑与和逻辑或运算符类似，但有一个重要的区别：如果第一个运算符的评估足够完成操作，第二个运算符将不会被评估。因此，为了使短路与为真，它两边的条件都必须为真。然而，如果左边为假，则不会评估右边。类似地，对于短路或，如果左边为假，则不会评估右边。

这里举一个使用短路逻辑或的例子。

1. boolean isJavaFun = true;
2. Boolean isNullFun = null;
3. System.out.println(isJavaFun || isNullFun);

 

首先，你将变量isJavaFun赋值为true。为了与之前的示例保持一致性，这个变量是基本类型boolean。然而，对于下一个变量isNullFun，你使用Boolean引用类型，以便可以将其赋值为null。在这个示例中，你有一个指向null的变量很重要，但是正如你可能还记得的，在理解Java数据类型的教程中，基本类型不能为null，这就是为什么你使用了引用类型的原因。

当短路或运算符发生在括号中时，由于左侧为真，isNullFun被忽略，这就足以使整个表达式为真。因此，当您在jshell中运行代码时，将打印以下输出：

isJavaFun ==> true isNullFun ==> null true

第一行和第二行确认变量被赋值为真和空值。第三行打印真，因为短路或操作返回了真。

以上的例子是选择特定的空值来展示短路运算符的工作原理，并且isNullFun函数不会被执行。要看到isNullFun被执行，请尝试将短路的OR运算符更改为普通的OR，像这样：

1. boolean isJavaFun = true;
2. Boolean isNullFun = null;
3. System.out.println(isJavaFun | isNullFun);

 

常规的逻辑或运算符会同时对表达式的两侧进行求值。

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

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

当逻辑OR尝试评估null时，你会得到java.lang.NullPointerException。因此，短路操作符更受青睐，几乎总是使用而不是常规逻辑操作符。

作为练习，尝试使用短路运算符&&和||，它们是最受欢迎和最有用的运算符。

在本节中，你在一系列的例子中使用了二进制运算符，从基本算术到涉及强制类型转换和比较对象相等性的更具挑战性的操作。在下一节中，你将使用三个运算数来进行操作。

三元运算符

在之前的章节中，你练习了使用一个或两个操作数的运算符。在这最后一节中，你将使用三元运算符，这是唯一的三个操作数的运算符。它的语法是这样的：第一个操作数？第二个操作数：第三个操作数。第一个操作数必须是布尔值。如果它为真，则从表达式中返回第二个操作数。如果第一个操作数为假，则返回第三个操作数。

三元运算符因其可以避免编写复杂的条件语句和存储结果于临时变量而广受欢迎且经常被使用。

尝试使用以下示例中的三元运算符。

1. boolean isJavaFun = true;
2. String shouldILearnJava = isJavaFun ? “yes” : “no”;
3. System.out.println(“Should I learn Java: “ + shouldILearnJava);

 

isJavaFun 的值被设置为 true，并且变量 shouldILearnJava 是通过三元操作符来确定的。因为第一个操作数 isJavaFun 是 true，所以返回第二个操作数，即字符串 “yes”。为了验证这一点，第三行打印变量 shouldILearnJava，此时应该输出 yes。

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

Should I learn Java: yes

为了额外的练习，尝试在isJavaFun前面使用NOT运算符。

1. boolean isJavaFun = true;
2. String shouldILearnJava = !isJavaFun ? “yes” : “no”;
3. System.out.println(“Should I learn java: “ + shouldILearnJava);

 

通过将isJavaFun的值从true翻转为false，结果是三元表达式将返回最后的操作数，即”no”。

三元表达式可能会让人感到困惑，特别是当你使用附加的运算符，如非（NOT）运算符时。然而，它们可以减少重复的代码，这就是为什么它们很受欢迎的原因。

运算符优先级

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

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

理解运算符优先级有助于编写干净的代码，这是现代编程的事实标准。编写干净的代码意味着编写易理解和易维护的代码。在运算符方面，干净代码范式意味着尽量少使用运算符，而是创建单独的语句，而不是嵌套和组合运算符。

例如，应避免使用像下面这样的陈述，因为它们太令人困惑。

1. boolean isThisCleanCode = !true || false && true;

 

即使你查阅操作手册，也可能无法猜测最终结果（isThisCleanCode为假）。

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

• Pre and post increment and decrement operators: They have the highest precedence and take effect before any other operators.
• Arithmetic rules from math: All rules valid in math are also valid in Java. For example, division / has higher precedence than addition +. Parentheses override the precedence; that is, you can group operations with parentheses and they will be evaluated with priority.
• Equality and relational operators: Since they evaluate equality or relation, they also work with the final values of their operands, and thus all other operations have to be completed.
• Logical OR and AND operators (including short-circuit): Similar to the ternary operator, they all need the final values of their operands, hence their low precedence.
• Ternary operator: The ternary operator needs the final value of the first operand. For this to happen, all other operations must have been completed. That’s why the ternary operator has such low precedence.
• Assignment operators: They are evaluated last so that all other operations have been completed and the final result can be assigned to the operand on the left. As an example, think of every variable that you have assigned with the equals sign so far.

现在，你将使用一道数学问题来探索运算符优先级。

1. int x = 1 + 10 / 2;

 

当你将以上的代码粘贴到jshell中时，你将会得到下面的输出结果：

x ==> 6

根据上述输出，x的值为6。这是因为已经完成了以下操作，按照递减的优先级排列：

1. 首先计算10除以2，结果为5。

 

1. 然后将第一步操作的结果（5）加1，得到6。

 

接着赋值操作符开始执行，使用最终结果（6）将其赋给变量x。

尽管这个数学方程相对来说很简单，但你可以通过增加冗余内容并使用括号来确保运算的优先级更容易理解。考虑把它改写成这样：

1. int x = 1 + (10 / 2);

 

当你将上述内容粘贴到jshell中时，将打印出与之前相同的结果。

x ==> 6

在上一个示例中，您没有通过在 10 / 2 周围使用括号来更改优先级。相反，它们的目的只是使括号内的操作的优先级更明显。像这样使用括号有助于使您的代码更加清晰和易懂，尤其是在操作更加复杂的情况下。

优先规则很有趣，花点时间学习它们是个好主意。牢记代码的整洁范式，不要进行不必要的嵌套和操作符组合，因为这被视为代码上的弱点。

结论

在本教程中，你学习了Java中的主要运算符。你编写了一些测试代码片段，其中你看到了与运算符相关的一些最有用和有趣的场景。你还学习了简洁代码的原则，意识到运算符不应该被不必要地过度使用。

想了解更多关于Java的内容，请访问我们的《Java编程指南》系列。