Help on understanding this code

[Stacey Johnson]

Hello everyone,
Here I am agian struggling to figure things out. Right now I am trying to understand this class and test program to go with. I just don't understand how it works. Can anyone take a look at it and give me some insight. In my assignment I'm suppose to use the following class (Rational Class) and write a program thta will compute a summation series as follows:
1/1 + 1/2 + 1/3 +... +1/n
1/1 + 1/2 + 1/2exponent2 +...+ 1/2exponentn
So I figure I need a better understanding of this class before I attempt a program for the above.
One other thing is can someone explain the "tostring()" method to me?
The Rational Class is as follows:

// Rational.java: Define a rational number and its associated
// operations such as add, subtract, multiply, and divide
// the divide method throws an exception
public class Rational extends Number implements Comparable {
  // Data fields for numerator and denominator
  private long numerator = 0;
  private long denominator = 1;
  /** Default constructor */
  public Rational() {
    this(0, 1);
  }
  /** Construct a rational with specified numerator and denominator */
  public Rational(long numerator, long denominator) {
    long gcd = gcd(numerator, denominator);
    this.numerator = numerator/gcd;
    this.denominator = denominator/gcd;
  }
  /** Find GCD of two numbers */
  private long gcd(long n, long d) {
    long t1 = Math.abs(n);
    long t2 = Math.abs(d);
    long remainder = t1%t2;
    while (remainder != 0) {
      t1 = t2;
      t2 = remainder;
      remainder = t1%t2;
    }
    return t2;
  }
  /** Return numerator */
  public long getNumerator() {
    return numerator;
  }
  /** Return denominator */
  public long getDenominator() {
    return denominator;
  }
  /** Add a rational number to this rational */
  public Rational add(Rational secondRational) {
    long n = numerator*secondRational.getDenominator() +
      denominator*secondRational.getNumerator();
    long d = denominator*secondRational.getDenominator();
    return new Rational(n, d);
  }
  /** Subtract a rational number from this rational */
  public Rational subtract(Rational secondRational) {
    long n = numerator*secondRational.getDenominator()
      - denominator*secondRational.getNumerator();
    long d = denominator*secondRational.getDenominator();
    return new Rational(n, d);
  }
  /** Multiply a rational number to this rational */
  public Rational multiply(Rational secondRational) {
    long n = numerator*secondRational.getNumerator();
    long d = denominator*secondRational.getDenominator();
    return new Rational(n, d);
  }
  /** Divide a rational number from this rational */
  public Rational divide(Rational secondRational)
    throws RuntimeException {
    if (secondRational.getNumerator() == 0)
      throw new RuntimeException("Divisor cannot be zero");
    long n = numerator*secondRational.getDenominator();
    long d = denominator*secondRational.getNumerator();
    return new Rational(n, d);
  }
  /** Override the toString() method */
  public String toString() {
    if (denominator == 1)
      return numerator + "";
    else
      return numerator + "/" + denominator;
  }
  /** Override the equals method */
  public boolean equals(Object parm1) {
    /** @todo: Override this java.lang.Object method */
    if ((this.subtract((Rational)(parm1))).getNumerator() == 0)
      return true;
    else
      return false;
  }
  /** Override the intValue method */
  public int intValue() {
    /** @todo: implement this java.lang.Number abstract method */
    return (int)doubleValue();
  }
  /** Override the floatValue method */
  public float floatValue() {
    /** @todo: implement this java.lang.Number abstract method */
    return (float)doubleValue();
  }
  /** Override the doubleValue method */
  public double doubleValue() {
    /** @todo: implement this java.lang.Number abstract method */
    return numerator*1.0/denominator;
  }
  /** Override the longValue method */
  public long longValue() {
    /** @todo: implement this java.lang.Number abstract method */
    return (long)doubleValue();
  }
  /** Override the compareTo method */
  public int compareTo(Object o) {
    /** @todo: Implement this java.lang.Comparable method */
    if ((this.subtract((Rational)o)).getNumerator() > 0)
      return 1;
    else if ((this.subtract((Rational)o)).getNumerator() < 0)
      return -1;
    else
      return 0;
  }
}

And the testprogram:

// TestRationalClass.java: Demonstrate using the Rational class
public class TestRationalClass {
  /** Main method */
  public static void main(String[] args) {
    // Create and initialize two rational numbers r1 and r2.
    Rational r1 = new Rational(4, 2);
    Rational r2 = new Rational(2, 3);
    // Display results
    System.out.println(r1.toString() + " + " + r2.toString() +
      " = " + (r1.add(r2)).toString());
    System.out.println(r1.toString() + " - " + r2.toString() +
      " = " + (r1.subtract(r2)).toString());
    System.out.println(r1.toString() + " * " + r2.toString() +
      " = " + (r1.multiply(r2)).toString());
    System.out.println(r1.toString() + " / " + r2.toString() +
      " = " + (r1.divide(r2)).toString());
  }
}

Thanks
Stacey

[Carlos Failde]

The Java Tutorial

Object contains the toString method, which returns a String object containing the name of the object's class and its hash code. Most, if not all, classes will want to override this method and print out something meaningful for that class.

toString()

Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.

The above class overrides toString to return a representation of a rational nubmer.
Incidentally the println's in TestRationalClass could have been simplified:

    System.out.println(r1 + " + " + r2 + " = " + r1.add(r2) );
    System.out.println(r1 + " - " + r2 + " = " + r1.subtract(r2) );
    System.out.println(r1 + " * " + r2 + " = " + r1.multiply(r2) );
    System.out.println(r1 + " / " + r2 + " = " + r1.divide(r2) );

as the toString() method is automatically invoked when you concatenate an object and a string