逻辑运算符

    (短路与) && (逻辑与)&

    (短路或)|| (逻辑或)|

    (逻辑非)!

    (异或操作)^

(短路与) && (逻辑与)&

(短路与) &&

&&具有短路功能,当&&左边表达式为false的时候,直接判断整个&&运算结果为false,&&右边不再进行计算(两个表达式都为真,才是true。有一个为假则都是(false)假)

boolean num = true && true;
		 System.out.println("true && true:"+num); //结果为true

		 boolean num1 = true && false;
		 System.out.println("true && false:"+num1);//结果为false

		 boolean num2 = false && true;
		 System.out.println("false && true:"+num2);//结果为false

		 boolean num3 = false && false;
		 System.out.println("false &&false:"+num3);//结果为false

/*先运算左边的表达式,在运算右边的表达式。
  如果左边的表达式运算为false,则结束运算不在参与右边的表达式运算,结果为:false。
  如果左边的表达式运算为true,右边的表达式运算也为true,结果为true,反之右边的运算结果为false,则结果为false

*/
int a = 5;
		 int b= 10;
		 boolean bool1 = (a>=b)&&(a>b);
		 System.out.println("bool1:"+bool1);//结果为false
		 System.out.println(a);
// 表达式(a<=b):a大于或等于b,满足a等于b的条件,所以只要有一个条件满足,则结果为真(true),两个都不满足则为假(false)
//表达式(a>b):a大于b,不满足为假(false)
//两个表达式有一个为假,最终结果为假

 (逻辑与)&

&不具有短路功能,不管&左边表达式的结果为true还是false,&右边表达式都要进行计算(两个表达式都为真,才是true。有一个为假则都是(false)假) 

boolean num4 = true & true;
		 System.out.println("true & true:"+num4);//结果为true

		 boolean num5 = true & false;
		 System.out.println("true & false:"+num5);//结果为false

		 boolean num6 = false & true;
		 System.out.println("false & true:"+num6);//结果为false

		 boolean num7 = false & false;
		 System.out.println("false & false:"+num7);//结果为false
/*先运算左边的表达式,在运算右边的表达式。
  如果左边的表达式运算为false,则结束运算不在参与右边的表达式运算,结果为:false。
  如果左边的表达式运算为true,右边的表达式运算也为true,结果为true,反之右边的运算结果为false,则结果为false

*/
两个表达式都为真(true),则最终结果为true
两个表达式都为假(false),则最终结果为false
两个表达式有一个为假(false),则最终结果为false
int a = 5;
		 int b= 10;
		 boolean bool1 = (a<b)&(a>b);
		 System.out.println("bool1:"+bool1);//结果为false
		 System.out.println(a);
//表达式1(a<b) 为true ; 表达式2(a>b)  为false
//两个表达式有一个为false,所以结果为false

 (短路或)||、(逻辑或)|

          (短路或)||

||具有短路功能,当||左边表达式为true的时候,直接判断整个||运算结果为true,||右边不再进行计算(两个表达式有一个为真(true),则为真)

// true || true-->true
			boolean result1 = true || true;
			System.out.println("true||true:" + result1);//结果为true

			// true || false-->true
			boolean result2 = true || false;
			System.out.println("true||false:" + result2);//结果为true

			// false || true-->true
			boolean result3 = false || true;
			System.out.println("false||true:" + result3);//结果为true

			// false || false-->false
			boolean result4 = false || false;
			System.out.println("false||false:" + result4);//结果为false

   两个表达式中有一个为true,则结果为true
   两个表达式都为false,则结果为false
byte a = 10;
		 int b = 20;
		 boolean size = (a<b) || (a!=b);
		 System.out.println("size:"+size);
 表达式2的结果为真(true),所以最终结果为true

 (逻辑或)|

|不具有短路功能,不管|左边表达式的结果为true还是false,|右边表达式都要进行计算

boolean result5 = true | true;
			System.out.println("true|true:" + result5);//true

			// true | false-->true
			boolean result6 = true | false;
			System.out.println("true|false:" + result6);//true

			// false | true-->true
			boolean result7 = false | true;
			System.out.println("false|true:" + result7);//true

			// false | false-->false
			boolean result8 = false | false;
			System.out.println("false|false:" + result8);//false

表达式1不论真(true)、假(false),表达式2都要进行运算。两个表达式有一个为真(true),
  其结果都为true

(逻辑非)!

操作数为true,结果为false
操作数为false,结果为true

int a = 5;
			 int b = 3;
			 boolean max = a!=b;   //a非等于b,就是a不等于b
			 System.out.println("max:"+max);
//boolean为布尔类型,其值为:true、false
//所以这段代码最终结果为(真)true

^(异或): 

     操作:前后一样返回false,前后不一样返回true

三元运算符 

 语法形式:
关系表达式(条件) ? 表达式1 :表达式2
运算过程:
如果布尔表达式的值为 true ,则返回 表达式1 的值,否则返回 表达式2 的值。

int num1 = 100;
		 int num2 = 200;
		 int bool1 = num1 < num2 ? num1 : num2;
		 System.out.println(bool1);

 int bool1 = (条件)num1 < num2 ? (表达式1)num1 : (表达式2)num2;
  条件:num1小于num2吗?小于就执行表达式1,否则执行表达式2

嵌套条件(三元)运算符

语法:

条件1 ? (条件2 ? 表达式1 : 表达式2):(条件3 ? 表达式3 : 表达式4)

int a = 20;
		 int b = 30;
		 int c = 10;
		 int max = a>b?(a>c?a:c):(b>c?b:c);
		 System.out.println("最大:"+max);
		 
		 int tiny = a<b?(a<c?a:c):(b<c?b:c);
		 System.out.println("最小:"+tiny);


 int max = a>b? (a>c?a:c) : (b>c?b:c);
/*
  1、先运算两个括号里的结果。
  2、括号1为:a ;括号2为:b
  3、 int max = a>b? a:b;//问a大于b吗?不大于那就执行第二个,那max的变量值就是b(30)
*/