› ›

运算符：数值

后置递增

使用 后置递增运算符 '++' 将数值类型变量/字段的值增加 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 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`

« 运算符：通用运算符：布尔 »