if statements

Objective #1: Use if statements.

• When decisions are made in a computer program, they are simply the result of a computation in which the final result is either true or false. Computer programs do not have intuition or "gut feelings"; they simply make thousands of yes-or-no-like decisions at blinding speeds. The computer programmer must set up these decisions within the algorithm of a computer program to achieve the desired results. Selection statements (also known as decision statements) are used in computer programming languages to allow the programmer to do this. Like most computer languages, Java includes if statements as one kind of selection statement. Another selection statement is the switch statement (which is similar to Select Case in Visual Basic).
  
  
• Practically all computer languages have some sort of if statement. An if statement is a one-way selection statement. Here is an example of an if statement:

  if (number == 3)
  {
     System.out.println("The value of number is 3");
     System.out.println("Goodbye");
  }

• All if statements contain a control expression to determine if the statements in the body of the if statement execute or not. In the example above, (number == 3) is the control expression. The control expression must be placed in a set of parentheses. If the control expression is true then the statements in the body of the if statement execute. If the control expression is false, then the statements in the body of the if statement are not executed.
  
  
• When there is only one statement in the body of an if statement, curly braces are optional according to the compiler. When an if statement is typed without curly braces, the compiler treats the next individual statement in the computer program to be in the body of the if statement. However, according to our Coding Standards, you must use curly braces around the body of every if statement even if there is only one statement in its body. If you use the following statement in a program assignment for this class, you will lose points for not including curly braces even though the statement would not cause compile errors.
  
  if (num > 10)
     System.out.println(num + " is greater than 10");
  
  You would also lose points for typing the following one-line if statement even though it would cause no compile error:
  
  if (num > 10) System.out.println(num + " is greater than 10");
  
  These Coding Standards style rules are stressed so that beginner programmers develop safe habits and good style. In the following code segment

  if (num > 0)
      System.out.println("num is positive");
      System.out.println("num is not zero");

  the body of the if statement is only considered to be the first System.out.println statement according to the Java compiler. The second statement would execute even if num is equal to zero. The indentation of the second statement has no effect on the way the compiler interprets this code.

• Avoid the following common mistakes that are made with if statements:

  Always use the "double equals" symbol (i.e. comparison operator) rather than the assignment operator in control expressions. For example,

  int num = 5;

  if (num == 5)
  {
     System.out.println("hello world");
  }

  would display "hello world". However, the code segment

  int num = 5;

  if (num = 5)
  {
     System.out.println("hello world");
  }

  would cause a compile error.

  Avoid using an unnecessary semicolon after a control expression:

  if (num > 0);
  {
     System.out.println("num is positive");
  } 

  which would cause the phrase "num is positive" to be displayed even if num is negative since the body of the if statement would be considered empty.

Objective #2: Be able to use the if else statement.

• The if else statement is a two-way selection statement since either the block of code after the "if" part will be executed or the block of code after the "else" part will be executed. An if else statement is a two-way selection statement.
• The "if" part is executed if the control expression is TRUE while the "else" part is executed if the "if" part is false, guaranteeing one part of the expression to be executed or the other.
• Example:

  if (number < 0)
  {
          System.out.println("The number is negative.");
  }
  else
  {
          System.out.println("The number is zero or positive.");
  }

• Don't forget to include boundary cases when you code control expressions. That is, be sure to use <= or >= instead of < or >, respectively, when necessary.
• You can use an if else if statement as well. The else clause is optional just as it is with an if statement. Example:
  
  if (number > 10)
  {
     System.out.println(number + " is greater than 10.");
  }
  else if (number <= 9 && number >= 6)
  {
     System.out.println(number + " is greater than 5 and less than 10.");
  }
  else
  {
     System.out.println(number + "must be less than 6.");
  }
  
• According to our Coding Standards, you must include one blank line above an if or an if else statement and one blank line below it for good style and readability.
  
  In this example, the if statement "stands out" and is easy to read.
  
  int num = 5;
  
  if (num > 0)
  {
     System.out.println(num + " is greater than 0");
  }
  
  System.out.println("Goodbye");
  
  In this example, the code "runs together" and isn't very easy to read. You will lose points if you submit assignments that do not include blank lines around if statements or other structures such as loops, functions, and switch statements.
  
  int num = 5;
  if (num > 0)
  {
     System.out.println(num + " is greater than 0");
  }
  System.out.println("Goodbye");

Objective #3: Be able to use and interpret nested if statements.

• if statements and if else statements can be nested within one another in order to model complex decision structures. Be sure to use the braces and semicolons properly when coding such structures. Also, be sure to rigorously check the logic of your algorithm since it is quite easy to overlook possible errors.
  
• Example:
  
  The if statement that tests for divisibility by 5 is located inside of the if statement that tests for divisibility by 3 therefore it is considered to be a nested if statement.
  
  if (number % 3 == 0)
  {
          System.out.println(number + " is divisible by 3.");
  
          if (number % 5 == 0)
          {
                  System.out.println(number + " is divisible by 3 and 5.");
          }
  
  }
  
  Notice the blank lines around the inner if statement for good style.
  
  
  
• Avoid making the dangling else error with nested if statements like this
  
  if (num >= 0)
     if (num <= 10)
        System.out.println("num is between 0 and 10");
  else
     System.out.println("num is less than 0");
  
  where the phrase "num is less than 0" displays if num is greater than 10 not if num is less than 0. The else clause binds with the nested if statement not the outer if statement despite the indentation. The programmer should use curly braces with the outer if statement to correct this logic mistake
  
  if (num >= 0)
  {
     if (num <= 10)
        System.out.println("num is between 0 and 10");
  }
  else
     System.out.println("num is less than 0");
  
  Here is another tricky dangling else logic error:
  
  grade = 75;
  if (grade >= 80)
     if (grade >= 90)
        System.out.println("A or B");
  else
     System.out.println("C or less");
  
  In this example, the programmer may think that the phrase "C or less" prints but actually no output will be printed. The else clause binds with the nested if statement not the outer if statement. The indentation that is used has no bearing on the way the compiler interprets this dangling else. The code would be interpreted the same way if it were typed with no indentation as in
  
  grade = 75;
  if (grade >= 80)
  if (grade >= 90)
  System.out.println("A or B");
  else
  System.out.println("C or less");
  
  Of course, for style and readability, the code should have been typed with at least one set of curly braces as in:
  
  grade = 75;
  
  if (grade >= 80)
  {
     if (grade >= 90)
        System.out.println("A or B");
  }
  else
     System.out.println("C or less");
  
  
• Blocks of code define variable scope. A variable declared within a set of curly braces can only be used within that set of curly braces. This goes for the body of methods but if statements and loops, which we will study later, as well. In this code segment
  
  int num = 5;
  if (num > 0)
  {
     int otherNum = 3;
  }
  System.out.println(otherNum);
  
  a "cannot resolve symbol" compile error is generated since otherNum cannot be used outside of the curly braces of the if statement.

Objective #4: Use Boolean expressions with relational (comparison) and logical (Boolean) operators.

• Every if statement must have a control expression which in turn uses a Boolean expression that evaluates to either true or false. A simple example of a Boolean expression is (price < 10.00) where price is a variable. If price is equal to the value 8.34, then the Boolean expression as a whole would be considered to be true since 8.34 is indeed less than 10.00. Relational and logical operators are used in Boolean expressions.

• Relational operators (also called comparison operators) include:

==      equal to     NOTE: this is two equals symbols next to each other, not to be confused with the assignment operator, =
>        greater than
<        less than
>=      greater than or equal to
<=      less than or equal to
!=       not equal to

• Be careful not to use the assignment operator ( = ) instead of the "double equals" comparison operator in if statement control expressions. The following statement would cause an "incompatible types" compile error since == should be used instead of =
  
  if (num = 1)
  {
     System.out.println("num is " + num);
  }
  
  Since the value 1 is being assigned to num and not being compared to num and since the value 1 is not treated as a boolean value according to Java, the if statement cannot be executed.
  
  However the following illogical if statement would compile without errors
  
  boolean userWantsToQuit = false;
  
  if (userWantsToQuit = true)
  {
     System.out.println("user wants to quit");
  }
  
  and furthermore it would print the output message even though the flag variable userWantsToQuit was meant to be false. Since the assignment operator is being used in the if statement's control expression, the variable userWantsToQuit is being changed to true. Because true is a legitimate boolean expression, Java will then be able to execute the if statement.
  
  Therefore, it is considered safer style to type the following version of the if statement which is acceptable in Java
  
  if (userWantsToQuit)
  {
     System.out.println("user wants to quit");
  }
  
  
• When complex decisions must be coded into an algorithm, it may be necessary to "chain together" a few Boolean expressions into a compound Boolean expressions.   This is done with logical operators (also called Boolean operators) which include:
  

  &&        is the logical AND             operator
  ||            is the logical OR             operator
  !            is the logical NOT            operator
  

• You must use logical operators to join Boolean expressions into compound Boolean expressions. The following syntax is invalid:
  
  if (0 < number < 10)
  {
        System.out.println(number + " is greater than 0 but less than 10.");
  }
  
  and so is the expression
  
  if (number > 0 && < 10)
  {
        System.out.println(number + " is greater than 0 but less than 10.");
  }
  
  Rather the following syntax must be used:
  
  if (0 < number && number < 10)
  {
        System.out.println(number + " is greater than 0 but less than 10.");
  }
  
• Use this truth table to determine the results of the logical operators. In this table, 1 represents true and 0 represents false.
  
  

  A	B	A && B	A || B
  0	0	0	0
  0	1	0	1
  1	0	0	1
  1	1	1	1

  
  
  Notice that the && (And) logical operation is similar to mathematical multiplication since 0 * 0 = 0, 0 * 1 = 0, etc.
  Notice that the Or (Or) logical operation is similar to mathematical addition since 0 + 0 = 0, 0 + 1 = 1, etc.
  
  With the ! (Not) operator, if A is 0 then !A is 1 and vice versa.
  
  
• Logical operators may be mixed within evaluation statements but you must abide by their precedence rules (aka order of operations):   
  
                  NOT operator (!), AND operator (&&), OR operator (||)
  
  You must remember that the && operation is always performed before the || operation because && is similar to multiplication in normal arithmetic while || is similar to addition.
  
  
• Short-circuit evaluation (also known as lazy evaluation) allows the compiler to quickly evaluate a logical expression in some cases without having to completely evaluate each part of the expression.

Example:   
int a = 0, b = 1, c = 2;

if (2 * b - c > 5 && Math.PI / Math.pow(2, 0) > 3 && c + 2 * c / a > 0 || a < b)
{
   System.out.println("true");
}
else
{
   System.out.println("false");
}

The compiler evaluates the whole control expression to be true without even evaluating the left side of the || operator. Since a < b is true and since the || is the last operation according to the order of operations, the whole expression is considered to be true. Notice that the division by 0 (a = 0) would normally cause a run-time error but since that part of the expression is never evaluated, the error is avoided.

Some compilers and languages support short-circuit evaluation and some do not. When short-circuit evaluation is supported, it allows efficient programmers to rearrange control expressions in an order that saves a little bit of time and thus speeds up the program. In this example, since Dumb Johnny and Lazy Joe are the weakest students, their expressions are placed in the control expression before Smart Sally's.

if (dumbJohnnysGrade > 60 && lazyJoesGrade > 60 && smartSallysGrade > 60)
{
   System.out.println("Everyone in the class gets a candy bar"):
}
else
{
   System.out.println("No one gets a candy bar");
}


• The following Boolean expressions (that could be as the control expression of an if statement) have the resulting value of true assuming that the integer variables a, b, & c have a = 1, b = 2, & c = 3.
  
  (a < 2)
  (a + 1 == b)
  (a <= b && b < c)
  (b < a || b < c)
  (0 > b || b > 0 && b > 1)
  (a > 0)
  
  
• The following control expressions have the resulting value of false assuming that the integer variables a, b, & c have the values a = 1, b = 2, & c
  
  (a > 1)
  (b == 1)
  (a > 0 && a < -9)
  (a > 0 + 4)
  
  
• The complete order of operations including all of the arithmetic, relational, and logical operators including all of the basic arithmetic, relational, & logical operators is:
  
  *, /, %
  +, -
  <, >, <=, >=, ==, !=
  !
  &&
  ||
  
  
• DeMorgan's Law can be used to simplify some complicated compound Boolean expressions. DeMorgan's Law states that you can rewrite the expression
  
  Not (A And B)     As      Not A Or Not B
  
  You can also rewrite
  
  Not (A Or B) as Not A And Not B
  
  Here is an actual example,
  
  if (!(age > 12 && age < 20))
     System.out.println("You are not a teenager");
  
  could be rewritten as
  
  if (!(age > 12) || !(age < 20))
     System.out.println("You are not a teenager");
  
  which could be simplified further to
  
  if (age <= 12 || age >= 20)
     System.out.println("You are not a teenager");
  
  There are other Boolean algebra identities worth using to simplify complicated expressions such as
  
  !!(A) = A
  A || !A = true
  A && !A = false
  A && A = A
  A || A = A
  !(A && B) = !A || !B (DeMorgan's Law)
  !(A || B) = !A && !B (DeMorgan's Law)
  A && (B || C) = A && B || A && C
  A || false = A
  A || true = true
  A && false = false
  A && true = A
  A || !A && B = A || B
  A && (A || B) = A
  (A || B) && (A || C) = A || B && C
  (A || B) && (C || D) = A && C || A && D || B && C || B && D
  (A || B) && (A && B) = A && B (Minich's Law - with help of 2009-10 Per 7 students)
  
  
  
• Two Boolean expressions are equivalent if they are both true under the same exact inputs and they are both false under the same inputs similar to how the mathematical expressions (2 + 2)x and 4x are equivalent since for all values of x, the expressions evaluate to the same output. You should be able to use a truth chart to determine whether two Boolean expressions are equivalent or not. Consider the Java control expression
  
  (num > 0 && (!(sum < 100) || num > 0) || num > 0)
  
  which can be rewritten in Boolean algebra as
  
  A && (!(B || A) || A)
  
  How would you solve the problem "Which of the following expressions is equivalent to A && (!(B || A) || A)?"
  A) A && B
  B) A || B && !A
  C) A
  D) none of the above
  
  You could use logic and brute force to analytically deduce and solve the question. Or, you would build a complete truth table where the columns are the partial steps that you would complete by following the order of operations:
  
  

  A	B	B || A	!(B || A)	(!(B || A) || A)	A && (!(B || A) || A)	A && B	A || B && !A	A
  0	0
  0	1
  1	0
  1	1

  
  
• A predicate method is a method whose purpose is to return a boolean value either true or false. For good style, you should use the prefix "is" in the name of a predicate method. For example, suppose you need a method in your Fish class that indicates whether a fish is hungry or not. A good name for the method would be isHungry.
  
  public boolean isHungry(int hunger)
  {
     if (hunger > 0)
     {
        return true;
     }
     return false;
  }
  
  Note that you should not use this if statement in the body of the method above since some compilers may return a warning or error message
  
     if (hunger > 0)
     {
        return true;
     }
     else
     {
        return false;
     }
  
  However, the following single statement could be used as the body of the method
  
  return hunger > 0;
  
  since the boolean expression hunger > 0 simplifies to either true or false and that boolean value could immediately be returned.
  
  
• The selection operator (also known as the ternary operator) can be used to create an assignment statement that is based on a conditional expression. The selection operator is the use of ? : in this format    control expression ? true value : false value
  
  char letter;
  int grade = 95;
  letter = grade >= 90 ? 'A' : 'B';
  System.out.println(letter);
  
  If the control expression    grade >= 90    is true then the value after the question mark 'A' is assigned to the variable letter. If    grade >= 90    is false then the value after the colon 'B' is assigned to the variable letter. Note that the statement could be rewritten as the following if else statement
  
  if (grade >= 90)
  {
     letter = 'A';
  }
  else
  {
     letter = 'B';
  }
  
  A similar situation where the ternary operator is used is directly within a System.out.println statement as in:
  
  System.out.println(grade >= 90 ? "Great work" : "You could do better");
  
  The selection operator is not covered on the AP exam. I don't even encourage you to use this operator on programming assignments or worksheets in this course.

Objective #5: Compare floating-point values and double variables correctly.

• Since floating-point data types such as double have limited precision, the computer's calculations may lead to round off errors. Since this is unavoidable in some algorithms, it is important to test whether a variable is close to a certain value rather than exactly equal to that value. The statement
  
  System.out.println(Math.pow(Math.sqrt(2), 2) - 2);
  
  displays 4.440892098500626E-16 in Java even though on your handheld calculator taking the square root of 2, squaring that answer and then subtracting 2 from that answer gives you the answer 0.
  
  So, to make up for the precision loss of the double data type, we should use something like
  
  if ((Math.pow(Math.sqrt(2), 2) - 2) < 1.0E-15)
  {
     System.out.println(2); // displays 0
  }
  
  which does display the answer 0.
  
  
• Here's a complete code segment that illustrates this issue:
  
  

  double a = 2.0;
  double b = Math.sqrt(2) * Math.sqrt(2); // 2.0000000000000004
  		
  if (a == b)
  {
     System.out.println("equal");
  }
  else
  {
     System.out.println("NOT EQUAL when using the == operator with double variables");
  }
  		
  if (a - b  < 1E-15)
  {
     System.out.println("EQUAL when subtracting them and checking that the difference is negligible");
  }
  else
  {
     System.out.println("not equal");
  }
  
  

  
  When the code executes the output is
  
  

  NOT EQUAL when using the == operator with double variables
  EQUAL when subtracting them and checking that the difference is negligible