"Greetings, Amigo! I was so carried away by solving logic problems that I didn't notice you come in. Here's one for you: if crocodiles fly, then snow is white. There's a flying crocodile. What's the conclusion?"

"Um... So we conclude that snow is white?"

"Excellent! You passed the initiation test. You are ready to master the next topic. It is called 'logical operators'. And we'll start with Boolean logic. Instinctively, you already know it. You're a robot, after all. We just need to tweak your settings to match the Java language."

"Boolean logic? I was recently told about the boolean type..."

"Yes, there's a direct connection here. Boolean expressions can only be true or false. And as it happens, this sort of logic is all about expressions that are true or false, and combinations of such expressions. For example, the expression 18 < 25 is always true, and 7 < 5 is always false. The expression (i < 10) depends on the value of i. And if the expression evaluates, for example, to true, then we can ask the program to do something."

"Ahh, I get it. Boolean expressions allow us not only to make logical conclusions, but also to create forks in programs."

"Exactly. The main thing is to learn how to write them. For example, in Java you can't just go and write the expression 18 < age <65. This would be syntactically incorrect and the program will not compile.

"But you can write it like this:

            (18 < age) AND (age < 65)

Of course, we don't actually use the ENGLISH word AND. Instead, you need a boolean operator. That is, 'AND' is represented differently.

"There are three logical operators in Java: AND (&&), OR (||), NOT (!).

The good news is that you can use parentheses to construct logical expressions of any complexity.

The bad news is that Java developers decided to use notation from the C language instead of the words and, or and not.

Look at the screen:

Logical operator Expectation Reality
AND (∧) and &&
OR (∨) or ||
NOT (¬) not !

"It's actually not that bad... Pretty compact. I've almost memorized them."

"Well, that's marvelous. Here are some examples of using logical operators in Java:

Expression Interpretation Explanation
(0 < a) && (a < 100) (0 < a) and (a < 100) (0 < a) AND (a < 100)
(!a) && (!b) (not a) and (not b) (NOT a) AND (NOT b)
!(!a || !b) not((not a) or (not b)) NOT((NOT a) OR (NOT b))

Examples of using comparison operators and boolean variables

"Remember, Amigo, wherever you can write a logical expression, you can write a logical variable."

"How's that?"

"I mean you can write logical expressions in different ways. For instance:

Code Explanation
int age = 35;
if (age >= 18 && age <= 65)
   System.out.println("You can work");
If the value of age is between 18 and 65, then the phrase "You can work" is displayed.
int age = 35;
boolean isYoung = (age < 18);
if (!isYoung && age <= 65)
   System.out.println("You can work");
We created an isYoung variable and moved the first part of the expression into it. We simply replaced age >= 18 with age < 18.
int age = 35;
boolean isYoung = (age < 18);
boolean isOld = (age > 65);
if (!isYoung && !isOld)
   System.out.println("You can work");
We created an isOld variable and moved the second part of the expression into it. Additionally, age <= 65 was replaced by age > 65.

"These three examples are equivalent. Only in the second example did we move part of the expression from the if statement into a separate boolean variable (isYoung). In the third example, we moved the second part of the expression into a second variable (isOld). By the way, the default value of a boolean variable is false."

"I will remember that. I hope."

Logical arithmetic

"Now let's briefly go through logical operations. They obey very simple and logical (how could it be otherwise!) rules.

"First, let's see how the OR operator works. It's also known as || or disjunction.

Expression Result
true || true true
true || false true
false || true true
false || false false

"Can you deduce now what the result of the expression a || b is based on the table?"

"I see!" The value of an expression is true if at least one term in the expression is true. If both are false, then the result is false.

"That's correct. Since you're so smart, take another look at the table and imagine that false is 0 and true is 1. When you look at it that way, does the || operator's behavior remind you of anything from ordinary arithmetic?"

"Um... Well, it's a bit like addition... But when you do addition, 1 + 1 does not equal 1."

"There is a sense in which it is equal if we are only working with 0 and 1. But don't bother with that right now. The important thing is that you noticed the similarity between the || operation and addition. This means you won't be surprised by the fact that this operation is often called 'logical addition'.

"Got it."

"Now the AND, aka &&, aka conjunction operator, comes onto the stage.

Expression Result
true && true true
true && false false
false && true false
false && false false

"As I understand it, the result of an expression is true only if both values that make up the expression are true. Otherwise, it is always false."

"Well done, Amigo! You're absorbing all this like a sponge. Do you see another similarity with arithmetic?"


"Exactly. So here we have a 'logical multiplication'".

"Next we look at the NOT operator, aka !, aka the logical inverse.

Expression Result
!true false
!false true

"Well, everything is quite simple here. The operator changes true to false and vice versa."

"Exactly. Here are some useful expressions for you:"

Expression Result
m && !m false
m || !m true
!(a && b) !a || !b
!(a || b) !a && !b