 Here's a program that determines your rebate based on the average amount of your purchases. It asks for the total amount you've purchased and the number of orders you've made. If the number of orders is greater than zero and the average purchase per order is greater than or equal to $30, congratulations, we calculate your rebate and tell you what it is. Otherwise, you don't get a rebate. Let's run this program with a total of $500 of purchases over 10 orders. That's $50 per order and we get a rebate. What happens if we run the program again and this time enters zero for the number of orders? Why did that work? Why didn't the program crash on this division? To answer this, we need to look at the truth table for and. When the first condition of an and is true, we need to look at the second condition to figure out what the result will be. But when the first condition is false, there's no need to look at the second condition. We know that the result must be false. Java compiles your code to take advantage of this. When we ran the program with 10 orders, our first condition, 10 greater than zero, was true. Java had to do the division to find out if the second condition, the average being greater than or equal to $30, was true or not. When we gave zero orders, zero is not greater than zero. The first condition came back as false, which meant Java didn't have to evaluate the second condition at all. The division never happened. That's why the program was able to complete successfully. This process of evaluating conditions only when necessary is sometimes referred to as short circuit evaluation. The OR operator also has short circuit evaluation. When the first condition is true, it doesn't matter what the second condition is. The answer must be true, and Java does not evaluate the second condition at all. It gets short circuited.