Java之逻辑运算符

文章目录

• 逻辑运算符
• • 1. 介绍
  • 2. 逻辑运算符一览
  • 3. && 和 & 基本规则
  • 4. && 和 & 案例演示
  • 5. || 和 | 基本规则
  • 6. || 和 | 案例演示
  • 7. || 和 | 使用区别
  • 8. ! 取反 基本规则
  • 9. ! 案例演示
  • 10. ^ 异或 案例演示
  • 11. 练习 1
  • 11. 练习 2

逻辑运算符

1. 介绍

• 用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。

2. 逻辑运算符一览

• 分为两组学习

1. 短路与 && ， 短路或 ||，取反 !
2. 逻辑与 &，逻辑或 |，^ 逻辑异或
   

• 说明逻辑运算规则：

1. a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false
2. a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
3. a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 t
4. a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
5. !a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true
6. a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为

3. && 和 & 基本规则

名称	语法	特点
短路与&&	条件1&&条件2	两个条件都为 true，结果为 true,否则 false
逻辑与&	条件1&条件2	两个条件都为 true，结果为 true,否则 false

4. && 和 & 案例演示

• 案例演示&& 和 & 运算符的使用(LogicOperator01.java)

	//&&短路与  和 &逻辑与 案例演示
	int age = 50;
	if(age > 20 && age < 90) {
	    System.out.println("ok100");
	}
	
	//&逻辑与使用
	if(age > 20 & age < 90) {
	    System.out.println("ok200");
	}

	//区别
	int a = 4;
	int b = 9;
	//对于&&短路与而言，如果第一个条件为false ,后面的条件不再判断
	if(a < 1 && ++b < 50) {
	   System.out.println("ok300");
	}
	System.out.println("a=" + a + " b=" + b);// 4 9

	//对于&逻辑与而言，如果第一个条件为false ,后面的条件仍然会判断
	if(a < 1 & ++b < 50) {
	    System.out.println("ok300");
	}
	System.out.println("a=" + a + " b=" + b);// 4 10

5. || 和 | 基本规则

名称	语法	特点
短路或 ||	条件1||条件2	两个条件中只要有一个成立，结果为true，否则为false
逻辑或 |	条件1|条件2	只要有一个条件成立，结果为true，否则为false

6. || 和 | 案例演示

• 案例演示&& || 运算符的使用(LogicOperator02.java)。

	 //||短路或  和 |逻辑或 案例演示
	 //|| 规则: 两个条件中只要有一个成立，结果为true,否则为false
	 //| 规则: 两个条件中只要有一个成立，结果为true,否则为false
	int age = 50;
	if(age > 20 || age < 30) {
	    System.out.println("ok100");
	}
	
	//逻辑或| 的使用
	if(age > 20 | age < 30) {
	    System.out.println("ok200");
	}

• 逻辑或 | 和 短路或 || 区别：

	//看看两者的区别
	//(1) ||短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高
	int a = 4;
	int b = 9;
	if( a > 1 || ++b > 4) { 
	   System.out.println("ok300");
	}
	System.out.println("a=" + a + " b=" + b); //4 9

//(2) |逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
	int a = 4;
	int b = 9;
	if( a > 1 || ++b > 4) { 
	   System.out.println("ok300");
	}
	System.out.println("a=" + a + " b=" + b); //4 10

7. || 和 | 使用区别

1. ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
2. | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
3. 开发中，我们基本使用 ||

8. ! 取反 基本规则

名称	语法	特点
! 非（取反）	! 条件	如果条件本身成立,结果为false,否则为true

9. ! 案例演示

• 案例演示 ! 和^案例演示运算符的使用(InverseOperator.java)

	//! 操作是取反 T->F  , F -> T
	System.out.println(60 > 20); //T
	System.out.println(!(60 > 20)); //F
	
	//a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为true, 否则为false
	boolean b = (10 > 1) ^ ( 3 > 5);
	System.out.println("b=" + b);//T

10. ^ 异或 案例演示

• a^b: ^叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

System.out.println( (4 < 1) ^ (6 > 3) ); // True

11. 练习 1

1. 分析：if条件中，x先比较后自增，所以x++==6为false，此时 x 自增后为 6。++y 是先自增再比较，此时 y = 6 ，比较的结果为 true。最后if条件的结果为 false

	int x = 5;
	int y = 5;
	if (x++==6 & ++y==6){
	    x = 11;
	}
	System.out.println("x="+x+",y"+y);

• 所以最后结果为 x = 6，y = 6
  

2. 分析：if条件中x先比较后自增，x++==6 为 false，x自增后为 6 。因为是短路与&&，所以后面的++y==6 不会再执行。最后if条件的结果为 false

	int x = 5,y = 5;
	if (x++==6 && ++y==6){
	    x = 11;
	}
	System.out.println("x="+x+",y="+y);

• 所以最后结果 x = 6，y = 5
  

3. 分析：if条件中 x++==5 中 x先比较再自增，所以x++==5 为 true，因为为 逻辑或 | ，所以后面的判断要执行。++y==5中y先自增再比较，此时y = 6，所以 ++y==5 结果为false。最后if条件的结果为 true，就要执行 x = 11

	int x = 5,y = 5;
	if (x++==5 | ++y==5){
	    x = 11;
	}
	System.out.println("x="+x+",y="+y);

• 所以最后结果 x = 11，y = 6
  

4. 分析：if条件中，x++==5 中，x先比较再自增，此时 x++==5 的结果为 true，x 比较完成后自增为 6. 因为是短路或 || ，所以后面的判断不会执行。最后if条件的结果为 true，就要执行 x = 11

	int x = 5,y = 5;
	if (x++==5 || ++y==5){
	    x = 11;
	}
	System.out.println("x="+x+",y="+y);
	}

• 所以最后结果 x = 11，y = 5
  

11. 练习 2

• 分析：

1. 第一个if条件中， z为先判断后自增，所以 z++==46 为 true，此时 z = 47。y = true 是把 true 赋值给 y，此时 y = true，所以 y = true 的判断结果为 true。最后if条件的结果为 true，就要执行 z++，此时 z = 48
2. 第二个if条件中，false 赋值为 x ，此时x=false的判断结果为 false，因为短路或 || ，前面的条件为 false，所以后面的条件也要执行。++z==49中，z先自增再判断，所以 x = 49。最后if条件的结果为 true，就要执行 z++，此时 z = 50

	boolean x = true;
	boolean y = false;
	short z = 46;
	if ((z++==46) && (y = true)) z++;
	if ((x=false) || (++z==49)) z++;
	System.out.println("z="+z);

• 所以最后结果 z = 50