/*
A: What are logical operators
& With (and), | or (OR),! (non), ^ (XOR),
Logic Double and && (short circuit and), logic double or | | (Short circuit or)
Precautions:
A: Logical operators are typically used to concatenate expressions or values of type Boolean.
In Java we want to represent a number greater than 3 and less than 6, can not be written 3<x<6, should be written x>3 & X<6.
B: Expression: It is the Java syntax that joins a constant or variable with an operator.
Arithmetic expression: A + b
Comparison expression: a = = b
Assignment expression: int a = 10
What is a Boolean-type expression?
Is that the result of an expression is a Boolean type.
Comparison expressions
Conclusion
&: False on both sides as long as there is a positive result
False if False
|: Both sides as long as true result must be true
True if True
^: The same on both sides is false different is true
Same-sex repulsion, heterosexual phase suction (magnet relationship)
!: Non-(not)
False if not true
True if not false
An even number of non-obtained results for a value is itself
*/
Class operatordemo{public static void main (String[] args) {int a = 3;int b = 4;int c = 5; // & Usage : And //the left and right sides of a Boolean-type value or expression System.out.println ((a>b) & (a>c));//false & false = false system.out.println ((A >B) & (A<c);//false & true = falsesystem.out.println (a< b) & (A>C);//true & false = falsesystem.out.println (A<B) & (A<c));//true & true = true system.out.println ("-------------------------------------------------------");//| or, or meaning has true trueSystem.out.println ((a>b) | ( A>C));//false | false = false system.out.println ((a>b) | ( A<C));//false | true = truesystem.out.println ((a<b) | ( A>C));//true | false = truesystem.out.println ((a<b) | ( A<C));//true | true = truesystem.out.println ("----------------- --------------------------------------");//^ xor same as false different for trueSystem.out.println ( (a>b) ^ (a>c));//false ^ false = false system.out.println ((a>b) ^ (a<c));//false ^ true = TrueSystem.out.println ((a<b) ^ (a>c));//true ^ false = TrueSystem.out.println ((a<b) ^ (a<c));//true ^ true = FalseSystem.out.println ("-------------------------------------------------------"); //Logic non-!&NBSP;&NBSP;SYSTEM.OUT.PRINTLN (! A>B));//!FALSE&NBSP;=&NBSP;TRUE&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;SYSTEM.OUT.PRINTLN (!! (a>b)); /!! FALSE&NBSP;=&NBSP;!TRUE&NBSP;=&NBSP;FALSE&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;&NBSP;SYSTEM.OUT.PRINTLN (!!! (a>b)); /true}}
/*
The difference between logic double and && and logic and &
Common && in Development | |
The logical operator joins a Boolean type of
&: False if False
A: As A result
b:&& with short circuit effect
If you encounter false, the following formula is no longer executed
False to the left, not to the right.
&& Efficiency ratio & High
Common && in development
|| : After encountering true, the formula is no longer executed
*/
Class operatordemo2{public static void main (String[] args) {/*int a = 3;int b = 4;int c = 5;//&& usage : and // Connecting the left and right values or expressions of type Boolean & && System.out.println ((a>b) && (a>c));//false && false = False system.out.println (a>b) && (a<c);//false && true = falsesystem.out.println ((a<b) && (a>c)); /true && false = falsesystem.out.println ((a<b) && (a <C));//true && true = true system.out.println ("-------------------------------------------------------") *///use on int x = 3;int y = 4;//& //system.out.println ((x++==3) & (y++==4));//true & True //system.out.println ("x:" +x);//4//System.out.println ("Y:" +y);//5//&& //system.out.println (x++==3) & & (Y++==4));//true & true // System.out.println ("x:" +x);//4//system.out.println ("Y:" +y);//5 & //system.out.println ((++x==3) & (y++==4));// false & true =false //x first self-added to 4 again do judgment The first result is false //continue to execute the right side of the symbol, first make a judgment, and then add The second result is true //system.out.println ("x:" +x);//4 //system.out.println ("Y: +y)//5 system.out.println ((++x==3) && (y++==4));//false & true =false // X self-add to 4 and then make a judgment the first result is false // && encounter false behind the will not execute, // does not execute the right side of the symbol//because you know logic with the conclusion there is false then false system.out.println ("x:" +x);//4 system.out.println ("Y:" +y);//4}}
This article from the "Clear Sky" blog, declined reprint!
Java logical operators