› ›

运算符：布尔值

运算符：布尔值编辑

布尔非编辑

使用 布尔非运算符 '!' 对 布尔值 类型的值进行非运算，其中 true 变为 false，false 变为 true。

错误

如果给定的值不是 布尔值 类型的值，或者不能转换为 布尔值 类型的值。

真值

原始值	结果
true	false
false	true

语法

boolean_not: '!' expression;

示例

对 布尔值 类型进行布尔非运算。

boolean x = !false; 
boolean y = !x;

	声明 `布尔值 x`; 对 `布尔值 false` 进行布尔非运算 → `布尔值 true`; 将 `布尔值 true` 存储到 `x`
	声明 `布尔值 y`; 从 `x` 加载 → `布尔值 true`; 对 `布尔值 true` 进行布尔非运算 → `布尔值 false`; 将 `布尔值 false` 存储到 `y`

对 def 类型进行布尔非运算。

def y = true; 
def z = !y;

	声明 `def y`; 将 `布尔值 true` 隐式转换为 `def` → `def`; 将 `true` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `布尔值 true` → 布尔值 `true`; 对 `布尔值 true` 进行布尔非运算 → `布尔值 false`; 将 `布尔值 false` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`

大于编辑

使用 大于运算符 '>' 比较两个数值类型的值，如果左侧值大于右侧值，则结果为 布尔值 类型的 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

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

示例

不同数值类型的大于比较。

boolean x = 5 > 4; 
double y = 6.0;    
x = 6 > y;

	声明 `布尔值 x`; `int 5` 大于 `int 4` → `布尔值 true`; 将 `布尔值 true` 存储到 `x`;
	声明 `double y`; 将 `double 6.0` 存储到 `y`;
	从 `y` 加载 → `double 6.0 @0`; 将 `int 6` 和 `double 6.0` 提升类型：结果为 `double`; 将 `int 6` 隐式转换为 `double 6.0 @1` → `double 6.0 @1`; `double 6.0 @1` 大于 `double 6.0 @0` → `布尔值 false`; 将 `布尔值 false` 存储到 `x`

与 def 类型进行大于比较。

int x = 5;       
def y = 7.0;     
def z = y > 6.5; 
def a = x > y;

	声明 `int x`; 将 `int 5` 存储到 `x`
	声明 `def y`; 将 `double 7.0` 隐式转换为 `def` → `def`; 将 `def` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `double 7.0` → `double 7.0`; `double 7.0` 大于 `double 6.5` → `布尔值 true`; 将 `布尔值 true` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`
	声明 `def a`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `double 7.0` → `double 7.0`; 从 `x` 加载 → `int 5`; 将 `int 5` 和 `double 7.0` 提升类型：结果为 `double`; 将 `int 5` 隐式转换为 `double 5.0` → `double 5.0`; `double 5.0` 大于 `double 7.0` → `布尔值 false`; 将 `布尔值 false` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`

大于等于编辑

使用 大于等于运算符 '>=' 比较两个数值类型的值，如果左侧值大于等于右侧值，则结果为 布尔值 类型的 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

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

示例

不同数值类型的大于等于比较。

boolean x = 5 >= 4; 
double y = 6.0;     
x = 6 >= y;

	声明 `布尔值 x`; `int 5` 大于等于 `int 4` → `布尔值 true`; 将 `布尔值 true` 存储到 `x`
	声明 `double y`; 将 `double 6.0` 存储到 `y`
	从 `y` 加载 → `double 6.0 @0`; 将 `int 6` 和 `double 6.0` 提升类型：结果为 `double`; 将 `int 6` 隐式转换为 `double 6.0 @1` → `double 6.0 @1`; `double 6.0 @1` 大于等于 `double 6.0 @0` → `布尔值 true`; 将 `布尔值 true` 存储到 `x`

与 def 类型进行大于等于比较。

int x = 5;        
def y = 7.0;      
def z = y >= 7.0; 
def a = x >= y;

	声明 `int x`; 将 `int 5` 存储到 `x`;
	声明 `def y`; 将 `double 7.0` 隐式转换为 `def` → `def`; 将 `def` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `double 7.0 @0` → `double 7.0 @0`; `double 7.0 @0` 大于等于 `double 7.0 @1` → `布尔值 true`; 将 `布尔值 true` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`
	声明 `def a`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `double 7.0` → `double 7.0`; 从 `x` 加载 → `int 5`; 将 `int 5` 和 `double 7.0` 提升类型：结果为 `double`; 将 `int 5` 隐式转换为 `double 5.0` → `double 5.0`; `double 5.0` 大于等于 `double 7.0` → `布尔值 false`; 将 `布尔值 false` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`

小于编辑

使用 小于运算符 '<' 比较两个数值类型的值，如果左侧值小于右侧值，则结果为 布尔值 类型的 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

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

示例

不同数值类型的小于比较。

boolean x = 5 < 4; 
double y = 6.0;    
x = 6 < y;

	声明 `布尔值 x`; `int 5` 小于 `int 4` → `布尔值 false`; 将 `布尔值 false` 存储到 `x`
	声明 `double y`; 将 `double 6.0` 存储到 `y`
	从 `y` 加载 → `double 6.0 @0`; 将 `int 6` 和 `double 6.0` 提升类型：结果为 `double`; 将 `int 6` 隐式转换为 `double 6.0 @1` → `double 6.0 @1`; `double 6.0 @1` 小于 `double 6.0 @0` → `布尔值 false`; 将 `布尔值 false` 存储到 `x`

与 def 类型进行小于比较。

int x = 5;       
def y = 7.0;     
def z = y < 6.5; 
def a = x < y;

	声明 `int x`; 将 `int 5` 存储到 `x`
	声明 `def y`; 将 `double 7.0` 隐式转换为 `def` → `def`; 将 `def` 存储到 `y`
	声明 `def z`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `double 7.0` → `double 7.0`; `double 7.0` 小于 `double 6.5` → `布尔值 false`; 将 `布尔值 false` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`
	声明 `def a`; 从 `y` 加载 → `def`; 将 `def` 隐式转换为 `double 7.0` → `double 7.0`; 从 `x` 加载 → `int 5`; 将 `int 5` 和 `double 7.0` 提升类型：结果为 `double`; 将 `int 5` 隐式转换为 `double 5.0` → `double 5.0`; `double 5.0` 小于 `double 7.0` → `布尔值 true`; 将 `布尔值 true` 隐式转换为 `def` → `def`; 将 `def` 存储到 `z`

小于等于编辑

使用 小于等于运算符 '<=' 比较两个数值类型的值，如果左侧值小于等于右侧值，则结果为 布尔值 类型的 true，否则为 false。

错误

如果计算出的左侧值或右侧值是非数值。

语法

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

示例

不同数值类型的小于或等于。

boolean x = 5 <= 4; 
double y = 6.0;     
x = 6 <= y;

	声明 `boolean x`；小于或等于 `int 5` 和 `int 4` → `boolean false`；将 `boolean true` 存储到 `x`
	声明 `double y`; 将 `double 6.0` 存储到 `y`
	从 `y` 加载 → `double 6.0 @0`；提升 `int 6` 和 `double 6.0`：结果 `double`；隐式转换 `int 6` 为 `double 6.0 @1` → `double 6.0 @1`；小于或等于 `double 6.0 @1` 和 `double 6.0 @0` → `boolean true`；将 `boolean true` 存储到 `x`

使用 def 类型的小于或等于。

int x = 5;        
def y = 7.0;      
def z = y <= 7.0; 
def a = x <= y;

	声明 `int x`; 将 `int 5` 存储到 `x`;
	声明 `def y`；隐式转换 `double 7.0` 为 `def` → `def`；将 `def` 存储到 `y`；
	声明 `def z`；从 `y` 加载 → `def`；隐式转换 `def` 为 `double 7.0 @0` → `double 7.0 @0`；小于或等于 `double 7.0 @0` 和 `double 7.0 @1` → `boolean true`；隐式转换 `boolean true` 为 `def` → `def`；将 `def` 存储到 `z`
	声明 `def a`；从 `y` 加载 → `def`；隐式转换 `def` 为 `double 7.0` → `double 7.0`；从 `x` 加载 → `int 5`；提升 `int 5` 和 `double 7.0`：结果 `double`；隐式转换 `int 5` 为 `double 5.0` → `double 5.0`；小于或等于 `double 5.0` 和 `double 7.0` → `boolean true`；隐式转换 `boolean true` 为 `def` → `def`；将 `def` 存储到 `z`

实例运算符编辑

使用 instanceof 运算符 将变量/字段类型与指定的引用类型进行比较，使用引用类型名称，如果变量/字段类型与指定的引用类型相同或为其后代，则结果 boolean 类型值为 true，否则为 false。

错误

如果右侧指定的引用类型名称不存在。

语法

instance_of: ID 'instanceof' TYPE;

示例

不同引用类型的实例。

Map m = new HashMap();            
boolean a = m instanceof HashMap; 
boolean b = m instanceof Map;

	声明 `Map m`；分配 `HashMap` 实例 → `HashMap 引用`；隐式转换 `HashMap 引用` 为 `Map 引用`；将 `Map 引用` 存储到 `m`
	声明 `boolean a`；从 `m` 加载 → `Map 引用`；隐式转换 `Map 引用` 为 `HashMap 引用` → `HashMap 引用`；instanceof `HashMap 引用` 和 `HashMap` → `boolean true`；将 `boolean true` 存储到 `a`
	声明 `boolean b`；从 `m` 加载 → `Map 引用`；隐式转换 `Map 引用` 为 `HashMap 引用` → `HashMap 引用`；instanceof `HashMap 引用` 和 `Map` → `boolean true`；将 `true` 存储到 `b`；（注意 `HashMap` 是 `Map` 的后代）

使用 def 类型的实例。

def d = new ArrayList();       
boolean a = d instanceof List; 
boolean b = d instanceof Map;

	声明 `def d`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `def` → `def`；将 `def` 存储到 `d`
	声明 `boolean a`；从 `d` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；instanceof `ArrayList 引用` 和 `List` → `boolean true`；将 `boolean true` 存储到 `a`；（注意 `ArrayList` 是 `List` 的后代）
	声明 `boolean b`；从 `d` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；instanceof `ArrayList 引用` 和 `Map` → `boolean false`；将 `boolean false` 存储到 `a`；（注意 `ArrayList` 不是 `Map` 的后代）

相等运算符编辑

使用 相等运算符 '==' 比较两个值，如果两个值相等，则结果 boolean 类型值为 true，否则为 false。当值是引用类型值时，将隐式调用成员方法 equals，其中第一个值是调用的目标，第二个值是参数。此操作是空安全的，如果两个值都为 null，则结果 boolean 类型值为 true，如果只有一个值为 null，则结果 boolean 类型值为 false。有效的比较是在 boolean 类型值、数值类型值或引用类型值之间进行的。

错误

如果在 boolean 类型值和数值类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

equality_equals: expression '==' expression;

类型提升

	布尔值	byte	short	char	int	long	float	double	引用	def
布尔值	布尔值	-	-	-	-	-	-	-	-	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	def

示例

使用 boolean 类型的相等运算符。

boolean a = true;  
boolean b = false; 
a = a == false;    
b = a == b;

	声明 `boolean a`；将 `boolean true` 存储到 `a`
	声明 `boolean b`；将 `boolean false` 存储到 `b`
	从 `a` 加载 → `boolean true`；相等运算符 `boolean true` 和 `boolean false` → `boolean false`；将 `boolean false` 存储到 `a`
	从 `a` 加载 → `boolean false @0`；从 `b` 加载 → `boolean false @1`；相等运算符 `boolean false @0` 和 `boolean false @1` → `boolean false`；将 `boolean false` 存储到 `b`

使用原始类型的相等运算符。

int a = 1;          
double b = 2.0;     
boolean c = a == b; 
c = 1 == a;

	声明 `int a`；将 `int 1` 存储到 `a`
	声明 `double b`；将 `double 1.0` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `int 1`；从 `b` 加载 → `double 2.0`；提升 `int 1` 和 `double 2.0`：结果 `double`；隐式转换 `int 1` 为 `double 1.0` → double `1.0；相等运算符 `double 1.0` 和 `double 2.0` → `boolean false`；将 `boolean false` 存储到 `c`
	从 `a` 加载 → `int 1 @1`；相等运算符 `int 1 @0` 和 `int 1 @1` → `boolean true`；将 `boolean true` 存储到 `c`

使用引用类型的相等运算符。

List a = new ArrayList(); 
List b = new ArrayList(); 
a.add(1);                 
boolean c = a == b;       
b.add(1);                 
c = a == b;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；使用参数 (`int 1)` 在 `List 引用` 上调用 `add`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；使用参数 (`List 引用 @1`) 在 `List 引用 @0` 上调用 `equals` → `boolean false`；将 `boolean false` 存储到 `c`
	从 `b` 加载 → `List 引用`；使用参数 (`int 1`) 在 `List 引用` 上调用 `add`
	从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；使用参数 (`List 引用 @1`) 在 `List 引用 @0` 上调用 `equals` → `boolean true`；将 `boolean true` 存储到 `c`

使用 null 的相等运算符。

Object a = null;       
Object b = null;       
boolean c = a == null; 
c = a == b;            
b = new Object();      
c = a == b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；相等运算符 `null @0` 和 `null @1` → `boolean true`；将 `boolean true` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；相等比较 `null @0` 和 `null @1` → `布尔值 true`；将 `布尔值 true` 存储到 `c`
	分配 `Object` 实例 → `对象引用`；将 `对象引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；使用参数 (`null`) 调用 `对象引用` 上的 `equals` → `布尔值 false`；将 `布尔值 false` 存储到 `c`

使用 def 类型的相等比较。

def a = 0;               
def b = 1;               
boolean c = a == b;      
def d = new HashMap();   
def e = new ArrayList(); 
c = d == e;

	声明 `def a`；将 `int 0` 隐式转换为 `def` → `def`；将 `def` 存储到 `a`；
	声明 `def b`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `b`；
	声明 `boolean c`；从 `a` 加载 → `def`；将 `a` 隐式转换为 `int 0` → `int 0`；从 `b` 加载 → `def`；将 `b` 隐式转换为 `int 1` → `int 1`；相等比较 `int 0` 和 `int 1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；将 `HashMap 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`；
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；将 `ArrayList 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`；
	从 `d` 加载 → `def`；将 `def` 隐式转换为 `HashMap 引用` → `HashMap 引用`；从 `e` 加载 → `def`；将 `def` 隐式转换为 `ArrayList 引用` → `ArrayList 引用`；使用参数 (`ArrayList 引用`) 调用 `HashMap 引用` 上的 `equals` → `布尔值 false`；将 `布尔值 false` 存储到 `c`

不相等比较编辑

使用 不相等比较运算符 '!=' 比较两个值，如果两个值不相等，则结果 布尔值 类型值为 true，否则为 false。当值是引用类型值时，将隐式调用成员方法 equals，其中第一个值是调用的目标，第二个值是参数，结果 布尔值 类型值取反。此操作是 null 安全的，如果两个值都为 null，则结果 布尔值 类型值为 false，如果只有一个值为 null，则结果 布尔值 类型值为 true。有效的比较是在布尔类型值、数字类型值或引用类型值之间进行的。

错误

如果在 boolean 类型值和数值类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

equality_not_equals: expression '!=' expression;

类型提升

	布尔值	byte	short	char	int	long	float	double	引用	def
布尔值	布尔值	-	-	-	-	-	-	-	-	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	def

示例

使用 布尔值 类型的不相等比较。

boolean a = true;  
boolean b = false; 
a = a != false;    
b = a != b;

	声明 `boolean a`；将 `boolean true` 存储到 `a`
	声明 `boolean b`；将 `boolean false` 存储到 `b`
	从 `a` 加载 → `布尔值 true`；不相等比较 `布尔值 true` 和 `布尔值 false` → `布尔值 true`；将 `布尔值 true` 存储到 `a`
	从 `a` 加载 → `布尔值 true`；从 `b` 加载 → `布尔值 false`；不相等比较 `布尔值 true` 和 `布尔值 false` → `布尔值 true`；将 `布尔值 true` 存储到 `b`

使用基本类型的不相等比较。

int a = 1;          
double b = 2.0;     
boolean c = a != b; 
c = 1 != a;

	声明 `int a`；将 `int 1` 存储到 `a`
	声明 `double b`；将 `double 1.0` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `int 1`；从 `b` 加载 → `double 2.0`；提升 `int 1` 和 `double 2.0`：结果 `double`；将 `int 1` 隐式转换为 `double 1.0` → double `1.0；不相等比较 `double 1.0` 和 `double 2.0` → `布尔值 true`；将 `布尔值 true` 存储到 `c`
	从 `a` 加载 → `int 1 @1`；不相等比较 `int 1 @0` 和 `int 1 @1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`

使用引用类型的不相等比较。

List a = new ArrayList(); 
List b = new ArrayList(); 
a.add(1);                 
boolean c = a == b;       
b.add(1);                 
c = a == b;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；使用参数 (`int 1)` 在 `List 引用` 上调用 `add`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；使用参数 (`List 引用 @1`) 调用 `List 引用 @0` 上的 `equals` → `布尔值 false`；布尔值非 `布尔值 false` → `布尔值 true` 将 `布尔值 true` 存储到 `c`
	从 `b` 加载 → `List 引用`；使用参数 (`int 1`) 在 `List 引用` 上调用 `add`
	从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；使用参数 (`List 引用 @1`) 调用 `List 引用 @0` 上的 `equals` → `布尔值 true`；布尔值非 `布尔值 true` → `布尔值 false`；将 `布尔值 false` 存储到 `c`

使用 null 的不相等比较。

Object a = null;       
Object b = null;       
boolean c = a == null; 
c = a == b;            
b = new Object();      
c = a == b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；不相等比较 `null @0` 和 `null @1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；不相等比较 `null @0` 和 `null @1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	分配 `Object` 实例 → `对象引用`；将 `对象引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；使用参数 (`null`) 调用 `对象引用` 上的 `equals` → `布尔值 false`；布尔值非 `布尔值 false` → `布尔值 true`；将 `布尔值 true` 存储到 `c`

使用 def 类型的不相等比较。

def a = 0;               
def b = 1;               
boolean c = a == b;      
def d = new HashMap();   
def e = new ArrayList(); 
c = d == e;

	声明 `def a`；将 `int 0` 隐式转换为 `def` → `def`；将 `def` 存储到 `a`；
	声明 `def b`；将 `int 1` 隐式转换为 `def` → `def`；将 `def` 存储到 `b`；
	声明 `boolean c`；从 `a` 加载 → `def`；将 `a` 隐式转换为 `int 0` → `int 0`；从 `b` 加载 → `def`；将 `b` 隐式转换为 `int 1` → `int 1`；相等比较 `int 0` 和 `int 1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；将 `HashMap 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`；
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；将 `ArrayList 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`；
	从 `d` 加载 → `def`；将 `def` 隐式转换为 `HashMap 引用` → `HashMap 引用`；从 `e` 加载 → `def`；将 `def` 隐式转换为 `ArrayList 引用` → `ArrayList 引用`；使用参数 (`ArrayList 引用`) 调用 `HashMap 引用` 上的 `equals` → `布尔值 false`；将 `布尔值 false` 存储到 `c`

恒等比较编辑

使用 恒等比较运算符 '===' 比较两个值，如果两个值相等，则结果 布尔值 类型值为 true，否则为 false。如果两个引用类型值都引用堆上的同一个实例，或者两个值都为 null，则它们相等。有效的比较是在 布尔值 类型值、数字类型值或引用类型值之间进行的。

错误

如果在 boolean 类型值和数值类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

identity_equals: expression '===' expression;

类型提升

	布尔值	byte	short	char	int	long	float	double	引用	def
布尔值	布尔值	-	-	-	-	-	-	-	-	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	def

示例

使用引用类型的恒等比较。

List a = new ArrayList(); 
List b = new ArrayList(); 
List c = a;               
boolean c = a === b;      
c = a === c;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；将 `List 引用` 存储到 `c`
	声明 `boolean c`；从 `a` 加载 → `List 引用 @0`；从 `b` 加载 → `List 引用 @1`；恒等比较 `List 引用 @0` 和 `List 引用 @1` → `布尔值 false` 将 `布尔值 false` 存储到 `c`
	从 `a` 加载 → `List 引用 @0`；从 `c` 加载 → `List 引用 @1`；恒等比较 `List 引用 @0` 和 `List 引用 @1` → `布尔值 true` 将 `布尔值 true` 存储到 `c`（注意 `List 引用 @0` 和 `List 引用 @1` 引用同一个实例）

使用 null 的恒等比较。

Object a = null;        
Object b = null;        
boolean c = a === null; 
c = a === b;            
b = new Object();       
c = a === b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `boolean c`；从 `a` 加载 → `null @0`；恒等比较 `null @0` 和 `null @1` → `布尔值 true`；将 `布尔值 true` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；恒等比较 `null @0` 和 `null @1` → `布尔值 true`；将 `布尔值 true` 存储到 `c`
	分配 `Object` 实例 → `对象引用`；将 `对象引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；恒等比较 `对象引用` 和 `null` → `布尔值 false`；将 `布尔值 false` 存储到 `c`

使用 def 类型的恒等比较。

def a = new HashMap();   
def b = new ArrayList(); 
boolean c = a === b;     
b = a;                   
c = a === b;

	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；将 `HashMap 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；将 `ArrayList 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`
	声明 `boolean c`；从 `a` 加载 → `def`；将 `def` 隐式转换为 `HashMap 引用` → `HashMap 引用`；从 `b` 加载 → `def`；将 `def` 隐式转换为 `ArrayList 引用` → `ArrayList 引用`；恒等比较 `HashMap 引用` 和 `ArrayList 引用` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	从 `a` 加载 → `def`；将 `def` 存储到 `b`
	从 `a` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用 @0` → `HashMap 引用 @0`；从 `b` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用 @1` → `HashMap 引用 @1`；恒等式比较 `HashMap 引用 @0` 和 `HashMap 引用 @1` → `布尔值 true`；将 `布尔值 true` 存储到 `b`；（注意 `HashMap 引用 @0` 和 `HashMap 引用 @1` 指的是同一个实例）

恒等式不等于运算符编辑

使用 恒等式不等于运算符 '!==' 来比较两个值，如果两个值不相等，则结果 布尔值 为 true，否则为 false。如果两个引用类型值引用堆上的不同实例，或者一个值为 null 而另一个值不是，则这两个值不相等。有效的比较是在 布尔值 类型值、数字类型值或引用类型值之间进行的。

错误

如果在 boolean 类型值和数值类型值之间进行比较。
如果在原始类型值和引用类型值之间进行比较。

语法

identity_not_equals: expression '!==' expression;

类型提升

	布尔值	byte	short	char	int	long	float	double	引用	def
布尔值	布尔值	-	-	-	-	-	-	-	-	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	def

示例

引用类型值的恒等式不等于。

List a = new ArrayList(); 
List b = new ArrayList(); 
List c = a;               
boolean c = a !== b;      
c = a !== c;

	声明 `List a`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `a`
	声明 `List b`；分配 `ArrayList` 实例 → `ArrayList 引用`；隐式转换 `ArrayList 引用` 为 `List 引用` → `List 引用`；将 `List 引用` 存储到 `b`
	从 `a` 加载 → `List 引用`；将 `List 引用` 存储到 `c`
	声明 `布尔值 c`；从 `a` 加载 → `列表引用 @0`；从 `b` 加载 → `列表引用 @1`；恒等式不等于 `列表引用 @0` 和 `列表引用 @1` → `布尔值 true` 将 `布尔值 true` 存储到 `c`
	从 `a` 加载 → `列表引用 @0`；从 `c` 加载 → `列表引用 @1`；恒等式不等于 `列表引用 @0` 和 `列表引用 @1` → `布尔值 false` 将 `布尔值 false` 存储到 `c` （注意 `列表引用 @0` 和 `列表引用 @1` 指的是同一个实例）

与 null 的恒等式不等于。

Object a = null;        
Object b = null;        
boolean c = a !== null; 
c = a !== b;            
b = new Object();       
c = a !== b;

	声明 `Object a`；将 `null` 存储到 `a`
	声明 `Object b`；将 `null` 存储到 `b`
	声明 `布尔值 c`；从 `a` 加载 → `null @0`；恒等式不等于 `null @0` 和 `null @1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	从 `a` 加载 → `null @0`；从 `b` 加载 → `null @1`；恒等式不等于 `null @0` 和 `null @1` → `布尔值 false`；将 `布尔值 false` 存储到 `c`
	分配 `Object` 实例 → `对象引用`；将 `对象引用` 存储到 `b`
	从 `a` 加载 → `对象引用`；从 `b` 加载 → `null`；恒等式不等于 `对象引用` 和 `null` → `布尔值 true`；将 `布尔值 true` 存储到 `c`

与 def 类型的恒等式不等于。

def a = new HashMap();   
def b = new ArrayList(); 
boolean c = a !== b;     
b = a;                   
c = a !== b;

	声明 `def d`；分配 `HashMap` 实例 → `HashMap 引用`；将 `HashMap 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`
	声明 `def e`；分配 `ArrayList` 实例 → `ArrayList 引用`；将 `ArrayList 引用` 隐式转换为 `def` → `def` 将 `def` 存储到 `d`
	声明 `布尔值 c`；从 `a` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用` → `HashMap 引用`；从 `b` 加载 → `def`；隐式转换 `def` 为 `ArrayList 引用` → `ArrayList 引用`；恒等式不等于 `HashMap 引用` 和 `ArrayList 引用` → `布尔值 true`；将 `布尔值 true` 存储到 `c`
	从 `a` 加载 → `def`；将 `def` 存储到 `b`
	从 `a` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用 @0` → `HashMap 引用 @0`；从 `b` 加载 → `def`；隐式转换 `def` 为 `HashMap 引用 @1` → `HashMap 引用 @1`；恒等式不等于 `HashMap 引用 @0` 和 `HashMap 引用 @1` → `布尔值 false`；将 `布尔值 false` 存储到 `b`；（注意 `HashMap 引用 @0` 和 `HashMap 引用 @1` 指的是同一个实例）

布尔异或编辑

使用 布尔异或运算符 '^' 对两个 布尔值 类型值进行异或运算，如果一个 布尔值 类型值为 true，而另一个为 false，则结果 布尔值 类型值为 true，否则为 false。

错误

如果任何一个被评估的值不是 布尔值 类型值，或者不是可以转换为 布尔值 类型值的值。

真值

	true	false
true	false	true
false	true	false

语法

boolean_xor: expression '^' expression;

示例

使用 布尔值 类型进行布尔异或运算。

boolean x = false;    
boolean y = x ^ true; 
y = y ^ x;

	声明 `布尔值 x`；将 `布尔值 false` 存储到 `x`
	声明 `布尔值 y`；从 `x` 加载 → `布尔值 false` 布尔异或 `布尔值 false` 和 `布尔值 true` → `布尔值 true`；将 `布尔值 true` 存储到 `y`
	从 `y` 加载 → `布尔值 true @0`；从 `x` 加载 → `布尔值 true @1`；布尔异或 `布尔值 true @0` 和 `布尔值 true @1` → `布尔值 false`；将 `布尔值 false` 存储到 `y`

使用 def 类型进行布尔异或运算。

def x = false;    
def y = x ^ true; 
y = y ^ x;

	声明 `def x`；隐式转换 `布尔值 false` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `布尔值 false` → `布尔值 false`；布尔异或 `布尔值 false` 和 `布尔值 true` → `布尔值 true`；隐式转换 `布尔值 true` 为 `def` → `def`；将 `def` 存储到 `y`
	从 `y` 加载 → `def`；隐式转换 `def` 为 `布尔值 true @0` → `布尔值 true @0`；从 `x` 加载 → `def`；隐式转换 `def` 为 `布尔值 true @1` → `布尔值 true @1`；布尔异或 `布尔值 true @0` 和 `布尔值 true @1` → `布尔值 false`；隐式转换 `布尔值 false` → `def`；将 `def` 存储到 `y`

布尔与编辑

使用 布尔与运算符 '&&' 对两个 布尔值 类型值进行与运算，如果两个 布尔值 类型值都为 true，则结果 布尔值 类型值为 true，否则为 false。

错误

如果任何一个被评估的值不是 布尔值 类型值，或者不是可以转换为 布尔值 类型值的值。

真值

	true	false
true	true	false
false	false	false

语法

boolean_and: expression '&&' expression;

示例

使用 布尔值 类型进行布尔与运算。

boolean x = true;      
boolean y = x && true; 
x = false;             
y = y && x;

	声明 `布尔值 x`；将 `布尔值 true` 存储到 `x`
	声明 `布尔值 y`；从 `x` 加载 → `布尔值 true @0`；布尔与 `布尔值 true @0` 和 `布尔值 true @1` → `布尔值 true`；将 `布尔值 true` 存储到 `y`
	将 `布尔值 false` 存储到 `x`
	从 `y` 加载 → `布尔值 true`；从 `x` 加载 → `布尔值 false`；布尔与 `布尔值 true` 和 `布尔值 false` → `布尔值 false`；将 `布尔值 false` 存储到 `y`

使用 def 类型进行布尔与运算。

def x = true;      
def y = x && true; 
x = false;         
y = y && x;

	声明 `def x`；隐式转换 `布尔值 true` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `布尔值 true @0` → `布尔值 true @0`；布尔与 `布尔值 true @0` 和 `布尔值 true @1` → `布尔值 true`；隐式转换 `布尔值 true` 为 `def` → `def`；将 `def` 存储到 `y`
	隐式转换 `布尔值 false` 为 `def` → `def`；将 `def` 存储到 `x`；
	从 `y` 加载 → `def`；隐式转换 `def` 为 `布尔值 true` → `布尔值 true`；从 `x` 加载 → `def`；隐式转换 `def` 为 `布尔值 false` → `布尔值 false`；布尔与 `布尔值 true` 和 `布尔值 false` → `布尔值 false`；隐式转换 `布尔值 false` → `def`；将 `def` 存储到 `y`

布尔或编辑

使用 布尔或运算符 '||' 对两个 布尔值 类型值进行或运算，如果两个 布尔值 类型值中有一个为 true，则结果 布尔值 类型值为 true，否则为 false。

错误

如果任何一个被评估的值不是 布尔值 类型值，或者不是可以转换为 布尔值 类型值的值。

真值

	true	false
true	true	true
false	true	false

语法

boolean_and: expression '||' expression;

示例

使用 布尔值 类型进行布尔或运算。

boolean x = false;     
boolean y = x || true; 
y = false;             
y = y || x;

	声明 `布尔值 x`；将 `布尔值 false` 存储到 `x`
	声明 `布尔值 y`；从 `x` 加载 → `布尔值 false`；布尔或 `布尔值 false` 和 `布尔值 true` → `布尔值 true`；将 `布尔值 true` 存储到 `y`
	将 `布尔值 false` 存储到 `y`
	从 `y` 加载 → `布尔值 false @0`；从 `x` 加载 → `布尔值 false @1`；布尔或 `布尔值 false @0` 和 `布尔值 false @1` → `布尔值 false`；将 `布尔值 false` 存储到 `y`

使用 def 类型进行布尔或运算。

def x = false;     
def y = x || true; 
y = false;         
y = y || x;

	声明 `def x`；隐式转换 `布尔值 false` 为 `def` → `def`；将 `def` 存储到 `x`
	声明 `def y`；从 `x` 加载 → `def`；隐式转换 `def` 为 `布尔值 false` → `布尔值 true`；布尔或 `布尔值 false` 和 `布尔值 true` → `布尔值 true`；隐式转换 `布尔值 true` 为 `def` → `def`；将 `def` 存储到 `y`
	隐式转换 `布尔值 false` 为 `def` → `def`；将 `def` 存储到 `y`；
	从 `y` 加载 → `def`；隐式转换 `def` 为 `boolean false @0` → `boolean false @0`；从 `x` 加载 → `def`；隐式转换 `def` 为 `boolean false @1` → `boolean false @1`；布尔或运算 `boolean false @0` 和 `boolean false @1` → `boolean false`；隐式转换 `boolean false` → `def`；存储 `def` 到 `y`

« 运算符：数值运算符：引用 »