Lab 8: Classes and Objects

Introduction

In this lab, you'll learn how to write basic object-oriented programs.

Setup

Create a lab08 directory in your cs124 directory to hold the files for this lab. Copy the files from /classes/s08/cs124/labs/lab08/ to your lab08 directory.

Classes and Objects

This lab covers Sections 5.1 through 5.4 of the book. If you don't have your book with you, the book can be found online at http://math.hws.edu/javanotes5/.

Exercises

Here are the exercises for this week's lab, due next Thursday.

Within a file called Counter.java write a class called Counter that represents a counter that counts 0, 1, 2, 3, 4, .... The Counter class should have one private instance (i.e., non-static) variable representing the value of the counter. It also has two instance (i.e., non-static) methods: increment() adds one to the counter value, and getValue() returns the current counter value.

Within a second file called CoinToss.java, You will then write another class called CoinToss that simulates 100 coin tosses and keeps track of the number of heads and tails using two counter objects: headCount and tailCount. Your class CoinToss will look like the following, although you will have to fill in the blanks (i.e., _____________________):
```
class CoinToss {
  public static void main(String[] args) {
    Counter headCount, tailCount;
    headCount = new Counter();
    tailCount = new Counter();
    for (int flip = 0; flip < 100; flip++) {
      if (Math.random() < 0.5)
        _____________________;
      else
        _____________________;
    }
    System.out.println("There were " + _____________________ + " heads.");
    System.out.println("There were " + _____________________ + " tails.");
  }
}
```
When you have completed both classes, compile each file and run the program using the following:
```
bash$ javac Counter.java
bash$ javac CoinToss.java
bash$ java CoinToss
```
Note: you need to compile both files (actually, in some scenarios you only need to compile one file, but just to be safe you should compile both) and run only the second file, since the second file contains the main method.
Within the file Die.java create a class called Die that represents a single, 6-sided die (like the die used in games such as Craps). In particular, your Die class should contain the following:
- An instance variable (an int) called value that represents the current value on the top side of the die (i.e., value that was last rolled). Intially, value should start at 1 (before the die has been rolled). This variable should not be accessible from outside the Die class.
- A (non-static) method called roll(), which takes no parameters and returns nothing, for rolling the die (i.e., setting randomly to a value between 1 and 6).
- A (non-static) method called getValue() for obtaining the current value on the top-side of the die. It takes no parameters and returns the current value of the die.
After you finish writing Die.java, open the provided file Craps.java, which contains the program you wrote for lab 4. Modify the class Craps to use Die objects to simulate rolling the dice rather than ints. You will need to change the die1 and die2 variables to type Die rather than int and manipulate them as Die objects (i.e., use the methods that you wrote in the Die class). There should be no calls to Math.random() when you have finished modifying the Craps class.

When you finish modifying Craps.java, compile both Die.java and Craps.java, and run Craps. Make sure the program works like it's supposed to (the probability should be around 49.3% chance of winning).
Within a file called BankAccount.java create a class called BankAccount to represent a bank account. In particular, the class should have the following elements:
- An instance variable representing the current balance in the account. This variable should not be accessible from outside the class.
- A (non-static) method called getBalance, which returns the current balance.
- A (non-static) method called deposit, which takes the amount to deposit as a parameter and adjusts the balance accordingly. If a amount is deposited that is less than 0, then the the transaction should be ignored (i.e., the balance should not be changed).
- A (non-static) method called withdraw, which takes the amount to withdraw as a parameter and adjusts the balance accordingly. The balance should not be allowed to fall below 0, so a withdrawal which would cause this should not occur (i.e., the withdrawal should not change the balance). In addition, withdrawals of amounts less than 0 should be ignored (i.e., the balance should not be changed).
After you finish writing BankAccount.java create a class called Banking.java, which contains a single main method. The main method should create two BankAccount objects, deposit and withdraw amounts from them, and print the balance after each transaction. Make sure that you call each method in the BankAccount class at least once.

When you finish writing Banking.java, compile both BankAccount.java and Banking.java and run Banking. Make sure that your program works correctly.
In this exercise, you will write your own String class called NewString. You may not use the original, built-in String class in Java to implement NewString, but instead, will implement NewString using an array of characters. This array will represent the state of each NewString object. Your NewString class will also contain constructors and methods (similar to the String class) for manipulating the string.

Below is a list of the variables and methods you will need to define in your NewString class. In particular, your NewString class should contain the following:
- An instance, character array variable called charArray for holding the sequence of characters that the string represents.
- A constructor, which takes as input an array of characters that the string will represent. Your constructor should copy the characters in this array parameter to charArray.
- A (non-static) method called length that returns the length of the sequence of characters.
- A (non-static) method called charAt for accessing the nth character of the string. The method takes as a parameter an int n, which is the index of the character to return. The method returns the nth character. If n is out of bounds (i.e., less than 0 or greater than or equal to the length of the string) then your method should print an error message and exit.
- A (non-static) method called equals for comparing the contents of two NewString objects (i.e., the characters in both arrays). The method takes as input a single NewString object. The other NewString is the instance object on whose behalf we are running the method. For example, ns.equals(ns2) compares ns with ns2. Only ns2 has to be passed as a parameter. The equals method will run inside of the ns object. The method returns a boolean indicating whether the two NewString objects contain the same sequence of characters.
- A (non-static) method called concat for concatenating (or appending) one NewString to another. The method takes as input a single NewString object. The other NewString is the instance object on whose behalf we are running the method (owner object). The method then builds a new NewString whose array of characters contain the characters from the owner object followed by the characters from the parameter object.
If you're having trouble understanding how any of the methods above should work, test them out with conventional Strings. Your NewString methods should work similarly.

Write your NewString class in the file NewString.java. In addition, write a class NewStringTest in a file called NewStringTest.java, which contains a main() method for testing your NewString class. Write some code that creates some NewString objects and calls the various methods. Your code should call each method you wrote in NewString at least once.

Handin

Verify that your lab08 folder contains all of the files you created or modified for this lab (including at least Counter.java, CoinToss.java, Die.java, Craps.java, BankAccount.java, Banking.java, NewString.java, and NewStringTest.java), then copy your entire lab08 folder to the handin directory ~mcorliss/handin/124/username (where username is replaced with your username).