› ›

运算符：数值

后置递增

使用后置递增运算符 '++' 将数值类型变量/字段的值增加1。对于以下类型：byte、short 和 char，需要额外的隐式转换才能将提升后的数值类型值返回到变量/字段的原始数值类型值。如果变量/字段作为表达式的一部分被读取，则会在递增之前加载其值。

错误

如果变量/字段是非数值类型。

语法

post_increment: ( variable | field ) '++';

提升

原始	提升后的	隐式的
byte	int	byte
short	int	short
char	int	char
int	int
long	long
float	float
double	double
def	def

示例

使用不同数值类型的后置递增。

short i = 0; 
i++;         
long j = 1;  
long k;      
k = j++;

	声明 `short i`；将 `short 0` 存储到 `i`
	从 `i` 加载 → `short 0`；提升 `short 0`：结果 `int`；将 `int 0` 和 `int 1` 相加 → `int 1`；将 `int 1` 隐式转换为 `short 1`；将 `short 1` 存储到 `i`
	声明 `long j`；将 `int 1` 隐式转换为 `long 1` → `long 1`；将 `long 1` 存储到 `j`
	声明 `long k`；将默认值 `long 0` 存储到 `k`
	从 `j` 加载 → `long 1`；将 `long 1` 存储到 `k`；将 `long 1` 和 `long 1` 相加 → `long 2`；将 `long 2` 存储到 `j`

使用 def 类型的后置递增。

def x = 1; 
x++;

	声明 `def x`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `x`
	从 `x` 加载 → `def`；将 `def` 隐式转换为 `int 1`；将 `int 1` 和 `int 1` 相加 → `int 2`；将 `int 2` 隐式转换为 `def`；将 `def` 存储到 `x`

后置递减

编辑

使用后置递减运算符 '--' 将数值类型变量/字段的值减少1。对于以下类型：byte、short 和 char，需要额外的隐式转换才能将提升后的数值类型值返回到变量/字段的原始数值类型值。如果变量/字段作为表达式的一部分被读取，则会在递减之前加载其值。

错误

如果变量/字段是非数值类型。

语法

post_decrement: ( variable | field ) '--';

提升

原始	提升后的	隐式的
byte	int	byte
short	int	short
char	int	char
int	int
long	long
float	float
double	double
def	def

示例

使用不同数值类型的后置递减。

short i = 0; 
i--;         
long j = 1;  
long k;      
k = j--;

	声明 `short i`；将 `short 0` 存储到 `i`
	从 `i` 加载 → `short 0`；提升 `short 0`：结果 `int`；从 `int 0` 减去 `int 1` → `int -1`；将 `int -1` 隐式转换为 `short -1`；将 `short -1` 存储到 `i`
	声明 `long j`；将 `int 1` 隐式转换为 `long 1` → `long 1`；将 `long 1` 存储到 `j`
	声明 `long k`；将默认值 `long 0` 存储到 `k`
	从 `j` 加载 → `long 1`；将 `long 1` 存储到 `k`；从 `long 1` 减去 `long 1` → `long 0`；将 `long 0` 存储到 `j`

使用 def 类型的后置递减。

def x = 1; 
x--;

	声明 `def x`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `x`
	从 `x` 加载 → `def`；将 `def` 隐式转换为 `int 1`；从 `int 1` 减去 `int 1` → `int 0`；将 `int 0` 隐式转换为 `def`；将 `def` 存储到 `x`

前置递增

编辑

使用前置递增运算符 '++' 将数值类型变量/字段的值增加1。对于以下类型：byte、short 和 char，需要额外的隐式转换才能将提升后的数值类型值返回到变量/字段的原始数值类型值。如果变量/字段作为表达式的一部分被读取，则会在递增之后加载其值。

错误

如果变量/字段是非数值类型。

语法

pre_increment: '++' ( variable | field );

提升

原始	提升后的	隐式的
byte	int	byte
short	int	short
char	int	char
int	int
long	long
float	float
double	double
def	def

示例

使用不同数值类型的递增。

short i = 0; 
++i;         
long j = 1;  
long k;      
k = ++j;

	声明 `short i`；将 `short 0` 存储到 `i`
	从 `i` 加载 → `short 0`；提升 `short 0`：结果 `int`；将 `int 0` 和 `int 1` 相加 → `int 1`；将 `int 1` 隐式转换为 `short 1`；将 `short 1` 存储到 `i`
	声明 `long j`；将 `int 1` 隐式转换为 `long 1` → `long 1`；将 `long 1` 存储到 `j`
	声明 `long k`；将默认值 `long 0` 存储到 `k`
	从 `j` 加载 → `long 1`；将 `long 1` 和 `long 1` 相加 → `long 2`；将 `long 2` 存储到 `j`；将 `long 2` 存储到 `k`

使用 def 类型的递增。

def x = 1; 
++x;

	声明 `def x`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `x`
	从 `x` 加载 → `def`；将 `def` 隐式转换为 `int 1`；将 `int 1` 和 `int 1` 相加 → `int 2`；将 `int 2` 隐式转换为 `def`；将 `def` 存储到 `x`

前置递减

编辑

使用前置递减运算符 '--' 将数值类型变量/字段的值减少1。对于以下类型：byte、short 和 char，需要额外的隐式转换才能将提升后的数值类型值返回到变量/字段的原始数值类型值。如果变量/字段作为表达式的一部分被读取，则会在递减之后加载其值。

错误

如果变量/字段是非数值类型。

语法

pre_decrement: '--' ( variable | field );

提升

原始	提升后的	隐式的
byte	int	byte
short	int	short
char	int	char
int	int
long	long
float	float
double	double
def	def

示例

使用不同数值类型的递减。

short i = 0; 
--i;         
long j = 1;  
long k;      
k = --j;

	声明 `short i`；将 `short 0` 存储到 `i`
	从 `i` 加载 → `short 0`；提升 `short 0`：结果 `int`；从 `int 0` 减去 `int 1` → `int -1`；将 `int -1` 隐式转换为 `short -1`；将 `short -1` 存储到 `i`
	声明 `long j`；将 `int 1` 隐式转换为 `long 1` → `long 1`；将 `long 1` 存储到 `j`
	声明 `long k`；将默认值 `long 0` 存储到 `k`
	从 `j` 加载 → `long 1`；从 `long 1` 减去 `long 1` → `long 0`；将 `long 0` 存储到 `j`；将 `long 0` 存储到 `k`；

使用 def 类型的递减运算符。

def x = 1; 
--x;

	声明 `def x`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `x`
	从 `x` 加载 → `def`；将 `def` 隐式转换为 `int 1`；从 `int 1` 减去 `int 1` → `int 0`；将 `int 0` 隐式转换为 `def`；将 `def` 存储到 `x`

一元正号

编辑

使用一元正号运算符 '+' 保留数值类型的标识。

错误

如果值是非数值类型。

语法

unary_positive: '+' expression;

示例

使用不同数值类型的一元正号。

int x = +1;  
long y = +x;

	声明 `int x`；`int 1` 的标识 → `int 1`；将 `int 1` 存储到 `x`
	声明 `long y`；从 `x` 加载 → `int 1`；`int 1` 的标识 → `int 1`；将 `int 1` 隐式转换为 `long 1` → `long 1`；将 `long 1` 存储到 `y`

使用 def 类型的一元正号。

def z = +1; 
int i = +z;

	声明 `def z`；`int 1` 的标识 → `int 1`；将 `int 1` 隐式转换为 `def`；将 `def` 存储到 `z`
	声明 `int i`；从 `z` 加载 → `def`；将 `def` 隐式转换为 `int 1`；`int 1` 的标识 → `int 1`；将 `int 1` 存储到 `i`；

一元负号

编辑

使用一元负号运算符 '-' 对数值类型的值取反。

错误

如果值是非数值类型。

语法

unary_negative: '-' expression;

示例

使用不同数值类型的一元负号。

int x = -1;  
long y = -x;

	声明 `int x`；对 `int 1` 取反 → `int -1`；将 `int -1` 存储到 `x`
	声明 `long y`；从 `x` 加载 → `int 1`；对 `int -1` 取反 → `int 1`；将 `int 1` 隐式转换为 `long 1` → `long 1`；将 `long 1` 存储到 `y`

使用 def 类型的一元负号。

def z = -1; 
int i = -z;

	声明 `def z`；对 `int 1` 取反 → `int -1`；将 `int -1` 隐式转换为 `def`；将 `def` 存储到 `z`
	声明 `int i`；从 `z` 加载 → `def`；将 `def` 隐式转换为 `int -1`；对 `int -1` 取反 → `int 1`；将 `int 1` 存储到 `i`；

按位非

编辑

使用按位非运算符 '~' 对整型值的每个位取反，其中1-bit 将翻转为结果 0-bit，0-bit 将翻转为结果 1-bit。

错误

如果值是非整型类型。

位

原始	结果
1	0
0	1

语法

bitwise_not: '~' expression;

提升

原始	提升后的
byte	int
short	int
char	int
int	int
long	long
def	def

示例

使用不同数值类型的按位非。

byte b = 1;  
int i = ~b;  
long l = ~i;

	声明 `byte x`；将 `byte 1` 存储到 b
	声明 `int i`；从 `b` 加载 → `byte 1`；将 `byte 1` 隐式转换为 `int 1` → `int 1`；对 `int 1` 进行按位非 → `int -2`；将 `int -2` 存储到 `i`
	声明 `long l`；从 `i` 加载 → `int -2`；将 `int -2` 隐式转换为 `long -2` → `long -2`；对 `long -2` 进行按位非 → `long 1`；将 `long 1` 存储到 `l`

使用 def 类型的按位非。

def d = 1;  
def e = ~d;

	声明 `def d`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `d`；
	声明 `def e`；从 `d` 加载 → `def`；将 `def` 隐式转换为 `int 1` → `int 1`；对 `int 1` 进行按位非 → `int -2`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `e`

乘法

编辑

使用乘法运算符 '*'将两个数值类型的值相乘。结果溢出和 NaN 值的规则遵循 JVM 规范。

错误

如果任一值是非数值类型。

语法

multiplication: 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

示例

不同数值类型的乘法。

int i = 5*4;      
double d = i*7.0;

	声明 `int i`；将 `int 4` 乘以 `int 5` → `int 20`；将 `int 20` 存储到 `i` 中
	声明 `double d`；从 `int i` 加载 → `int 20`；提升 `int 20` 和 `double 7.0`：结果为 `double`；隐式转换 `int 20` 为 `double 20.0` → `double 20.0`；将 `double 20.0` 乘以 `double 7.0` → `double 140.0`；将 `double 140.0` 存储到 `d` 中

与 def 类型的乘法。

def x = 5*4; 
def y = x*2;

	声明 `def x`；将 `int 5` 乘以 `int 4` → `int 20`；隐式转换 `int 20` 为 `def` → `def`；将 `def` 存储到 `x` 中
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `int 20`；将 `int 20` 乘以 `int 2` → `int 40`；隐式转换 `int 40` 为 `def` → `def`；将 `def` 存储到 `y` 中

除法

编辑

使用除法运算符 '/'将一个数值类型的值除以另一个数值类型的值。NaN 值和除以零的规则遵循 JVM 规范。整数除法会丢弃结果值的余数。

错误

如果任一值是非数值类型。
如果左侧整数类型的值除以右侧值为 0 的整数类型的值。

语法

division: 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

示例

不同数值类型的除法。

int i = 29/4;     
double d = i/7.0;

	声明 `int i`；将 `int 29` 除以 `int 4` → `int 7`；将 `int 7` 存储到 `i` 中
	声明 `double d`；从 `int i` 加载 → `int 7`；提升 `int 7` 和 `double 7.0`：结果为 `double`；隐式转换 `int 7` 为 `double 7.0` → `double 7.0`；将 `double 7.0` 除以 `double 7.0` → `double 1.0`；将 `double 1.0` 存储到 `d` 中

与 def 类型的除法。

def x = 5/4; 
def y = x/2;

	声明 `def x`；将 `int 5` 除以 `int 4` → `int 1`；隐式转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `x` 中
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `int 1`；将 `int 1` 除以 `int 2` → `int 0`；隐式转换 `int 0` 为 `def` → `def`；将 `def` 存储到 `y` 中

余数

编辑

使用余数运算符 '%'计算两个数值类型值之间除法的余数。NaN 值和除以零的规则遵循 JVM 规范。

错误

如果任一值是非数值类型。

语法

remainder: 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

示例

不同数值类型的余数。

int i = 29%4;     
double d = i%7.0;

	声明 `int i`；计算 `int 29` 除以 `int 4` 的余数 → `int 1`；将 `int 7` 存储到 `i` 中 (此处应为int 1)
	声明 `double d`；从 `int i` 加载 → `int 1`；提升 `int 1` 和 `double 7.0`：结果为 `double`；隐式转换 `int 1` 为 `double 1.0` → `double 1.0`；计算 `double 1.0` 除以 `double 7.0` 的余数 → `double 1.0`；将 `double 1.0` 存储到 `d` 中

与 def 类型的余数。

def x = 5%4; 
def y = x%2;

	声明 `def x`；计算 `int 5` 除以 `int 4` 的余数 → `int 1`；隐式转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `x` 中
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `int 1`；计算 `int 1` 除以 `int 2` 的余数 → `int 1`；隐式转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `y` 中

加法

编辑

使用加法运算符 '+'将两个数值类型的值相加。结果溢出和 NaN 值的规则遵循 JVM 规范。

错误

如果任一值是非数值类型。

语法

addition: 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

示例

加法运算符与不同数值类型。

int i = 29+4;     
double d = i+7.0;

	声明 `int i`；将 `int 29` 和 `int 4` 相加 → `int 33`；将 `int 33` 存储到 `i` 中
	声明 `double d`；从 `int i` 加载 → `int 33`；提升 `int 33` 和 `double 7.0`：结果为 `double`；隐式转换 `int 33` 为 `double 33.0` → `double 33.0`；将 `double 33.0` 和 `double 7.0` 相加 → `double 40.0`；将 `double 40.0` 存储到 `d` 中

与 def 类型的加法。

def x = 5+4; 
def y = x+2;

	声明 `def x`；将 `int 5` 和 `int 4` 相加 → `int 9`；隐式转换 `int 9` 为 `def` → `def`；将 `def` 存储到 `x` 中
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `int 9`；将 `int 9` 和 `int 2` 相加 → `int 11`；隐式转换 `int 11` 为 `def` → `def`；将 `def` 存储到 `y` 中

减法

编辑

使用减法运算符 '-'从左侧数值类型的值中减去右侧数值类型的值。结果溢出和 NaN 值的规则遵循 JVM 规范。

错误

如果任一值是非数值类型。

语法

subtraction: 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

示例

不同数值类型的减法。

int i = 29-4;     
double d = i-7.5;

	声明 `int i`；从 `int 29` 中减去 `int 4` → `int 25`；将 `int 25` 存储到 `i` 中
	声明 `double d`；从 `int i` 加载 → `int 25`；提升 `int 25` 和 `double 7.5`：结果为 `double`；隐式转换 `int 25` 为 `double 25.0` → `double 25.0`；从 `double 25.0` 中减去 `double 7.5` → `double 17.5`；将 `double 17.5` 存储到 `d` 中 (原文例子有误)

与 def 类型的减法。

def x = 5-4; 
def y = x-2;

	声明 `def x`；从 `int 5` 中减去 `int 4` → `int 1`；隐式转换 `int 1` 为 `def` → `def`；将 `def` 存储到 `x` 中
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `int 1`；从 `int 1` 中减去 `int 2` → `int -1`；隐式转换 `int -1` 为 `def` → `def`；将 `def` 存储到 `y` 中

左移

编辑

使用左移运算符 '<<'将左侧整数类型值的低位比特向高位比特移动，移动距离由右侧整数类型值指定。

错误

如果任一值是非整型类型。
如果右侧值不能转换为 int 类型。

语法

left_shift: expression '<<' expression;

提升

左侧整数类型值将按照下表中指定的规则进行提升。右侧整数类型值始终隐式转换为 int 类型值，并截断为提升类型值的比特数。

原始	提升后的
byte	int
short	int
char	int
int	int
long	long
def	def

示例

不同整数类型的左移。

int i = 4 << 1;   
long l = i << 2L;

	声明 `int i`；将 `int 4` 左移 `int 1` 位 → `int 8`；将 `int 8` 存储到 `i` 中
	声明 `long l`；从 `int i` 加载 → `int 8`；隐式转换 `long 2` 为 `int 2` → `int 2`；将 `int 8` 左移 `int 2` 位 → `int 32`；隐式转换 `int 32` 为 `long 32` → `long 32`；将 `long 32` 存储到 `l` 中

与 def 类型的左移。

def x = 4 << 2; 
def y = x << 1;

	声明 `def x`；将 `int 4` 左移 `int 2` 位 → `int 16`；隐式转换 `int 16` 为 `def` → `def`；将 `def` 存储到 `x` 中
	声明 `def y`；从 `x` 加载到 `def`；隐式转换 `def` 为 `int 16`；将 `int 16` 左移 `int 1` 位 → `int 32`；隐式转换 `int 32` 为 `def` → `def`；将 `def` 存储到 `y`

右移运算符

编辑

使用 右移运算符 '>>' 将左侧整型值的更高位移到低位，移动距离由右侧整型值指定。左侧整型值最高位的值将被保留。

错误

如果任一值是非整型类型。
如果右侧值不能转换为 int 类型。

语法

right_shift: expression '>>' expression;

提升

左侧整数类型值将按照下表中指定的规则进行提升。右侧整数类型值始终隐式转换为 int 类型值，并截断为提升类型值的比特数。

原始	提升后的
byte	int
short	int
char	int
int	int
long	long
def	def

示例

不同整型类型的右移运算。

int i = 32 >> 1;  
long l = i >> 2L;

	声明 `int i`；将 `int 32` 右移 `int 1` 位 → `int 16`；将 `int 16` 存储到 `i`
	声明 `long l`；从 `int i` 加载到 `int 16`；隐式转换 `long 2` 为 `int 2` → `int 2`；将 `int 16` 右移 `int 2` 位 → `int 4`；隐式转换 `int 4` 为 `long 4` → `long 4`；将 `long 4` 存储到 `l`

使用 def 类型的右移运算。

def x = 16 >> 2; 
def y = x >> 1;

	声明 `def x`；将 `int 16` 右移 `int 2` 位 → `int 4`；隐式转换 `int 4` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载到 `def`；隐式转换 `def` 为 `int 4`；将 `int 4` 右移 `int 1` 位 → `int 2`；隐式转换 `int 2` 为 `def` → `def`；将 `def` 存储到 `y`

无符号右移运算符

编辑

使用 无符号右移运算符 '>>>' 将左侧整型值的更高位移到低位，移动距离由右侧整型值指定。左侧整型值最高位的值不会被保留。

错误

如果任一值是非整型类型。
如果右侧值不能转换为 int 类型。

语法

unsigned_right_shift: expression '>>>' expression;

提升

左侧整数类型值将按照下表中指定的规则进行提升。右侧整数类型值始终隐式转换为 int 类型值，并截断为提升类型值的比特数。

原始	提升后的
byte	int
short	int
char	int
int	int
long	long
def	def

示例

不同整型类型的无符号右移运算。

int i = -1 >>> 29; 
long l = i >>> 2L;

	声明 `int i`；将 `int -1` 无符号右移 `int 29` 位 → `int 7`；将 `int 7` 存储到 `i`
	声明 `long l`；从 `int i` 加载到 `int 7`；隐式转换 `long 2` 为 `int 2` → `int 2`；将 `int 7` 无符号右移 `int 2` 位 → `int 3`；隐式转换 `int 3` 为 `long 3` → `long 3`；将 `long 3` 存储到 `l`

使用 def 类型的无符号右移运算。

def x = 16 >>> 2; 
def y = x >>> 1;

	声明 `def x`；将 `int 16` 无符号右移 `int 2` 位 → `int 4`；隐式转换 `int 4` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载到 `def`；隐式转换 `def` 为 `int 4`；将 `int 4` 无符号右移 `int 1` 位 → `int 2`；隐式转换 `int 2` 为 `def` → `def`；将 `def` 存储到 `y`

按位与运算符

编辑

使用 按位与运算符 '&' 对两个整型值的每一位进行与运算，如果同一索引处的两个位都为 1，则结果位为 1，否则为 0。

错误

如果任一值是非整型类型。

位

	1	0
1	1	0
0	0	0

语法

bitwise_and: expression '&' expression;

提升

	byte	short	char	int	long	def
byte	int	int	int	int	long	def
short	int	int	int	int	long	def
char	int	int	int	int	long	def
int	int	int	int	int	long	def
long	long	long	long	long	long	def
def	def	def	def	def	def	def

示例

不同整型类型的按位与运算。

int i = 5 & 6;   
long l = i & 5L;

	声明 `int i`；`int 5` 与 `int 6` 按位与 → `int 4`；将 `int 4` 存储到 `i`
	声明 `long l`；从 `int i` 加载到 `int 4`；提升 `int 4` 和 `long 5`：结果为 `long`；隐式转换 `int 4` 为 `long 4` → `long 4`；`long 4` 与 `long 5` 按位与 → `long 4`；将 `long 4` 存储到 `l`

使用 def 类型的按位与运算。

def x = 15 & 6; 
def y = x & 5;

	声明 `def x`；`int 15` 与 `int 6` 按位与 → `int 6`；隐式转换 `int 6` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载到 `def`；隐式转换 `def` 为 `int 6`；`int 6` 与 `int 5` 按位与 → `int 4`；隐式转换 `int 4` 为 `def` → `def`；将 `def` 存储到 `y`

按位异或运算符

编辑

使用 按位异或运算符 '^' 对两个整型值的每一位进行异或运算，如果同一索引处一个位为 1，另一个位为 0，则结果位为 1，否则结果位为 0。

错误

如果任一值是非整型类型。

位

下表说明了两个位异或运算的结果位。

	1	0
1	0	1
0	1	0

语法

bitwise_xor: expression '^' expression;

提升

	byte	short	char	int	long	def
byte	int	int	int	int	long	def
short	int	int	int	int	long	def
char	int	int	int	int	long	def
int	int	int	int	int	long	def
long	long	long	long	long	long	def
def	def	def	def	def	def	def

示例

不同整型类型的按位异或运算。

int i = 5 ^ 6;   
long l = i ^ 5L;

	声明 `int i`；`int 5` 与 `int 6` 按位异或 → `int 3`；将 `int 3` 存储到 `i`
	声明 `long l`；从 `int i` 加载到 `int 4`；提升 `int 3` 和 `long 5`：结果为 `long`；隐式转换 `int 3` 为 `long 3` → `long 3`；`long 3` 与 `long 5` 按位异或 → `long 6`；将 `long 6` 存储到 `l`

使用 def 类型的按位异或运算。

def x = 15 ^ 6; 
def y = x ^ 5;

	声明 `def x`；`int 15` 与 `int 6` 按位异或 → `int 9`；隐式转换 `int 9` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载到 `def`；隐式转换 `def` 为 `int 9`；`int 9` 与 `int 5` 按位异或 → `int 12`；隐式转换 `int 12` 为 `def` → `def`；将 `def` 存储到 `y`

按位或运算符

编辑

使用 按位或运算符 '|' 对两个整型值的每一位进行或运算，如果同一索引处至少一位为 1，则结果位为 1，否则结果位为 0。

错误

如果任一值是非整型类型。

位

下表说明了两个位或运算的结果位。

	1	0
1	1	1
0	1	0

语法

bitwise_or: expression '|' expression;

提升

	byte	short	char	int	long	def
byte	int	int	int	int	long	def
short	int	int	int	int	long	def
char	int	int	int	int	long	def
int	int	int	int	int	long	def
long	long	long	long	long	long	def
def	def	def	def	def	def	def

示例

不同整型类型的按位或运算。

int i = 5 | 6;   
long l = i | 8L;

	声明 `int i`；`int 5` 与 `int 6` 按位或 → `int 7`；将 `int 7` 存储到 `i`
	声明 `long l`；从 `int i` 加载到 `int 7`；提升 `int 7` 和 `long 8`：结果为 `long`；隐式转换 `int 7` 为 `long 7` → `long 7`；`long 7` 与 `long 8` 按位或 → `long 15`；将 `long 15` 存储到 `l`

使用 def 类型的按位或运算。

def x = 5 ^ 6; 
def y = x ^ 8;

	声明 `def x`；`int 5` 与 `int 6` 按位或 → `int 7`；隐式转换 `int 7` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载到 `def`；隐式转换 `def` 为 `int 7`；`int 7` 与 `int 8` 按位或 → `int 15`；隐式转换 `int 15` 为 `def` → `def`；将 `def` 存储到 `y`

« 运算符：常规运算符：布尔 »