Computer Science 15-100 (Sections T & U), Spring 2008
Class Notes:  Ch 4+5:  Classes, Methods, Conditionals, and Loops (3 of 3)

Logistics

1. Schedule
   1. Hw6
      • Due Friday
   2. Quiz 5
      • Change of plans:  no quiz this week.  Quiz 5 is Tue, 26-Feb.
      • Consequence:  Quiz 5 covers more material (all of today's material is included).
   3. Bonus Lecture #1
      • Tonight (at 4:30 and again at 6:30) in 5304 Wean Hall
      • Come prepared to think, think, think!  Take good notes, too!
2. Reading:
   1. L&L Chapter 4:  Writing Classes  (just static methods; no instance data, instance methods, encapsulation, or constructors)
      L&L Chapter 5:  Conditionals and Loops

Topic Outline:

Style for hw6:

• good comments, variable names, method names, whitespace, indenting, formatting
• test cases (including boundary cases)
• no magic numbers!
  Safe rule:  all values except -1, 0, +1, and +2 belong in named variables
• no duplicate code!
• use "else" when appropriate!
   
• Examples:
  • no magic numbers!
    wrong:
    // 1.2566 radians equals about 72 degrees
    polygon.addPoint(50+(int)(20*Math.cos(1.2566*i), 100+(int)(20*Math.sin(1.2566*i))
    
    right:
    int nPoints = 5; // # of outer points in the star
    double theta = Math.toRadians(360/nPoints);  // Q:  what about the 360?
    int cx = 50;  // x value of center of star
    int cy = 100; // y value of center of star
    int r = Math.min(width,height) / 10;  // Q:  what about the 10?
    polygon.addPoint(cx+(int)(r*Math.cos(theta*i), cy+(int)(r*Math.sin(theta*i))
     
  • no duplicate code!
    wrong:
    if (someTest) {
       foo1();
       bar1();
       foo2(); 
    }
    else {
       foo1();
       bar2();
       foo2(); 
    }
    
    right:
    foo1();
    if (someTest)
       bar1();
    else
       bar2();
    foo2();
    
    wrong:
    System.out.print("Enter a # (0 to exit): ");
    x = scanner.nextInt();
    while (x != 0) {
       foo(x);
       System.out.print("Enter a # (0 to exit): ");
       x = scanner.nextInt();       
    }
    
    right:
    while (true) {
       System.out.print("Enter a # (0 to exit): ");
       x = scanner.nextInt();
       if (x == 0)
          break;
       foo(x);
    }
     
  • use "else" when appropriate!
    wrong:
    if (x < 0)
       System.out.println("negative");
    if (x >= 0)
       System.out.println("non-negative");
    
    right:
    if (x < 0)
       System.out.println("negative");
    else
       System.out.println("non-negative");
    
    wrong:
    if (x < 0)
       System.out.println("negative");
    if (x > 0)
       System.out.println("positive");
    
    right:
    if (x < 0)
       System.out.println("negative");
    else if (x > 0)
       System.out.println("positive");

Methods, Conditionals, and Loops (Oh my!)

1. The Conditional Operator (?:)
   • Sort of an "if" statement inside an expression
   • Syntax:    ( test ? true-expression : false-expression )
   • Example:
     
     System.out.println("I saw " + p + " " + ((p == 1) ? "person" : "people"));
     
     Equivalent to:
     
     System.out.print("I saw " + p + " ");
     if (p == 1)
        System.out.println("person");
     else
        System.out.println("people");
      
2. Switch Statement
   See syntax diagram on p. 232
   • Example:
     int choice = scanner.nextInt();
     switch (choice) {
       case 0: System.out.println("Case for choice 0.");
               break;
       case 1: System.out.println("Case for choice 1.");
               break;
       case 5:
       case 8: System.out.println("Case for choice 5 or 8.");  // multiple cases
               // no break, fall-through
       case 9: System.out.println("Case for choice 9.");
               break;
       default:
               System.out.println("Default case");
     }
      
   • Note: cases must be compile-time constants
     wrong:
     char c = s.charAt(0);
     char d = 'X';
     switch (c) {
        case  d :  System.out.println("X marks the spot!");
                 break;
     }
     
     right:
     char c = s.charAt(0);
     switch (c) {
        case 'X': System.out.println("X marks the spot!");
                  break;
     }
      
   • A mildly compelling example from Sun:
     See http://java.sun.com/docs/books/tutorial/java/nutsandbolts/switch.html:

     class SwitchDemo2 {
         public static void main(String[] args) {
     
             int month = 2;
             int year = 2000;
             int numDays = 0;
     
             switch (month) {
                 case 1:
                 case 3:
                 case 5:
                 case 7:
                 case 8:
                 case 10:
                 case 12:
                     numDays = 31;
                     break;
                 case 4:
                 case 6:
                 case 9:
                 case 11:
                     numDays = 30;
                     break;
                 case 2:
                     if ( ((year % 4 == 0) && !(year % 100 == 0))
                          || (year % 400 == 0) )
                         numDays = 29;
                     else
                         numDays = 28;
                     break;
                 default:
                     System.out.println("Invalid month.");
                     break;
             }
             System.out.println("Number of Days = " + numDays);
         }
     }

3. The "do" Statement
   See syntax diagram on p. 250
   • It is a "while" statement that always executes the body at least once
     
     do {
        foo();
     } while (bar());
          
     Equivalent to:
     
     foo();
     while (bar()) {
        foo();
     }
      
   • Syntax Alert -- don't forget the trailing semicolon (the same one you never use with a "while" loop!)
     do {
        foo();
     } while (bar());
      
   • Not as common as "while" and "for" loops
      
   • Avoid obscurity -- use "do" loop only if it's a perfect fit
      
4. The "for" Statement
   See syntax diagram on p. 253
    
   • Classic use:  counting (say, from 0 to n-1):
     for (i=0; i<n; i++)
        foo(i);
      
   • Classic use:  inspecting each character in a string:
     for (i=0; i<s.length(); i++) {
        char c = s.charAt(i);
        foo(c);
     }
      
   • Syntax:
     
     for (init ; test ; update) body;
     
     Roughly equivalent to:
     
     {
        init;
        while (test) {
          body;
          update;
        }
     }
      
   • Note that you may omit any part of the init, test, or update
     (Style Alert:  Usually a bad idea, though -- use a better-suited loop):
     Ex1:
     int x = 1;
     for ( ; x < 3; x++)
       System.out.println(x);  // prints 1 then 2
     
     Ex2:
     int x = 1;
     for ( ; x < 3; ) {
       x++;
       System.out.println(x);  // prints 2 then 3
     }
     
     Ex3:
     int x = 1;
     for ( ; ; ) {
       x++;
       System.out.println(x);  // prints 2 then 3 then 4 then 5 then ...
     }
      
   • Style Alert:  Do not use "for ( ; ; )" -- use "while (true)"
      
   • Can have multiple statements in the init and update -- comma-separated
     (Style Alert:  Often a bad idea, though -- put them before the loop or in the body)
     int x, y;
     for (x=1,y=5; x < y; x++,y--)
       System.out.println(x);  // prints 1 then 2
      
   • Declaring variables inside a "for" loop
     • Example:
       int x;
       for (x=0; x<2; x++)
         System.out.println(x);  // prints 0 then 1
       
       Roughly the same as:
       for (int x=0; x<2; x++)
         System.out.println(x);  // prints 0 then 1
        
     • But:  variable's scope is limited to the for loop:
       int x;
       for (x=0; x<2; x++)
         System.out.println(x);  // prints 0 then 1
       System.out.println(x);  // prints 2
       
       Cannot be done this way:
       for (int x=0; x<2; x++)
         System.out.println(x);  // prints 0 then 1
       System.out.println(x);  // will not compile, x is not in scope here!
        
     • Also:  cannot declare a local variable within the scope of another local variable of the same name
       int x;
       for (int x=0; x<2; x++)  // will not compile -- x is already defined!
         System.out.println(x);
        
5. Iterators
   1. Support iterating over arbitrary collections
       
   2. Key methods:  hasNext and next
       
   3. Ex 1:  Reading strings from the user:
      java.util.Scanner scanner = new java.util.Scanner(System.in);
      while (scanner.hasNext()) {
         String s = scanner.next();
         System.out.println("read string: " + s);
      }
       
   4. Ex 2:  Reading strings from within a string (eg, portions of phone number):
      String phoneNumber = "44-0-20-7321-2233"; // Buckingham Palace
      java.util.Scanner scanner = new java.util.Scanner(phoneNumber);
      scanner.useDelimiter("-");
      while (scanner.hasNext()) {
         String s = scanner.next();
         System.out.println(s); // prints 44, then 0, then 20, then 7321, then 2233
      }
        
6. Block scope of variables
   1. Local variables (including parameters) are only visible within the block they are declared.
      So:  Local variables are not visible outside the block they are declared.
      for (int x=0; x<2; x++) {
        System.out.println(x);  // prints 0 then 1
      }
      System.out.println(x);  // will not compile, x is not in scope here!
       
   2. Local variables are only visible from their definitions onward
      public static void main(String[] args) {
        System.out.println(x);  // will not compile, x is not in scope here!
        int x = 3;
        System.out.println(x); // would print 3, if this compiled
      }
       
   3. You can reuse the same-named local variable in different blocks
      for (int x=0; x<2; x++) {
        System.out.println(x);  // prints 0 then 1
      }
      for (int x=0; x<2; x++) {
        System.out.println(x);  // prints 0 then 1 again
      }
       
   4. Style Alert:  bad idea #2541:  use a block as a statement to reuse same-named local variables
      public static void main(String[] args) {
        {
            int x = 3;
            System.out.println(x); // prints 3
        }
        {
            int x = 4;
            System.out.println(x); // prints 4
        }
      }

Practice:  Methods, Conditionals, and Loops (Oh my!)

Quiz 4 Redux:

// Quiz4.java
// <Your name, andrew id, section>

// This is a computer-based programming quiz.
// You MAY (in fact, MUST) use DrJava to write this quiz.
// You MAY NOT use the internet (except to obtain the quiz and submit it),
// or ANY OTHER PROGRAMS on the computer.  Or any notes.  Or any person
// (besides yourself).

// When you are done with your quiz, EMAIL THE FILE Quiz4.java to koz AT cmu.edu
// Email it as BOTH an ATTACHMENT and PASTED INTO THE BODY of the one message.
// CC yourself, and verify that you received the message you sent.
// Be SURE to email the Java file and NOT THE CLASS FILE!!!

// Style does not count on quizzes. Only correctness.

// IMPORTANT NOTE:  YOU MAY NOT "HARDCODE" THE TEST DATA INTO YOUR ANSWER!!!!
// Your solutions must work in general, and not just for the given test cases.

// You have 30 minutes.  Good luck.

public class Quiz4 {

  ///////////////////////////////////////////////////////////
  ///// PART 1:  Reverse Strings
  ///////////////////////////////////////////////////////////

  // PROBLEM STATEMENT:
  // Write a method that takes two possibly-null strings and returns true if
  // each string is the exact REVERSE of the other, taking case,
  // whitespace, and punctuation into account, and false otherwise.
  // NOTE:  The only String methods you may use are length and charAt.
  // Your method should work like this:
  //     areReverseStrings("abc","cba") returns true
  //     areReverseStrings("Abc","cba") returns false
  //     areReverseStrings("abc!","cba") returns false
  //     areReverseStrings(null,"abc") returns false (does not crash!)
  // Note: your program must work for the null string, which is not a string,
  // so is not the reverse of any string.  So just return false in that case!
  
  public static boolean areReverseStrings(String s1, String s2) {
    return false;  // REPLACE THIS WITH YOUR ANSWER!
  }
  
  public static void testAreReversedStrings() {
    System.out.println("Testing areReversedStrings...");
    verify(areReverseStrings("abc" ,"cba") == true);
    verify(areReverseStrings("Abc" ,"cba") == false);
    verify(areReverseStrings("abc!","cba") == false);
    verify(areReverseStrings(null  ,"abc") == false); // does not crash!
    System.out.println("  Passed these tests (though we will use more tests when grading)");
  }

  ///////////////////////////////////////////////////////////
  ///// PART 2:  Formatted Addition
  ///////////////////////////////////////////////////////////

  // PROBLEM STATEMENT:
  // Write a method that takes two doubles, each in the range [0,10),
  // and returns a single String that contains a nicely formatted
  // addition problem and its solution where all values are rounded
  // to the nearest 10th, all decimal points align, the second line
  // has a preceding "+" sign and a space, and the third line
  // contains 3 right-aligned dashes.
  
  // For example, if the method is called with the values 2.3 and 3.5,
  // it would return a string that, when printed out, would display:
  //   2.3
  // + 3.5
  //   ---
  //   5.8
  // This is all stored in one string, though, with newlines (\n's),
  // as such:
  // "  2.3\n+ 3.5\n  ---\n  5.8"
  
  // If either variable is less than 0 or greater than or equal to 10,
  // you should just return the string "out of range".
  
  // Also:  you should round the parameters BEFORE adding, and then
  // round the sum AFTER adding.  So if the parameters are 1.05 and
  // 2.05, you would first round these to 1.1 and 2.1, which sum to 3.2.
  // (Note that 1.05 + 2.05 = 3.1 if we do not first round the parameters.)
  // The only reason to round the result is to handle round-off error.
  
  // Thus, your method should work like this:
  // makeAdditionProblem(2.3 ,3.5 ) returns "  2.3\n+ 3.5\n  ---\n  5.8"
  // makeAdditionProblem(1.05,2.05) returns "  1.1\n+ 2.1\n  ---\n  3.2"
  // makeAdditionProblem(-1,3) returns "out of range"
  
  // HINT: You'll probably want to use String.format here -- it does
  // rounding and right-aligning for you!
  
  public static String makeAdditionProblem(double d1, double d2) {
    return "to do!"; // REPLACE THIS WITH YOUR ANSWER!
  }
  
  public static void testMakeAdditionProblem() {
    System.out.println("Testing makeAdditionProblem...");
    verify(makeAdditionProblem(2.3 ,3.5 ).equals("  2.3\n+ 3.5\n  ---\n  5.8"));
    verify(makeAdditionProblem(1.05,2.05).equals("  1.1\n+ 2.1\n  ---\n  3.2"));
    verify(makeAdditionProblem(-1,3).equals("out of range"));
    System.out.println("  Passed these tests (though we will use more tests when grading)");
  }

  ///////////////////////////////////////////////////////////
  ///// PART 3:  Sum of the first N Terms of the series
  /////          S = 4/1 - 4/3 + 4/5 - 4/7 +...
  ///////////////////////////////////////////////////////////

  // PROBLEM STATEMENT:
  // Consider this series:
  //  S = 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + 4/13 - ...
  // The first term is 4/1.  The second term is -4/3.  And so on.
  // As you can see, the sign (+/-) of each term changes, the numerator of each
  // term is 4, and the denominator keeps increasing by 2.

  // Write a method that takes an int "n" and if n is positive, returns the
  // sum of the first n terms of this series, rounded to the nearest 100th,
  // returning -1 if n is non-positive.  It should work like this:
  //   sumOfFirstNTerms(1) returns 4.00 (which is 4/1 when rounded)
  //   sumOfFirstNTerms(2) returns 2.67 (which is 4/1 - 4/3 when rounded)
  //   sumOfFirstNTerms(3) returns 3.47 (which is 4/1 - 4/3 + 4/5 when rounded)
  //   sumOfFirstNTerms(4) returns 2.90 (which is 4/1 - 4/3 + 4/5 - 4/7 when rounded)

  // Interesting aside:
  // As n gets larger, sumOfFirstNTerms(n) approaches pi (3.14).  Wow!

  public static double sumOfFirstNTerms(int n) {
    return 42;  // REPLACE THIS WITH YOUR ANSWER!
  }
  
  public static void testSumOfFirstNTerms() {
    System.out.println("Testing sumOfFirstNTerms...");
    verify(almostEqual(sumOfFirstNTerms(0),-1));
    verify(almostEqual(sumOfFirstNTerms(1),4.00));
    verify(almostEqual(sumOfFirstNTerms(2),2.67));
    verify(almostEqual(sumOfFirstNTerms(3),3.47));
    verify(almostEqual(sumOfFirstNTerms(4),2.90));
    System.out.println("  Passed these tests (though we will use more tests when grading)");
  }

  ///////////////////////////////////////////////////////////
  ///// Supporting Code  (verify, almostEqual, main)
  ///////////////////////////////////////////////////////////
  
  public static boolean almostEqual(double d1, double d2) {
    double epsilon = 0.0000001; // adjust as appropriate
    return Math.abs(d2 - d1) < epsilon;
  }
  
  public static void verify(boolean test) {
    if (test == false) throw new RuntimeException("Failed verify test!");
  }

  public static void main(String[] args){
    testAreReversedStrings();
    testMakeAdditionProblem();
    testSumOfFirstNTerms();
  }
}