Summary: In this lab, you will write and experiment with objects of your first class. Our goal is to design, implement, and test a Fraction class -- a way to represent exact rational numbers as objects in Java.

Preparation

1. Make a directory for the files you'll create in this lab.

     mkdir somewhere/objects

2. Go to your new directory.

    cd somewhere/objects

3. Copy an example class to your current directory

    cp ~weinman/public_html/courses/CSC207/2011S/labs/code/objects/TestBigInteger.java .

Exercises

Exercise 1

import java.math.BigInteger;

/** Demonstration of BigInteger objects
 *
 * @author John David Stone
 * @author Jerod Weinman
 * @author YOUR NAME HERE
 */
public class TestBigInteger
{
  public static void main(String[] args)
  {
    BigInteger augend = new BigInteger("3000000000000000000000000000");
    BigInteger addend = new BigInteger("5000000000000000000000000000");

    BigInteger sum = augend.add(addend);

    System.out.println(sum);
  }

}

1. Look over the documentation for the BigInteger class and acquaint yourself with the methods for addition, subtraction, negation, multiplication, and division.
2. Modify the class TestBigInteger so that it also prints out the quotient and the remainder when the product of seven trillion and ninety-six trillion is divided by seventeen million three hundred and nineteen.

Exercise 2

1. In a file called Fraction.java, write the definition for a class that has two BigInteger fields called numerator and denominator. Should these fields be static? What visibility should they have? Justify your answers.
2. Write a two-argument constructor for the Fraction class. It should take two arguments, each a BigInteger, and store the arguments in the appropriate fields.
3. Write a second two-argument constructor for the Fraction class. It should take two arguments, each an int. From each argument, the constructor should then build a BigInteger with the same value and store that BigInteger into the corresponding field.

   (Hint: Invoke a this-constructor to make the code very short.)

   Note that the BigInteger constructor needs a String as its argument. That's actually a pretty inefficient way to get a BigInteger object. Examine the class methods (static) of BigInteger for a better way.

4. Revise your constructors so that it throws an ArithmeticException (which is an unchecked exception type) when an attempt is made to construct a Fraction in which the denominator is zero. (If you followed the hint in part c, you'll only have to change one of the constructors.)

Exercise 3

For instance, in ordinary arithmetic, fractions are usually represented as having only positive numbers as denominators; when, in our computations, we find a negative number in the denominator, we reverse its sign and the sign of the numerator in presenting our result. For instance, we write "-3/5" rather than "3/-5", even though theoretically these express the same rational number. Similarly, we'd always write "5/7" rather than "-5/-7".

Similarly, fractions are usually expressed "in lowest terms" -- any divisors common to the numerator and denominator are cancelled in the final form. For instance, we'd write "2/5" rather than "24/60". That is to say, we divide both the numerator and the denominator by their greatest common divisor, in this case 12, to express the fraction in lowest terms.

1. Revise your constructor(s) so that, if the proposed denominator is negative, both the proposed numerator and the proposed denominator are negated before they are stored the corresponding fields.
2. Revise your constructors so that the fraction is stored in lowest terms, with the numerator and the denominator having no common divisors greater than 1. (Hint: The BigInteger class supports a method that computes the greatest common divisor of two BigIntegers.)

Exercise 4

1. The product of two rational numbers a/b and c/d is (ac)/(bd). Add a multiply method to your Fraction class that takes a Fraction as argument and multiplies the fraction to which the message is sent by the fraction supplied as argument, returning the product (as a Fraction, of course). Will the product that you return always be expressed in lowest terms?
2. The sum of of two rational numbers a/b and c/d is (ad + bc)/(bd). Add an add method to your Fraction class that takes a Fraction as argument and adds it to the fraction to which the message is sent, returning the sum as a Fraction.
3. Add a similar subtract method to your Fraction class.
4. Add a negate method that takes no arguments and returns the negative of the fraction to which the message is sent.
5. Add a reciprocal method that takes no arguments and returns the reciprocal of the fraction to which the message is sent (i.e., a new fraction with the numerator and denominator swapped). Ensure that your method throws an ArithmeticException if it is sent to a fraction in which the numerator is zero.
6. Add a similar quotient method to your Fraction class, throwing an ArithmeticException if the numerator of the divisor is zero. Note that the quotient of any two non-zero rational numbers can always be expressed exactly as a rational number, so there is no need of a remainder in this case.

Exercise 5

1. Add a toString method to your Fraction class that takes no arguments and returns a string formed by concatenating the string representation of the numerator, a slash character, and the string representation of the denominator.
2. Test your work by writing a main method that constructs some fractions, prints out their string representations, performs some arithmetic on them, and prints out the results.