This page will provide extra examples and other information not given in the lectures. Some of these examples use features of Java not yet covered in the course.

---

• The Dice class of the Week 4 Lecture:
  • Dice class worksheet.
  • Outcome of 36 000 000 rolls of two dice.

  ---

• Here is an example using the BigInteger class of Lab 2:
  • Factorial class.

  ---

• Here are two completed examples from the Week 5 Lecture:
  • The BankAccount class.
  • The Car class.

  ---

• Here are two completed examples from the Week 6 Lecture:
  • The SavingsAccount class.
  • The Student class.

  ---

• Here is a completed example from the Week 7 Lecture (review for Exam 1):
  • The Employee class.

  ---

• Here is a completed example from the Week 8 Lecture. In this example, there is only one copy of the PurseTest class, but there are two versions of the Purse class. These examples show how we can make changes to the internal form of a class, without changing the results of all public methods, and without changing any client code, that is, code such as PurseTest that makes use of Purse.
  • The Purse class.

  ---

• This is material related to the Week 9 Lecture.
  • For this lecture you may need to change your machine so that it recognizes the latest version of Java: Java 1.5 (in place of Java 1.4). To do this on machines at UTSA, you can follow the directions buried inside: CS 1723 Lab 2. (See Part I: Setting up JBuilder to use Java 1.5.)
  • Alternatively use Directions from Dr. Carola Wenk.
  • To see whether you have the 1.5 version of Java on your machine, try the following program:

    import java.util.Scanner;
    
    public class ScannerTest {
    
       public static void main(String[] args) {
          Scanner in = new Scanner(System.in);
          System.out.print("Type an integer and then 'Return' ---> ");
          int quantity = in.nextInt();
          System.out.println("You typed: " + quantity);
       }
    }
    

    In case this program doesn't work or you are not using Java 1.5, you can use the following alternative ways to input numbers in Java: Java Input without 1.5.

  • Here is the new version of the Purse class asked for in the first part of the lecture: The Purse class.

  ---

• Hints for Lab 8:

  This lab is perhaps a little confusing. Here are some hints:

  • First get in mind the values you start with and the numbers you need to calculate. Let's use the example in the write-up:
    • You start with numbers 0900 and 1730 which are read in from the keyboard and represent "military time".

    • Each of these numbers must be converted to the number of minutes since midnight, using the calculations:
      900/100 * 60 + 900%100 == 9*60 + 0 == 540
      1730/100 * 60 + 1730%100 == 17*60 + 30 == 1020 + 30 == 1050

    • Next subtract the smaller number (earlier time) from the larger number (later time) to get the number of minutes between the two time:
      1050 - 540 == 510

    • Finally convert 510 minutes to hours and minutes:
      510 / 60 == 8 (hours)
      510 % 60 == 30 (munutes)

  • Next note that the lab says: "Implement a class TimeInterval whose constructor takes two military times."
    This means that you will use a Scanner object inside the main function in the TimeIntervalTest class to read the two numbers. These numbers become actual parameters to a constructor for an instance of a TimeInterval class. The two numbers are transferred to the two data members of the TimeInterval instance.

  • Now use helper methods and formulas to calcuate the number of minutes between the two times. You might put this into another private data member if you want.

  • Finally use the number of minutes and division or remainder by 60 to return the hours and minutes that are needed.

  ---

• Here are two completed examples from the Week 10 Lecture. The examples also show input that doesn't use Java 1.5.
  • An example about quadratic equations: The QuadraticEquation class.
  • An example about a table computing commission rates for sales amounts: The Commission class.
  • Second version of: The Commission class (uses input without Java 1.5).

  ---

• Here are completed examples from the Week 11 Lecture.
  • An example about calculating leap year: The Year class.
  • An example about earthquakes: The Earthquake class.
  • An example about comparing strings: The Strings class.

  ---

• Hints for Lab 10:

  You need to study the directions for this lab carefully. The lab also requires some use of strings, as well as if-else statements. Here are some hints, and a preliminary design that we worked out in class on Friday:

  • Remember some of the stuff about strings from early in the Week 9 Lecture:
    • The length of a string:

      
      String s1 = "Hello"; // number chars 0, 1, 2, 3, 4
      System.out.println(s1.length()); // prints 5
          

    • Use + for concatenation (tack strings together).

    • Check if strings are equal:

      You must not use ==, but instead you must use one of the methods equals or compareTo. So to compare strings s1 and s2 for equality:

      
      if (s1.equals(s2)) ...          // check if equal
      if (s2.equals(s1)) ...          // same thing
      if (s1.equals(s2) == true) ...  // same thing
      if (s1.compareTo(s2) == 0) ...  // need the == 0
      if (s2.compareTo(s1) == 0) ...  // same thing
          

      To check if strings s1 and s2 are NOT equal:

      
      if (!s1.equals(s2)) ...          // check if equal
      if (!s2.equals(s1)) ...          // same thing
      if (s1.equals(s2) == false) ...  // same thing
      if (s1.equals(s2) != true) ...   // same thing
      if (s1.compareTo(s2) != 0) ...   // need the != 0
      if (s2.compareTo(s1) != 0) ...   // same thing
      if (!(s2.compareTo(s1) == 0)) ...  // same thing
          

    • Use substring() to get portions of a string:

      
      String s2 = "abcdefg"; // number chars 0, 1, 2, 3, 4, 5, 6
      System.out.println(s2.length()); // prints 7
      System.out.println(s2.substring(3, 6)); // prints: def
      System.out.println(s2.substring(1)); // prints: bcdefg (drops first char)
      System.out.println(s2.substring(2)); // prints: cdefg (drops first 2 chars)
      System.out.println(s2.substring(3)); // prints: defg (drops first 3 chars)
          

  • Here's an outline for the CombinationLock class that we developed in class: Start of CombinationLock.

  • When you first test your program to see if it is working, first use the first 4 bulleted items in Lab 10:
    • Instantiate a lock with the combination "ABC".
    • Try opening the lock by using the setPosition() method 3 times with the following sequence "A", "B", "D"
    • Try to unlock the lock using the unlock() method
    • Make sure the lock did not open by printing the result of the isOpen() method

    Then try the same 4 items again, except use setPosition() 3 times with "A", "B", "C", so that this time you can check that the lock did open.

  ---

• Here are two extra examples from the Week 13 Lecture about loops.
  • The Three-Halves Problem: Three-Halves Problem.
  • The Loop Patch Example: Loop Patch Example.

  ---

• Hints for Lab 11:

  The basis for this lab is a certain "magic formula" that computes square roots. (The formula comes from calculus, but it's plausible without knowing calculus, and you can just use it without understanding it.)

  Here's the idea: we start with a guess for the root, and then we produce a newer, better guess, using the old guess. Call the old and new guesses for the root rold and rnew. Then here is a special case of the magic formula, just for the square root of two:

  rnew = rold/2.0 + 1.0/rold;
  

  Now suppose you execute the magic formula twice, starting with rold = 1 as the initial guess. (Try it!). The result is the same after the second try, because rold is still the same. What we need is to make the new guess be the old guess and try again. So we generate a sequence of statements like the following:

  rold = 1.0;
  rnew = rold/2.0 + 1.0/rold;
  System.out.println("rnew: " + rnew); // prints: rnew: 1.5
  rold = rnew;
  
  rnew = rold/2.0 + 1.0/rold;
  System.out.println("rnew: " + rnew); // prints: rnew: 1.4166666666666665
  rold = rnew;
  
  rnew = rold/2.0 + 1.0/rold;
  System.out.println("rnew: " + rnew); // prints: rnew: 1.4142156862745097
  rold = rnew;
  
  rnew = rold/2.0 + 1.0/rold;
  System.out.println("rnew: " + rnew); // prints: rnew: 1.4142135623746899
  rold = rnew;
  
  rnew = rold/2.0 + 1.0/rold;
  System.out.println("rnew: " + rnew); // prints: rnew: 1.414213562373095
  

  The digits in red above inside the comments are correct, so we end up with a very accurate value for the square root of 2. The code above keeps repeating the same three statements over and over, so it almost cries out to be put into a loop. You keep executing as long as the new guess squared and two are not "too close", using some measure such as 0.00001.

  There is quite a bit more to the lab, but this gives you an idea how it is working.

  ---

• Here is an extra example from the Week 14 Lecture:
  • Simulation of Roulette gambling: Gambling.

  ---

• Hints for Lab 12:

  Be careful with the basic calculation, illustrated in the lab write up with:

  5/15 * 150000 == 50000
  

  If you were just working with integers, you could write this as:

  5 * 150000 / 15 == 50000
  

  since otherwise, 5/15 would be 0. Alternatively, you could do the calculation as all doubles and then cast to an int.

  ---

  One way to approach this lab is to just try to be able to print the "Depreciation Chart". Below in red is the original chart with two more columns to help keep it straight:

  OriginalCost: 200000, FinalValue: 50000, YearsDepreciated: 5
  
  Year Depreciation  totalDepreciated  depreciatedValue
  1       50000           50000           150000
  2       40000           90000           110000
  3       30000           120000          80000
  4       20000           140000          60000
  5       10000           150000          50000
  

  Here is another possible chart with original cost of 50000, final value of 10000, and depreciated over 4 years.

  OriginalCost: 50000, FinalValue: 10000, YearsDepreciated: 4
  
  Year Depreciation  totalDepreciated  depreciatedValue
  1       16000           16000           34000
  2       12000           28000           22000
  3       8000            36000           14000
  4       4000            40000           10000
  

  Here is another possible chart with original cost of 60000, final value of 0, and depreciated over 5 years.

  OriginalCost: 60000, FinalValue: 0, YearsDepreciated: 5
  
  Year Depreciation  totalDepreciated  depreciatedValue
  1       20000           20000           40000
  2       16000           36000           24000
  3       12000           48000           12000
  4       8000            56000           4000
  5       4000            60000           0
  

  Here is another possible chart with original cost of 1000000, final value of 200000, and depreciated over 10 years. In this example, why do you think that the final depreciated value is 200005, instead of exactly 200000.

  OriginalCost: 1000000, FinalValue: 200000, YearsDepreciated: 10
  
  Year Depreciation  totalDepreciated  depreciatedValue
  1       145454          145454          854546
  2       130909          276363          723637
  3       116363          392726          607274
  4       101818          494544          505456
  5       87272           581816          418184
  6       72727           654543          345457
  7       58181           712724          287276
  8       43636           756360          243640
  9       29090           785450          214550
  10      14545           799995          200005
  

  ---

• Comments about Project 3:
  • Note that if you declare a method static (as the main method is declared), then it can be called from the class without creating an instance of the class. Thus the sqrt method in the Math class is static, and we can call it just using Math.sqrt(2), without creating an instance of the Math class.

    Activity 2 in the Week 15 lectures uses static methods, and your methods in the Series class of Project 3 should also be static.

    We often use static methods when only one instance of the method is needed. (There is no need for more than one sqrt method.)

  • Part of the directions for Project 3 say: Use a do-while loop to ask the user if they would like to continue entering numbers. In this loop test your method using 100, 1000, 10000, 100000. Early in the Week 14 Lecture is a model for asking the user if he wants to continue entering numbers, with an anticipated Y or y for yes. In this case, the code used the charAt method of the String class, but you could also use the eqauls method of String to compare the user's answer directly with the string "Y" or with the string "y". Here is a page illustrating this: Repeated Input in Java.

  • The loops required in the methods for the project are actually second cousins to the ones in the review for the final.

  • We hadn't gone over a fact function in class, and I didn't realize that it wasn't in the lecture notes. Here is a version that should work in the Series class:

    private static double fact(double x){
       double result = 1;
       for(int k = 2; k <= x; k++){
          result = result * k;
       }
       return result;
    }

    This can be declared private because it is only used inside Series. It must be declared static because it is used without creating an instance of the Series class.