Objectives

• Use if statements, if/else statments, and nested if/else statments
• Use conditions and relational operators
• Use for loops with if statements to accumulate results
• Use methods with conditional execution

Assignments

• Read Chapter 4
• Lab 4 Due beginning of Week 8
• Quiz 6 Available end of Week 8
• Lab 5 Due beginning of Week 9
• Quiz 7 Available end of Week 9
• Finish Project 2 (Due beginning of Week 10)

Contents

---

if, if/else, and Nested if/else Statements

---

Cumulative Algorithms

---

Text Processing

The char Type

The primitive type char represents one character.  Literal values are expressed by a character within single quotes, for example: 'A', '7', '#'.

Values of type char are represented by integers, and arithmetic operators can be applied to chars, but generally this is not considered good practice (exceptions include using ++ to get the next char).  A char can be stored in an int, but a cast is required to store an int in a char.


The Character class has many useful functions for operating on chars.  These methods are called by putting Character. in front and including the char as a parameter (similar to how Math methods are called).

chars are primitive types, and Strings are objects in Java, and it can be confusing for beginners to keep track of the differences.  Here are some important things to remember.

• Use == to test equality of chars.  Use the equals method to test equality of Strings.

  char c = 'y';
  String s = c + "es";
  System.out.println(c == 'y');         // prints true
  System.out.println(s == "yes");       // prints false!
  System.out.println(s.equals("yes"));  // prints true
  

• Use Character.method(charVariable) notation for Character methods.  Use stringVariable.method( ) notation for String methods.

  char c = 'y';
  String s = "yes";
  System.out.println(Character.toUpperCase(c));  // prints Y
  System.out.println(s.toUpperCase( ));          // prints YES
  

• Use the charAt method to extract a single character from a String.  Recall that Strings use zero-based indexing.

  String s = "yes";
  char c0 = s.charAt(0);
  char c1 = s.charAt(1);
  char c2 = s.charAt(2);
  System.out.println(c0);  // prints y
  System.out.println(c1);  // prints e
  System.out.println(c2);  // prints s
  char c3 = s.charAt(3);   // causes an error
  

Cumulative Text Algorithms

We can process each character of a String by calling the charAt method for each index from 0 up to (but not including) the length of the String.

For example, we might to count the number of times a particular character occurs in a String.  Recall that to use a counter, we need to initialize the counter before the loop, increment the counter inside the loop if a test is satisfied, and use the value of the counter after the loop.  A method that returns the count would have the following pseudocode.

The String to be searched and the char to look for need to be parameters.  Otherwise, how do we know what to search and what to search for?  This leads to the following method.




For another example, consider converting a String to "leet", a geeky variation of spelling sometimes seen on the internet.  Part of the conversion is substitutions, for example: 'e' to '3', 'l' to '1', and 't' to '7'.  Given "turtle", we want to return "7ur713".  As we examine the String parameter one letter at a time, we want to add one letter (or a substitution) to the String we want to return.

The pseudocode only has one "if statement", but in Java we will need three different conditions for 'e', 'l', and 't'.  Recall that we can use the + operator to produce a String from two other Strings (or a String and any other type).

First look at how the String variable result behaves like a counter.  Before the loop, result is initialized to "", aka the empty string, a String with zero characters.  Inside the loop, the char variable c is added (concatentated) to the end of result.  After the loop, result is returned.

Next look at how the char variable c is manipulated in the loop.  In each iteration, c is initialized to the char at index i.  The if statement changes the value of c under certain conditions.  Changing the value of c does not change str; a primitive type is a copy of the original value.  In the tests, note that lower case and upper case letters are checked.  If none of the tests are true, c's value will stay the same.

---

Methods with Conditional Execution

Preconditions, Postconditions, and Exceptions

When you write a method, you should consider what needs to be true for the method to work and what it means for the method to accomplish its task.  For example, a method that finds the square root of a number might need the number to be zero or positive, and its return value, when multiplied by itself, should be equal to (or be very close to) the number.

A precondition is a condition that must be true when the method is called so that the method can perform its task.  A postcondition is a condition that will be true when the method is finished as long as the method's preconditions were true.

Consider writing a method that is supposed to return the sum of the integers from 1 up to a given value.  For example, if the parameter is 7, the method should return the value of 1+2+3+4+5+6+7.  Note that stating what a method is supposed to do usually describes its postcondition.

What should this method do if the parameter is zero or negative?  It doesn't make sense to add up the integers from 1 up to -5.  If we think that a zero or negative parameter is a programming error, then we should state that a positive parameter is a precondition of this method.

Unfortunately, comments don't do anything when the code is executed.  This method will return 0 if the precondition is not satisfied.  If this is a serious enough error, then we want to throw an exception, which will force the programmer to fix the bugs.

You see the new keyword because an exception is an object in Java.  There are many different kinds of exceptions in Java, but using IllegalArgumentException should be sufficient for now.

Return Values and Code Paths

One of the interesting features of the return statement is that when a return statement is run, the method does not run any more code.  For example, consider this method which behaves like Math.max.

This method returns the larger of the two doubles.  It looks like the method will always return b because that is what the last statement does.  However, if the test a > b is true, then the first return statement is executed and any code following the if statement is skipped.  There are two different paths in the code that could be executed: one path is executed if a > b, and the other path is executed if a <= b.


Reasoning about code paths is usually done when you are planning how to write a method.  Suppose we want to write a method that returns the first digit in a String.  This will probably involve a loop that obtains and examines each char in the String.

Note that if the first char in the String is a digit, the method can return that char and does not need to look at the remaining characters.  In general, once the method finds a digit, we can return it without looking at any remaining characters.

Having a return statement in a loop creates many different code paths.  For example, if the steps return on the fourth iteration, then, the fourth character must be a digit, and, in addition, the first three characters were not digits.

What should we do if the String has no digits?  Because the method will be returning a char, we could return a non-digit char (a '?', for example) to indicate that no digit was found (throwing an exception is another possibility).  Note that the method should not return a '?' until all the chars have been examined.  This is not something we can do before the loop (haven't examined any chars yet) or inside the loop (there might be more chars to examine), so it must be done after the loop.  That is, if the loop ends without a return, that means there were no digits found.

With all these considerations, we can convert the pseudocode into a method.

---