Algorithms and OOD (CSC 207 2014F) : Labs

# Laboratory: Designing Your Own Classes

Summary: In this laboratory, you will extend your knowledge of numeric values in Java.

Primary Classes Used:

GitHub Repository: `https://github.com/Grinnell-CSC207/lab-classes`.

## Exercises

### Preparation

Fork and clone the repository.

Read through the code to make sure that you understand what it does.

### Exercise 1: Multiplication

a. Extend the `Fraction` class so that it permits multiplication of two fractions. That is, you should add an appropriate `multiply` method to the class.

b. Write an experiment that allows you to explore the behavior of the new method.

### Exercise 2: Fractional Portions

As you may know, we can represent every non-negative rational number as a whole number plus a fractional value no smaller than 0 and strictly less than 1.

a. Write a method of the `Fraction` class, `fractional`, that identifies and returns this fractional value as a `Fraction`. Your procedure need only work for positive numbers. Here are some tests that illustrate what it's supposed to do.

```@Test
public void testFractional()
{
Fraction f = new Fraction(11,3);
assertEquals("2/3", f.fractional().toString());

f = new Fraction(1,2);
assertEquals("1/2",  f.fractional().toString());

f = new Fraction (5,2);
assertEquals("1/2", f.fractional().toString());

f = new Fraction(4,2);
assertEquals("0/2", f.fractional().toString());
} // testFractional()
```

b. Test your procedure and correct any errors.

### Exercise 3: From String to Fraction

Write and test a third constructor for the `Fraction` class. This constructor should accept a string as a parameter, “parse” that string, and generate the appropriate fraction. For example,

```public static void
stringConstructorTest()
{
Fraction f = new Fraction("1/4");
assertEquals(1, f.numerator());
assertEquals(4, f.denominator());
f = new Fraction("11/5");
assertEquals(11, f.numerator());
assertEquals(5, f.denominator());
f = new Fraction("120/3");
assertEquals(40.0, f.toReal(), 0.0001);
} // stringConstructorTest()
```

You can expect that the string will have two positive integers separated by a slash. You may find it useful to reflect on the `indexOf` method of the `java.lang.String` class and on various static methods of the `java.lang.BigInteger` class.

### Exercise 4: A Counter Class

Write and test (or experiment with) a class, `Counter`, that generates objects that can count. Objects in class `Counter` should provide two methods: `increment`, which adds 1 to the counter, and `get`, which gets the current value of the counter. Your class needs one zeroary constructor which initializes the counter to 0.

Make sure to verify that if you create two separate `Counter` objects, you can change the two objects separately.

### Exercise 5: Printing Counters

a. If you've included a `toString` method in `Counter`, comment it out.

b. What do you expect to happen if we print out a `Counter` using instructions like the following?

```  PrintWriter pen = new PrintWriter(System.out, true);
Counter c1 = new Counter();
Counter c2 = new Counter();
c1.increment();
c1.increment();
c2.increment();
pen.println("c1: " + c1);
pen.println("c2: " + c2);
```

d. As you should have discovered, when a class lacks a `toString` method, Java chooses a fairly naive representation for printing objects in that class. Add an appropriate `toString` method (e.g., one that returns the counter surrounded by angle brackets). Then verify that the lines above work as you expect.

### Exercise 6: Enhancing Counters

a. Update your `Counter` class to include a second constructor that allows the user to specify a starting value.

b. Update your `Counter` class to include a `reset` method that reset the counter to the starting value.

c. Test (or experiment with) both updates to ensure that they work appropriately.

## For Those With Extra Time

### Extra 1: Further Enhancing Counters

Identify other methods that would be useful to include in the `Counter` class and add them.

### Extra 2: Further Enhancing Fractions

Identify other methods that would be useful to include in the `Fraction` class and add them.