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.
  
  
• You can use the logical operators && (AND), || (OR) , and ! (NOT) within control expressions in an if statement.
  
  
• You must be careful to use extra parentheses in some situations since && (AND) executes before || (OR) according to the order of operations.
  
  For example, if you want to test for the correct username of "Cade" or "cade" and the matching password of "abc123" then the following If statement would NOT work correctly
  
  if (username.equals("Cade") || username.equals("cade") && password.equals("abc123"))
  {
     System.out.println("Welcome to Facebook");
  }
  
  If the user inputs "Cade" but lets the password blank, he will be able to login successfully since True Or False And False simplifies to True. The And expression executes first according to the order of operations.
  
  To fix the logic error, you must use an extra parenthese around the || (OR) expression as in
  
  if ((username.equals("Cade") || username.equals("cade")) && password.equals("abc123"))
  {
     System.out.println("Welcome to Facebook");
  }
  
  In this case when the user inputs "Cade" for the username and lets the password blank, the control expression will be False and prevent him from logging in since (True Or False) And False simplifies to False.
  
  
• 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.
  

Objective #4: Avoid usage problems and errors with if statements.

• 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");
  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");
  else
  System.out.println("C or less");
  
  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");
  }
  else
     System.out.println("C or less");
  
  For even better style, curly braces should be used in every part of the code segment and blank lines should be placed around the inner if statement as in:
  
  
  grade = 75;
  
  if (grade >= 80)
  {
  
     if (grade >= 90)
     {
        System.out.println("A");
     }
  
  }
  else
  {
     System.out.println("C or less");
  }
  
  Of course, there is a still a "hole" in the logic with this last example. The formatting of the code looks good and it compiles with no errors, but nothing prints if grade is 85. The inner, nested if statement should have an else clause to reflect the additional logic as in:
  
  grade = 85;
  
  if (grade >= 80)
  {
  
     if (grade >= 90)
     {
        System.out.println("A");
     }
     else
     {
        System.out.println("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 #5: 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 the whole expression.

Example:   
Scanner keyboard = new Scanner(System.in);
System.out.print("Enter the number of people sharing the pizza: ");
int num = keyboard.nextInt();

if (num > 0 && 8 / num >= 2)
{
   System.out.println("Each person will get 2 or more pieces of pizza.");
}

if (8 / num >= 2 && num > 0) // causes run-time ArithmeticException error if num is zero
{
   System.out.println("Each person will get 2 or more pieces of pizza.");
}

If zero is inputted for num, the first if statement above works fine since the compiler works from left to right through the control expression and num > 0 evaluates to false making the whole if control expression false. In other words, the compiler never bothers to evalute the 8 / num >= 2 part of the control expression. This is called short-circuit evaluation because the whole control expression is "short-circuited" and never complete evaluated.

If zero is inputted for num, the control expression in second if statement again is evaluated from left to right and a division-by-zero runtime ArithmeticException error immediately occurs.

Since Java supports short-circuit evaluation, it is wise for a Java coder to take advantage of it and write if statement control expressions like the first example to avoid potential runtime errors.


• 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)
  
  
• You can sometimes simplify a Boolean expression into simpler terms. For example
  
  (num > 0 && num <= 0)
  
  can be rewritten as
  
  (A && !A)     since being greater than zero is the opposite of being less than or equal to zero.
  
  Furthermore
  
  (A && !A)     simplifies to
  false
  
  since it doesn't matter whether A is true or false. If A is true, then the opposite of A is false and the whole thing is false. If A is false, then the whole thing is false already. In other words, it doesn't matter what value is stored in the variable num since either num is greater than zero or num is less than or equal to zero.
  
  See these videos to learn how to simplify more complicated Boolean expressions: VIDEO 1              VIDEO 2
  
  
• 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 a method in a class that has a myHunger property would be isHungry.
  
  public boolean isHungry()
  {
     if (myHunger > 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 (myHunger > 0)
     {
        return true;
     }
     else
     {
        return false;
     }
  
  However, the following single statement could be used as the body of the method
  
  return myHunger > 0;
  
  since the boolean expression myHunger> 0 simplifies to either true or false and that boolean value could immediately be returned.
  
  
• The selection operator explained below is not covered on the AP exam but it is useful in some situations. 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");
  

Objective #6: Use an if statement to parse and identify characteristics of integers.

• An if statement can be used to detect if a positive number is even or odd.
  
  if (num % 2 == 0)
  {
     System.out.println(num + " is even");
  }
  else if (num % 2 == 1)
  {
     System.out.println(num + " is odd");
  }
  
  Note that the above example could be rewritten using an else clause instead of an else if clause.
  
  
• An if statement can be used to isolate a specific digit within a number. This is called parsing an integer. For example, you can parse the integer 1234 to determine that a 3 is in the tens place. Remember that the according to the Java order of operations % (modulus) is tie with multiplication and division.
  
  The following algorithms apply to integers in Java:
  
  modding by 10 gives you the last 1 digit of an integer (e.g. 1234 % 10 simplifies to 4)
  modding by 100 gives you the last 2 digits of an integer (e.g. 1234 % 100 simplifies to 34)
  modding by 1000 gives you the last 3 digits of an integer (e.g. 1234 % 1000 simplifies to 234)
  and so on
  
  integer dividing by 10 takes off the last 1 digit of an integer (e.g. 1234 / 10 simplifies to 123)
  integer dividing by 100 takes off the last 2 digits of an integer (e.g. 1234 / 100 simplifies to 12)
  integer dividing by 1000 takes off the last 3 digits of an integer (e.g. 1234 / 1000 simplifies to 1)
  and so on
  
  THIS IS THE ESPECIALLY USEFUL SET OF ALGORTHMS TO PARSE INDIVIDUAL DIGITS:
  
  a number % 100 / 10 is the tens digit of that number (e.g. 1234 % 100 / 10 simplifies to 3)
  a number % 1000 / 100 is the hundreds digit of that number (e.g. 1234 % 1000 / 100 simplifies to 2)
  a number % 10000 / 1000 is the thousands digit of that number (e.g. 1234 % 10000 / 1000 simplifies to 1)
  and so on
  
  Notice the patterns in the algorithms above where increasing powers of 10 are used as divisors.
  
  We can write if statements such as
  
  if (num % 100 / 10 == 3)
  {
     System.out.println("The tens digit of " + num + " is 3");
  }
  
  Or, we can determine if a number is a numeric palindrome as in
  
  int num = 1331;
  
  if (num / 1000 == num % 10 && num % 1000 / 100 == num % 100 / 10)
  {
     System.out.println(num + " is a palindrome.");
  }
  

Objective #7: 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