› ›

运算符：常规

运算符：常规编辑

优先级编辑

使用 优先级运算符 '()' 来保证表达式求值的顺序。由优先级运算符封装（括在括号中）的表达式会覆盖运算符之间现有的优先级关系，并按照从内到外的顺序在其他表达式之前求值。

语法

precedence: '(' expression ')';

示例

数值运算符的优先级。

int x = (5+4)*6;   
int y = 12/(x-50);

	声明 `int x`；将 `int 5` 和 `int 4` 相加 → `int 9`；将 `int 9` 和 `int 6` 相乘 → `int 54`；将 `int 54` 存储到 `x` 中；（注意，由于优先级运算符，加法运算在乘法运算之前求值）
	声明 `int y`；从 `x` 加载 → `int 54`；从 `int 54` 中减去 `int 50` → `int 4`；将 `int 12` 除以 `int 4` → `int 3`；将 `int 3` 存储到 `y` 中；（注意，由于优先级运算符，减法运算在除法运算之前求值）

函数调用编辑

使用 函数调用运算符 () 来调用现有函数。函数调用在脚本中定义。

语法

function_call: ID '(' ( expression (',' expression)* )? ')'';

示例

函数调用。
```
int add(int x, int y) { 
      return x + y;
  }

int z = add(1, 2); 
```
定义返回 int 并具有参数 (int x, int y) 的函数 add

声明 int z；使用参数 (int 1, int 2) 调用 add → int 3；将 int 3 存储到 z 中

强制转换编辑

显式强制转换将原始类型的值强制转换为目标类型的等效值作为操作。使用 强制转换运算符 '()' 来指定显式强制转换。有关更多信息，请参阅强制转换。

条件运算符编辑

条件运算符由三个表达式组成。第一个表达式进行求值，预期结果类型为布尔值。如果第一个表达式求值为 true，则将对第二个表达式进行求值。如果第一个表达式求值为 false，则将对第三个表达式进行求值。如果求值结果的类型不同，则第二个和第三个表达式将被提升。使用 条件运算符 '? :' 作为快捷方式，以避免在某些表达式中需要完整的 if/else 分支。

错误

如果第一个表达式求值结果不是布尔类型值。
如果第二个和第三个表达式的值无法提升。

语法

conditional: expression '?' expression ':' expression;

提升

	byte	short	char	int	long	float	double	引用	def
byte	int	int	int	int	long	float	double	-	def
short	int	int	int	int	long	float	double	-	def
char	int	int	int	int	long	float	double	-	def
int	int	int	int	int	long	float	double	-	def
long	long	long	long	long	long	float	double	-	def
float	float	float	float	float	float	float	double	-	def
double	double	double	double	double	double	double	double	-	def
引用	-	-	-	-	-	-	-	Object @	def
def	def	def	def	def	def	def	def	def	def

@ 如果两个引用类型的值相同，则不会发生此提升。

示例

条件运算符的求值。

boolean b = true;        
int x = b ? 1 : 2;       
List y = x > 1 ? new ArrayList() : null; 
def z = x < 2 ? x : 2.0;

	声明 `boolean b`；将 `boolean true` 存储到 `b` 中
	声明 `int x`；从 `b` 加载 → `boolean true` 求值第一个表达式：`int 1` → `int 1`；将 `int 1` 存储到 `x` 中
	声明 `List y`；从 `x` 加载 → `int 1`；`int 1` 大于 `int 1` → `boolean false`；求值第二个表达式：`null` → `null`；将 `null` 存储到 `y` 中；
	声明 `def z`；从 `x` 加载 → `int 1`；`int 1` 小于 `int 2` → `boolean true`；求值第一个表达式：从 `x` 加载 → `int 1`；提升 `int 1` 和 `double 2.0`：结果 `double`；隐式强制转换 `int 1` 为 `double 1.0` → `double 1.0`；隐式强制转换 `double 1.0` 为 `def` → `def`；将 `def` 存储到 `z` 中；

赋值编辑

使用 赋值运算符 '=' 将值存储在变量或引用类型成员字段中，以便在后续操作中使用。任何产生值的运算都可以赋值给任何变量/字段，只要类型相同，或者结果类型可以隐式强制转换为变量/字段类型。

有关使用变量的示例，请参阅变量赋值。

错误

如果值的类型无法匹配变量或字段的类型。

语法

assignment: field '=' expression

示例

这些示例使用以下引用类型定义

name:
  Example

non-static member fields:
  * int x
  * def y
  * List z

不同类型值的字段赋值。

Example example = new Example(); 
example.x = 1;                   
example.y = 2.0;                 
example.z = new ArrayList();

	声明 `Example example`；分配 `Example` 实例 → `Example 引用`；将 `Example 引用` 存储到 `example` 中
	从 `example` 加载 → `Example 引用`；将 `int 1` 存储到 `Example 引用` 的 `x` 中
	从 `example` 加载 → `Example 引用`；隐式强制转换 `double 2.0` 为 `def` → `def`；将 `def` 存储到 `Example 引用` 的 `y` 中
	从 `example` 加载 → `Example 引用`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式强制转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `Example 引用` 的 `z` 中

字段访问的字段赋值。

Example example = new Example(); 
example.x = 1;                   
example.y = example.x;

	声明 `Example example`；分配 `Example` 实例 → `Example 引用`；将 `Example 引用` 存储到 `example` 中
	从 `example` 加载 → `Example 引用`；将 `int 1` 存储到 `Example 引用` 的 `x` 中
	从 `example` 加载 → `Example 引用 @0`；从 `example` 加载 → `Example 引用 @1`；从 `Example 引用 @1` 的 `x` 加载 → `int 1`；隐式强制转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `Example 引用 @0` 的 `y` 中；（注意 `Example 引用 @0` 和 `Example 引用 @1` 相同）

复合赋值编辑

使用 复合赋值运算符 '$=' 作为赋值的快捷方式，其中二元运算将在作为左侧表达式的变量/字段和单独的右侧表达式之间发生。

复合赋值等效于以下表达式，其中 V 是变量/字段，T 是变量/成员的类型。

V = (T)(V op expression);

运算符

下表显示了可用于复合赋值的运算符。每个运算符都遵循其常规定义的强制转换/提升规则。对于数值运算，必要时会进行额外的隐式强制转换，以将提升的数值类型值返回到变量/字段的原始数值类型值，这可能会导致数据丢失。

运算符	复合符号
乘法	*=
除法	/=
取余	%=
加法	+=
减法	-=
左移	<<=
右移	>>=
无符号右移	>>>=
按位与	&=
布尔与	&=
按位异或	^=
布尔异或	^=
按位或	\|=
布尔或	\|=
字符串连接	+=

错误

如果值的类型无法匹配变量或字段的类型。

语法

compound_assignment: ( ID | field ) '$=' expression;

注意，使用 $= 表示使用任何可能的二元运算符。

示例

每个数值运算符的复合赋值。

int i = 10; 
i *= 2;     
i /= 5;     
i %= 3;     
i += 5;     
i -= 5;     
i <<= 2;    
i >>= 1;    
i >>>= 1;   
i &= 15;    
i ^= 12;    
i |= 2;

	声明 `int i`；将 `int 10` 存储到 `i` 中
	从 `i` 加载 → `int 10`；将 `int 10` 和 `int 2` 相乘 → `int 20`；将 `int 20` 存储到 `i` 中；（注意，这等效于 `i = i*2`）
	从 `i` 加载 → `int 20`；将 `int 20` 除以 `int 5` → `int 4`；将 `int 4` 存储到 `i` 中；（注意，这等效于 `i = i/5`）
	从 `i` 加载 → `int 4`；`int 4` 除以 `int 3` 的余数 → `int 1`；将 `int 1` 存储到 `i` 中；（注意，这等效于 `i = i%3`）
	从 `i` 加载 → `int 1`；将 `int 1` 和 `int 5` 相加 → `int 6`；将 `int 6` 存储到 `i` 中；（注意，这等效于 `i = i+5`）
	从 `i` 加载 → `int 6`；从 `int 6` 中减去 `int 5` → `int 1`；将 `int 1` 存储到 `i` 中；（注意，这等效于 `i = i-5`）
	从 `i` 加载 → `int 1`；将 `int 1` 左移 `int 2` 位 → `int 4`；将 `int 4` 存储到 `i` 中；（注意，这等效于 `i = i<<2`）
	从 `i` 加载 → `int 4`；将 `int 4` 右移 `int 1` 位 → `int 2`；将 `int 2` 存储到 `i` 中；（注意，这等效于 `i = i>>1`）
	从 `i` 加载 → `int 2`；将 `int 2` 无符号右移 `int 1` 位 → `int 1`；将 `int 1` 存储到 `i` 中；（注意，这等效于 `i = i>>>1`）
	从 `i` 加载 → `int 1`；`int 1` 和 `int 15` 按位与 → `int 1`；将 `int 1` 存储到 `i` 中；（注意，这等效于 `i = i&2`）
	从 `i` 加载 → `int 1`；`int 1` 和 `int 12` 进行按位异或运算 → `int 13`；将 `int 13` 存储到 `i` 中；（请注意，这等效于 `i = i^2`）
	从 `i` 加载 → `int 13`；`int 13` 和 `int 2` 进行按位或运算 → `int 15`；将 `int 15` 存储到 `i` 中；（请注意，这等效于 `i = i\|2`）

每个布尔运算符的复合赋值。

boolean b = true; 
b &= false;       
b ^= false;       
b |= true;

	声明 `boolean b`；将 `boolean true` 存储在 `b` 中；
	从 `b` 加载 → `boolean true`；`boolean true` 和 `boolean false` 进行布尔与运算 → `boolean false`；将 `boolean false` 存储到 `b` 中；（请注意，这等效于 `b = b && false`）
	从 `b` 加载 → `boolean false`；`boolean false` 和 `boolean false` 进行布尔异或运算 → `boolean false`；将 `boolean false` 存储到 `b` 中；（请注意，这等效于 `b = b ^ false`）
	从 `b` 加载 → `boolean true`；`boolean false` 和 `boolean true` 进行布尔或运算 → `boolean true`；将 `boolean true` 存储到 `b` 中；（请注意，这等效于 `b = b \|\| true`）

使用字符串连接运算符进行复合赋值。

String s = 'compound'; 
s += ' assignment';

	声明 `String s`；将 `String 'compound'` 存储到 `s` 中；
	从 `s` 加载 → `String 'compound'`；将 `String 'compound'` 和 `String ' assignment'` 进行字符串连接 → `String 'compound assignment'`；将 `String 'compound assignment'` 存储到 `s` 中；（请注意，这等效于 `s = s + ' assignment'`）

使用 def 类型的复合赋值。

def x = 1; 
x += 2;

	声明 `def x`；将 `int 1` 隐式转换为 `def`；将 `def` 存储到 `x` 中；
	从 `x` 加载 → `def`；将 `def` 隐式转换为 `int 1` → `int 1`；将 `int 1` 和 `int 2` 相加 → `int 3`；将 `int 3` 隐式转换为 `def` → `def`；将 `def` 存储到 `x` 中；（请注意，这等效于 `x = x+2`）

带有额外隐式转换的复合赋值。

byte b = 1; 
b += 2;

	声明 `byte b`；将 `byte 1` 存储到 `x` 中；
	从 `x` 加载 → `byte 1`；将 `byte 1` 隐式转换为 `int 1` → `int 1`；将 `int 1` 和 `int 2` 相加 → `int 3`；将 `int 3` 隐式转换为 `byte 3` → `byte 3`；将 `byte 3` 存储到 `b` 中；（请注意，这等效于 `b = b+2`）

« 运算符运算符：数值 »

	定义返回 `int` 并具有参数 (`int x`, `int y`) 的函数 `add`
	声明 `int z`；使用参数 (`int 1`, `int 2`) 调用 `add` → `int 3`；将 `int 3` 存储到 `z` 中