Learn about the boolean operators in Java that can simplify your code. You'll practice using logical AND, OR, and NOT to create more concise conditional statements.

Conditional Operators

The  _unary_ operator NOT, `!`, works on a **single** value. This operator evaluates to the opposite boolean to which it's applied:

```java
!false
// true
!true
// false
```

NOT is useful for expressing our intent clearly in programs. For example, sometimes we need the opposite behavior of an `if-then`: run a code block **only if** the condition is `false`.

```java
boolean hasPrerequisite = false;

if (hasPrerequisite) {
  // do nothing
} else {
  System.out.println("Must complete prerequisite course!");
}
```

This code does what we want but it's strange to have a code block that does nothing!

The logical NOT operator cleans up our example:


```java
boolean hasPrerequisite = false;

if (!hasPrerequisite) {
  System.out.println("Must complete prerequisite course!");
}
```

We can write a succinct conditional statement without an empty code block.


Logical NOT: !

Let's return to our student enrollment program. We've added an additional requirement: not only must students have the prerequisite, but their tuition must be paid up as well. We have *two* conditions that must be `true` before we enroll the student. 

Here's one way we could write the code:

```java
if (tuitionPaid) {
  if (hasPrerequisite) {
    // enroll student
  }
}
```

We've nested two `if-then` statements. This does the job but we can be more concise with the _AND_ operator:

```java
if (tuitionPaid && hasPrerequisite) {
  // enroll student
}
```

The  AND operator, `&&`, is used between two boolean values and evaluates to a single boolean value. If the values **on both sides** are `true`, then the resulting value is `true`, otherwise the resulting value is `false`. 

This code illustrates every combination:

```java
true && true
// true
false && true
// false
true && false
// false
false && false
// false
```


Conditional-And: &&

Java includes operators that only use boolean values. These _conditional operators_ help simplify expressions containing complex boolean relationships by reducing multiple boolean values to a single value: `true` or `false`.

For example, what if we want to run a code block only if *multiple* conditions are true. We could use the _AND_ operator: `&&`.

Or, we want to run a code block if *at least one* of two conditions are `true`. We could use the _OR_ operator: `||`.

Finally, we can produce the opposite value, where `true` becomes `false` and `false` becomes `true`, with the _NOT_ operator: `!`.

Understanding these complex relationships can feel overwhelming at first. Luckily, _truth tables_, like the ones seen to the right, can assist us in determining the relationship between two boolean-based conditions.

In this lesson, we'll explore each of these conditional operators to see how they can be implemented into our conditional statements. 


Three truth tables are displayed: AND, OR, and NOT

Each truth table is divided into three columns. The first column shows the true or false value of 'a'. The second column shows the true or false value of 'b'. The third c.olumn shows a true or false value that represents the relationship between 'a' and 'b'.

Introduction to Conditional Operators

The requirements of our enrollment program have changed again. Certain courses have prerequisites that are satisfied by multiple courses. As long as students have taken **at least one** prerequisite, they should be allowed to enroll.

Here's one way we could write the code:

```java
if (hasAlgebraPrerequisite) {
  // Enroll in course
}

if (hasGeometryPrerequisite) {
  // Enroll in course
}
```

We're using two different `if-then` statements with **the same code block**. We can be more concise with the _OR_ operator:

```java
if (hasAlgebraPrerequisite || hasGeometryPrerequisite) {
  // Enroll in course
}
```

The OR operator, `||`, is used between two boolean values and evaluates to a single boolean value. If **either of the two values** is `true`, then the resulting value is `true`, otherwise the resulting value is `false`. 

This code illustrates every combination:

```java
true || true
// true
false || true
// true
true || false
// true
false || false
// false
```
**Keep Reading: AP Computer Science A Students**

On some occasions, the compiler can determine the truth value of a logical expression by only evaluating the first `boolean` operand; this is known as _short-circuited evaluation_. Short-circuited evaluation only works with expressions that use `&&` or `||`. 

In an expression that uses `||`, the resulting value will be `true` as long as one of the operands has a `true` value. If the first operand of an expression is `true`, we don't need to see what the value of the other operand is to know that the final value will also be `true`.

For example, we can run the following code without error despite dividing a number by `0` in the second operand because the first operand had a `true` value:
```java
if (1 > 0 || 2 / 0 == 7) {
  System.out.println("No errors here!");
}
```
An expression that uses `&&` will only result in `true` if both operands are `true`. If the first operand in the expression is `false`, the entire value will be `false`.



Conditional-Or: ||

Conditional operators work on boolean values to simplify our code. They're often combined with conditional statements to consolidate the branching logic.

Conditional-AND, `&&`, evaluates to `true` if the booleans on *both sides* are `true`.

```java
if (true && false) {
  System.out.println("You won't see me print!");
} else if (true && true) {
  System.out.println("You will see me print!");
}
```

Conditional-OR, `||`, evaluates to `true` if one or both of the booleans on either side is `true`.

```java
if (false || false) {
  System.out.println("You won't see me print!");
} else if (false || true) {
  System.out.println("You will see me print!");
}
```

Logical-NOT, `!`, evaluates to the opposite boolean value to which it is applied.

```java
if (!false) {
  System.out.println("You will see me print!");
}
```


Review

We have the ability to expand our boolean expressions by using multiple conditional operators in a single expression.

For example:
```java
boolean foo = true && !(false || !true)
```
How does an expression like this get evaluated by the compiler? The order of evaluation when it comes to conditional operators is as follows:
1. Conditions placed in parentheses - `()`
2. NOT - `!`
3. AND - `&&`
4. OR - `||`

Using this information, let's dissect the expression above to find the value of `foo`:
```java
true && !(false || !true)
```
First, we'll evaluate `(false || !true`) because it is enclosed within parentheses. Following the order of evaluation, we will evaluate `!true`, which equals `false`:
```java
true && !(false || false)
```
Then, we'll evaluate `(false || false)` which equals `false`. Now our expression looks like this: 
```java
true && !false
```
Next, we'll evaluate `!false` because it uses the NOT operator. This expression equals `true` making our expression the following:
```java
true && true
```
`true && true` evaluates to `true`; therefore, the value of `foo` is `true`.
