Alter the control flow of your programs with conditional statements. Learn how "if-then-else" statements give you power over which portions of your code will run.

Conditionals and Control Flow

Imagine we're writing a program that enrolls students in courses. 

- *If* a student has completed the prerequisites, *then* they can enroll in a course.
- *Else*, they need to take the prerequisite courses.

They can't take Physics II without finishing Physics I.

We represent this kind of decision-making in our program using [_conditional_](https://www.codecademy.com/resources/docs/java/conditionals?page_ref=catalog) or _control flow_ statements. Before this point, our code runs line-by-line from the top down, but conditional statements allow us to be selective in which portions will run. 

Conditional statements check a `boolean` condition and run a _block_ of code depending on the condition. Curly braces mark the scope of a conditional block similar to a method or class.

Here's a complete conditional statement:

```java
if (true) {

  System.out.println("Hello World!");

}
``` 

If the condition is `true`, then the block is run. So `Hello World!` is printed. 

But suppose the condition is different:

```java
if (false) {

  System.out.println("Hello World!");

}
```

If the condition is `false`, then the block does not run.

This code is also called _if-then_ statements: "If `(condition)` is `true`, then do something".


Introduction to Control Flow

An alternative to chaining if-then-else conditions together is to use the [`switch`](https://www.codecademy.com/resources/docs/java/switch?page_ref=catalog) statement. This conditional will check a given value against any number of conditions and run the code block where there is a match.

Here's an example of our course selection conditional as a `switch` statement instead:

```java
String course = "History";

switch (course) {
  case "Algebra": 
    // Enroll in Algebra
    break; 
  case "Biology": 
    // Enroll in Biology
    break;
  case "History": 
    // Enroll in History
    break;
  case "Theatre":
    // Enroll in Theatre
    break;
  default:
    System.out.println("Course not found");
}
```

This example enrolls the student in History class by checking the value contained in the parentheses, `course`, against each of the `case` labels. If the value after the case label matches the value within the parentheses, the _switch block_ is run.

In the above example, `course` references the string `"History"`, which matches `case "History":`.

When no value matches, the `default` block runs. Think of this as the `else` equivalent.

Switch blocks are different than other code blocks because they are not marked by curly braces and we use the `break` keyword to exit the switch statement. 

Without `break`, code below the matching `case` label is run, *including code under other case labels*, which is rarely the desired behavior.

```java
String course = "Biology";

switch (course) {
  case "Algebra": 
    // Enroll in Algebra
  case "Biology": 
    // Enroll in Biology
  case "History": 
    // Enroll in History
  case "Theatre":
    // Enroll in Theatre
  default:
    System.out.println("Course not found");
}

// enrolls student in Biology... AND History and Theatre!
```


Switch Statement

We've seen how to conditionally execute one block of code, but what if there are two possible blocks of code we'd like to execute? 

Let's say *if* a student has the required prerequisite, *then* they enroll in the selected course, *else* they're enrolled in the prerequisite course instead. 

We create an alternate conditional branch with the `else` keyword:

```java
if (hasPrerequisite) {

  // Enroll in course

} else {

  // Enroll in prerequisite

}
```

This conditional statement ensures that exactly one code block will be run. If the condition, `hasPrerequisite`, is `false`, the block after `else` runs.

There are now two separate code blocks in our conditional statement. The first block runs if the condition evaluates to `true`, the second block runs if the condition evaluates to `false`.

This code is also called an _if-then-else_ statement:

- If _condition_ is true, then do something.
- Else, do a different thing.


If-Then-Else

We can create more complex conditional structures by creating _nested conditional statements_, which is created by placing conditional statements inside other conditional statements:

```pseudo
if (outer condition) {
  if (nested condition) {
    Instruction to execute if both conditions are true
  }
}
```
When we implement nested conditional statements, the outer statement is evaluated first. If the outer condition is `true`, then the inner, nested statement is evaluated. 

Let's create a program that helps us decide what to wear based on the weather:
```java
int temp = 45;
boolean raining = true;

if (temp < 60) {
  System.out.println("Wear a jacket!");
  if (raining == true) {
    System.out.println("Bring your umbrella.");
  } else {
    System.out.println("Leave your umbrella home.");
  }
}
```

In the code snippet above, our compiler will check the condition in the first `if-then` statement: `temp < 60`. Since `temp` has a value of `45`, this condition is `true`; therefore, our program will print `Wear a jacket!`. 

Then, we'll evaluate the condition of the nested `if-then` statement: `raining == true`. This condition is also `true`, so `Bring your umbrella` is also printed to the screen. 

Note that, if the first condition was `false`, the nested condition would not be evaluated.

Nested Conditional Statements

Before this lesson, our code executed from top to bottom, line by line. 

Conditional statements add branching paths to our programs. We use conditionals to make decisions in the program so that different inputs will produce different results.

Conditionals have the general structure:

```java
if (condition) {
    // consequent path
} else {
    // alternative path
}
```

Specific conditional statements have the following behavior:

* `if-then`:
  * code block runs if condition is true
* `if-then-else`:
  * one block runs if conditions is true
  * another block runs if condition is false
* `if-then-else` chained:
  * same as `if-then` but an arbitrary number of conditions
* `switch`:
  * switch block runs if condition value matches `case` value


Review

The *if-then* statement is the most simple control flow we can write. It tests an expression for truth and executes some code based on it.

```java
if (flip == 1) {

  System.out.println("Heads!");

}
```

- The `if` keyword marks the beginning of the conditional statement, followed by parentheses `()`.
- The parentheses hold a `boolean` datatype. 

For the condition in parentheses we can also use variables that reference a boolean, or comparisons that evaluate to a boolean. 

The boolean condition is followed by opening and closing curly braces that mark a block of code. This block runs if, and only if, the boolean is `true`.

```java
boolean isValidPassword = true;

if (isValidPassword) {

  System.out.println("Password accepted!");

}

// Prints "Password accepted!"

int numberOfItemsInCart = 9;

if (numberOfItemsInCart > 12) {

  System.out.println("Express checkout not available");

}

// Nothing is printed.
```

If a conditional is brief we can omit the curly braces entirely:

```java
if (true) System.out.println("Brevity is the soul of wit");
```

**Note:** Conditional statements do not end in a semicolon. 


If-Then Statement

The conditional structure we've learned can be chained together to check as many conditions as are required by our program. 

Imagine our program is now selecting the appropriate course for a student. We'll check their submission to find the correct course enrollment.

The conditional statement now has multiple conditions that are evaluated from the top down:

```java
String course = "Theatre";

if (course.equals("Biology")) {

  // Enroll in Biology course

} else if (course.equals("Algebra")) {

  // Enroll in Algebra course

} else if (course.equals("Theatre")) {

  // Enroll in Theatre course

} else {

  System.out.println("Course not found!");

}
```

**The first**  condition to evaluate to `true` will have that code block run. Here's an example demonstrating the order:

```java
int testScore = 72;

if (testScore >= 90) {

  System.out.println("A");

} else if (testScore >= 80) {

  System.out.println("B");

} else if (testScore >= 70) {

  System.out.println("C");

} else if (testScore >= 60) {

  System.out.println("D");

} else {

  System.out.println("F");

}
// prints: C
```

This chained conditional statement has two conditions that evaluate `true`. Because `testScore >= 70` comes before `testScore >= 60`, only the earlier code block is run.

**Note:** Only one of the code blocks will run.
