# University of Washington, CSE 142 (190)

## Lab 4: `if/else`, `Scanner`, and `return`

Except where otherwise noted, the contents of this document are Copyright 2010 Stuart Reges and Marty Stepp.

lab document created by Whitaker Brand and Marty Stepp

# Today's lab

Goals for today:

• use `if/else` statements to select between multiple code actions
• use `Scanner` to create interactive programs that read user input
• use return values to send data between methods
• more practice with parameters, cumulative algorithms, etc.
• Where you see this icon, you can click it to check the problem in Practice-It!

# Exercise : Math Expressions

Write the results of each of the following expressions. Make sure to use the proper type (.0 for a `double`, " " for a `String`).

 `Math.ceil(9.17)` `10.0` `Math.pow(2, 4)` `16.0` `Math.sqrt(64)` `8.0` `Math.floor(12.73) + Math.max(8, 5)` `20.0` `Math.abs(Math.min(-1, -3))` `3` `Math.ceil(Math.random())` `1.0` `-Math.pow(2, 2) + Math.pow(-2, 3) + Math.pow(2, -2)` `-11.75` `Math.round(4.25) + Math.round(5.38) + Math.round(6.49)` `15.0`

# Exercise : AgeCheck

• Copy/paste and save the following program in jGRASP, then see the instructions on the next slide.
```public class AgeCheck {
public static void main(String[] args) {
int myAge = 19;   // I am 19; let me see if I can drive yet
message(myAge);
}

// Displays a single message about driving to the user based on the given age
public static void message(int age) {
if (myAge >= 16) {
System.out.println("I'm old enough to have a driver's license!");
}
if (myAge <= 16) {
System.out.println("I'm not old enough yet... :*(");
}
}
}
```

# Exercise - things to fix

• The program has a few syntax errors. Fix them until it compiles.
• The code has a logic problem. (For some value(s), it prints the wrong answer.) Find any such problems and fix them. (You may need to run the program a few times and try different values to see which ones fail.)
• The program uses `if` and `else` in a clumsy way. Improve the style of the code.

• The following is a corrected version of the program:
```public class AgeCheck {
public static void main(String[] args) {
int myAge = 19;   // I am 19; let me see if I can drive yet
message(myAge);
}

// Displays a single message about driving to the user based on the given age
public static void message(int age) {
if (age >= 16) {
System.out.println("I'm old enough to have a driver's license!");
} else {
System.out.println("I'm not old enough yet... :*(");
}
}
}
```

# Exercise : AgeCheck2

• Now Replace your previous `AgeCheck` program's `message` method with:
```    // Possibly prints some message(s) to the user based on the given age
public static void message(int age) {
if (age >= 21) {
System.out.println("I can legally purchase alcohol!");
} else if (age >= 17) {
System.out.println("I can purchase a ticket to an R-rated movie.");
} else if (age >= 16) {
System.out.println("I can get my driver's license!");
}
}
```
• For some age(s), the message(s) printed are not accurate. (In some cases, it should print no messages; in some cases, one message; and in others, many messages.) Improve the usage of `if`s and `else`s in this method to behave properly.

# Exercise : `if`/`else` mystery

Consider the following Java code. Fill in the boxes with the output produced by each of the method calls.

```public static void mystery(int n) {
System.out.print(n + " ");
if (n > 10) {
n = n / 2;
} else {
n = n + 7;
}
if (n * 2 < 25) {
n = n + 10;
}
System.out.println(n);
}
```
 `mystery(40);` `40 20` `mystery(8);` `8 15` `mystery(0);` `0 17` `mystery(12);` `12 16` `mystery(20);` `20 20`

# Exercise : area

Write a method named `area` that accepts the radius of a circle as a parameter and returns the area of a circle with that radius. For example, the call `area(2.0)` should return `12.566370614359172`.

• (Try solving this problem in Practice-It by clicking the icon above.)

Write a complete program `WazzuAdmit` with the behavior shown below. Use the `Scanner` to read user input for a student's grade point average and SAT exam score. A GPA of 1.8 or an SAT score of 900 or above (or both) will cause the student to be accepted; anything less will cause him/her to be rejected.

```Washington State University admission program
What is your SAT score? 1280
You were accepted!
```

```import java.util.*;   // for Scanner

public static void main(String[] args) {
Scanner console = new Scanner(System.in);

double gpa = console.nextDouble();
System.out.print("What is your SAT score? ");
int sat = console.nextInt();

if (gpa >= 1.8 || sat >= 900) {
System.out.println("You were accepted!");
} else {
System.out.println("You were rejected!");
}
}
}
```

# Exercise : Syntax errors

• The following Java program has 7 errors. Can you find all of them?  ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ``` ```public class IfOops { public static void main(String[] args) { int a = 7, b = 42; minimum(a, b); if {smaller = a} { System.out.println("a is the smallest!"); } } public static void minimum(int a, int b) { // returns which int is smaller if (a < b) { int smaller = a; } else (a => b) { int smaller = b; } return int smaller; } } ```
• Copy and paste the code into jGrasp and see if you can fix the errors.

1. line 5: `if` statement should use `()` parentheses, not `{}` brackets
2. line 5: `=` should be `==`
3. line 5: `smaller` is out of scope here
4. line 10: `void` should be `int`
5. line 13: `=>` should be `>=` (or better yet, no `if` test is needed)
6. line 16: should not write variable's type of `int` when returning it
7. line 16: `int smaller` is out of scope here (declare outside `if` or return directly)

# Exercise - Corrected version

• ```public class IfOops {
public static void main(String[] args) {
int a = 7, b = 42;
int smaller = minimum(a, b);
if (smaller == a) {
System.out.println("a is the smallest!");
}
}

public static void int minimum(int a, int b) {  // returns which int is smaller
int smaller;
if (a < b) {
int smaller = a;
} else if (a >= b) {
int smaller = b;
}
return int smaller;
}
}
```

# Exercise : pay

Write a method named `pay` that accepts a real number for a TA's salary and an integer for the number of hours the TA worked this week, and returns how much money to pay the TA. For example, the call `pay(5.50, 6)` should return `33.0`.

The TA should receive "overtime" pay of 1 ½ normal salary for any hours above 8. For example, the call `pay(4.00, 11)` should return (4.00 * 8) + (6.00 * 3) or `50.0`.

• (Try solving this problem in Practice-It by clicking the icon above.)

# Exercise : seeMovie

You're thinking about going with your friends to a movie. Write a Java method `seeMovie` that accepts two parameters: the cost of a ticket in dollars, and the rating number of stars the movie received out of 5. The method should print how interested you are (very, sort-of, or not). Use the following criteria:

• You like bargains. Any movie that costs less than \$5.00 is one that you want to see very much.
• You dislike expensive movies. You are not interested in seeing any movie that costs \$12.00 or more, unless it got 5 stars (and even then, you are only sort-of interested).
• You like quality. You are very interested in seeing 5-star movies that cost under \$12.00.
• You are sort-of interested in seeing movies costing between \$5.00 - \$11.99 that also got between 2-4 stars inclusive.
• You are not interested in seeing any other movies not described previously.

# `if`/`else` Factoring

• It's easy to introduce redundancy in the branches of an `if`/`else`. For example:
```if (x < 30) {
a = 2;
x++;
System.out.println("CSE 142 TAs are awesome! " + x);
} else {
a = 2;
System.out.println("CSE 142 TAs are awesome! " + x);
}
```
• The code can be factored out to become: (notice that the `else` went away!)
```a = 2;
if (x < 30) {
x++;
}
System.out.println("CSE 142 TAs are awesome! " + x);
```

# Exercise : `if`/`else` Factoring

• The program's method is redundant. Factor the method, restructuring the code to eliminate unnecessary statements while retaining the same behavior.
• Insert some test calls of the method in `main` and run it to make sure it works properly.

# Exercise : numUnique

Write a method named `numUnique` that accepts three integers as parameters and that returns the number of unique integers among the three. For example, the call `numUnique(18, 3, 4)` should return 3 because the parameters have 3 different values. By contrast, the call `numUnique(6, 7, 6)` would return 2 because there are only 2 unique numbers among the three parameters: 6 and 7.

• (Try solving this problem in Practice-It by clicking the icon above.)

# Exercise : pow

Write a method named `pow` that accepts a base and an exponent as parameters and returns the base raised to the given power. For example, the call `pow(3, 4)` returns 3 * 3 * 3 * 3 or 81. Do not use `Math.pow` in your solution; use a cumulative algorithm instead. Assume that the base and exponent are non-negative.

• (Try solving this problem in Practice-It by clicking the icon above.)
• For added challenge, try turning your solution into a second version `pow2` that works with real number bases and negative exponents, as in book Exercise 4.11.

# Exercise : smallestLargest

Write a method named `smallestLargest` that prompts the user to enter numbers, reads them, then prints the smallest and largest of all the numbers typed in by the user. For example:

```How many numbers do you want to enter? 4
Number 1: 5
Number 2: 11
Number 3: -2
Number 4: 3
Smallest = -2
Largest = 11
```

# If you finish them all...

If you finish all the exercises, try out our Practice-It web tool. It lets you solve Java problems from our Building Java Programs textbook.

You can view an exercise, type a solution, and submit it to see if you have solved it correctly.

Choose some problems from Chapter 4 and try to solve them!