› ›

运算符：数值

运算符：数值编辑

后置递增编辑

使用 后置递增运算符 '++' 将数值类型变量/字段的值增加 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 位 翻转为结果 0 位，0 位 翻转为结果 1 位。

错误

如果该值是非整数类型。

位

原始	结果
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` 中
	声明 `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 33.0` 中减去 `double 7.5` → `double 25.5`；将 `double 25.5` 存储到 `d`

使用 def 类型的减法。

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

	声明 `def x`；从 `int 4` 中减去 `int 5` → `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`

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