SE 1011, Note 5

Copyright © 1997, 2014
Robert W. Hasker

SE 1011 - Note 5

If Statements

Ch. 4

Review: Conditional Actions

Sequential action:

		       |
		.-------------.
		| statement 1 |
		`-------------'
		       |
		.-------------.
		| statement 2 |
		`-------------'
		       |
		.-------------.
		| statement 3 |
		`-------------'
		       |

Example:

	double side = in.getDouble();
	double volume = side * side * side;
        System.out.println("Volume of cube: " + volume);

Decisions:

                       |
                   /--------\
                  < decision >
                   \--------/
                    /      \
                 true     false
                 /           \
        .-----------.     .-------------.
        | statement |     | alternative |
        `-----------'     `-------------'
              |                  |
              `------------------'
                       |

Like coming to a fork in the road.

We need a way to express such decisions in programs.
- In pseudocode, we use the if:
```
	 if test then
	    actions
	 otherwise
	    actions
```
- Tests: standard mathematical symbols: <, >, [less or equal], [greater or equal]
- Example: determine the fine and penalty for speeding:
```
	if speed - limit > 15 then
	  fine = $300
	  penalty = 2 points
	otherwise
	  fine = $100
	  penalty = 1 point
```

Conditional statements in Java

General form of a condition:

	if ( test )
	{
	   statements
	}
	else
	{
	   statements
	}

Writing the pentalty/fine code in Java:

Will introduce constant RECKLESS for reckless driving cut-off speed.

	int speed, limit, fine, penalty;

	// ...

	if ( speed - limit > RECKLESS )
	{
	   fine    = 300;
	   penalty = 2;
	}
	else
	{
	   fine    = 100;
	   penalty = 1;
	}

Note the indentation: 3 spaces for body of if
Note bug: can get fined even if not speeding!

Multiple Checks

Consider the general form:
```
	if ( test )
	{
	   statements
	}
	else
	{
	   statements
	}
```
- This is a statement, so statements can be more if statements!

Example: pseudocode for grade is A, AB, B, BC, or C:

        if score >= 93
          grade = "A"
        else if score >= 89
          grade = "AB"
        else if score >= 85
          grade = "B"
        else if score >= 81
          grade = "BC"
        else if score >= 77
          grade = "C"
        else
          grade = "need to repeat"

Usual style:

        String grade;
        if ( score >= 93.0 ) {
           grade = "A";
        } else {
           if ( score >= 89.0 ) {
              grade = "AB";
           } else {
              if ( score >= 85.0 ) {
                 grade = "B";
              } else {
                 if ( score >= 81.0 ) {
                    grade = "BC";
                 } else {
                    if ( score >= 77.0 ) {
                       grade = "C";
                    } else {
                       grade = "need to repeat";
                    }
                 }
              }
           }
        }

But let's capture the parallel nature of what's going on
(Just reformatted - code still works the same)

        String grade;
        if ( score >= 93.0 ) {
           grade = "A";
        } else if ( score >= 89.0 ) {
           grade = "AB";
        } else if ( score >= 85.0 ) {
           grade = "B";
        } else if ( score >= 81.0 ) {
           grade = "BC";
        } else if ( score >= 77.0 ) {
           grade = "C";
        } else {
           grade = "need to repeat";
        }

More on Tests

Comparisons in math: <, >, [less than or equal], [greater than or equal], =, [not equal]
Comparisons in Java: <, >, <=, >=, ==, !=
- Warning: don't use = when you mean ==!
- In some cases it's legal, but won't give you what you desire
- ! is often pronounced "bang."

Another example (extending Ch. 4 example on grading a quiz):

	if answer matches expected response, then
	   print message saying answer right
	   add 1 to number of correct scores
	otherwise
	   print message giving correct answer

Tests: a new type of expression.
- "relational" operators: <, >, <=, >=, ==, !=
- precedence: lower than all of the additive operations (so speed - limit > RECKLESS works right)
But note: the result of these expressions is either true or false
- type: boolean
What are the types and results of the following?
- 18 + 2
- 4 * 3 < 2 * 5
Boolean values can be stored in variables just like any other type of value:
```
	boolean isLess;

	isLess = 4 * 3 < 2 * 5;
```

Conditions in if statements: boolean expressions; consider

	int speed, limit, fine, penalty;
	boolean driving_recklessly;

	// ...

	// not a really good method:
	driving_recklessly = speed - limit > RECKLESS;
	if ( driving_recklessly )
	{
	   fine    = 300;
	   penalty = 2;
	}
	else
	{
	   fine    = 100;
	   penalty = 1;
	}

What if you want to check two things at the same time?
- Example: only give speeding tickets between 9:00am and 5:00pm
  - use military clock (hours are 1 through 24); test between 900 and 1700
- pseudocode:
```
	if time >= 900 and time <= 1700, then
	   print ticket
	otherwise
	   print warning
```
- In Java, "and" is written as "&&".
  - Note: don't use just a single &; it means something different.
```
	if ( time >= 900 && time <= 1700 )
	{
	   System.out.println("Speeding; pay $300.");
	}
	else
	{
	   System.out.println("Warning: drive more carefully!");
	}
```
- "And" is true when both subconditions are true.

Also: "or": true when either subcondition is true

Get ticket if speeding or time = 1700:

	if speed > limit or time = 1700, then
	   print ticket
	otherwise,
	   print "drive safely"

Use "||" for or in Java.

In Java:

	if ( speed > limit || time == 1700 )
	{
	   System.out.println("Speeding; pay $300.");
	}
	else
	{
	   System.out.println("Drive safely");
	}

Negation:

Example: just print warning if not between 9am and 5pm

	if not(time >= 900 and time <= 1700), then
	   print warning
	otherwise
	   print ticket

In Java, "not" is written as "!".

	if ( !(time >= 900 && time <= 1700) )
	{
	   System.out.println("Warning: drive more carefully!");
	}
	else
	{
	   System.out.println("Speeding; pay $300.");
	}

"Not" is true when it's subcondition is false.

Debugging

Example: compute payroll
- read hours, (hourly) rate
- pay 1.5 time for over 40 hours in week
running the program: full control
- step over
- trace into
- breakpoints, toggle
- watches
  - variables
  - expressions

Other Forms of `if`

More details on `if`

read number
Create if statement which prints positive, not positive; use braces
Comment out the else branch - does it still run? What happens?
Remove the braces - still work?
Go back to braces version and change not positive case to print zero or negative
Remove all braces - still work?
Various parts of if statements are optional.

Can leave out the else part:

	if ( time >= 900 && time <= 1700 )
	{
	   System.out.println("Speeding; pay $300.");
	}

When there's just one statement, can leave out the braces:
```
	if ( time >= 900 && time <= 1700 )
	   System.out.println("Speeding; pay $300.");
```
- In general, braces are used to "group" multiple statements.
- When there's just one statement, can drop the braces.
- But leaving the braces in can help you edit programs.
- What does the following do?
```
	if ( time >= 900 && time <= 1700 )
	   System.out.println("Speeding;");
	   System.out.println("pay $300.");
```
- Suggestion: when in doubt, add braces!

Can nest if statements inside eachother:

If car is speeding, check for reckless driving:

	if ( speed > limit )
	{
	   if ( speed - limit > RECKLESS )
	      System.out.println("Pay $300");
	   else
	      System.out.println("Pay $100");
	}

"Dangling else" problem:
- Suppose the above code was written without braces:
```
	if ( speed > limit )
	   if ( speed - limit > RECKLESS )
	      System.out.println("Pay $300");
	   else
	      System.out.println("Pay $100");
```
- Which if is matched by the else?
- Answer: each else is matched to the closest unmatched if.
- When writing code like this, you almost always want to use braces to make things clear!
- How would you change this code so "Pay $50" was printed for everyone driving below the limit.

When to use If

When should you use an if statement?
- If an action takes place sometimes but not always, use one-legged if.
- If there are two alternative actions, use a regular if.
Strategy:
- write English statement
- translate condition to Java
  - Watch out for "x is less than y but greater than z"
    - "x < y > z" is not right!
    - instead: x < y && x > z
  - how to translate "x is equal to 5 or 8"?
    - again, not x == 5 || 8
    - instead: x == 5 || x == 8

Review

conditions, boolean expressions
if, one-legged if, nested ifs
next time: loops - this is a critical lecture!!

Copyright © 1997, 2014 Robert W. Hasker