› ›

运算符：通用

优先级

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

语法

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
引用	-	-	-	-	-	-	-	对象 @	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`；在 `b` 中存储 `boolean true`；
	从 `b` 加载 → `布尔值 true`；布尔与 `布尔值 true` 和 `布尔值 false` → `布尔值 false`；将 `布尔值 false` 存储到 `b`；（注意这等价于 `b = b && false`）
	从 `b` 加载 → `布尔值 false`；布尔异或 `布尔值 false` 和 `布尔值 false` → `布尔值 false`；将 `布尔值 false` 存储到 `b`；（注意这等价于 `b = b ^ false`）
	从 `b` 加载 → `布尔值 true`；布尔或 `布尔值 false` 和 `布尔值 true` → `布尔值 true`；将 `布尔值 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`