What is Java fraction?

Part I-IV recommend code changes as mentioned in link 1, for the initial code given at link 2.

Can you please review the code changes for Part I-IV?

Part I: Constructors (1 point)

Modify the no-parameter constructor to call the two-parameter constructor. Then, fill in the fourth constructor so that it uses the good style and correctly duplicates the input Fraction (it does neither now). Your TA or lab assistant will ask to see your constructors when you get checked off.

Part II: Using Objects (1 point)

Further on in the main method, there are four lines commented out. Remove the comment markers and fill in the two missing expressions so that sumOfTwo is the sum of f1 and f2, and sumOfThree is the sum of f0, f1, and f2.

Part III: Defining Classes (1 point)

The changeNumerator and fracs methods don’t work. Fix them. You may NOT change their signatures. Each fix should require the addition of just one word. These changes may or may not be in the methods themselves.

Part IV: Conditionals and Recursive Functions (1 point)

Rewrite the body of gcd so that it is a recursive function that correctly computes the GCD. Recompile and run your program.

Here are the code changes that are made as shown below:

/* Fraction.java */
import java.io.*;
/** The Fraction class implements nonnegative fractions--rational numbers.
 */
class Fraction {
  /* private fields within a Fraction. */
  private static  int numberOfFractions = 0;
  private int numerator;
  private int denominator;
  /** Constructs a Fraction n/d. 
   *  @param n is the numerator.  Must be nonnegative.
   *  @param d is the denominator.  Must be positive.
   */
  public Fraction(int n, int d) {
    if (n < 0>      System.out.println("Fatal error:  Negative numerator.");
      System.exit(0);
    }
    if (d < 1>      System.out.println("Fatal error:  Non-positive denominator.");
      System.exit(0);
    }
    numberOfFractions++;
    this.numerator = n; 
    this.denominator = d;
  }
  /** Constructs a Fraction n/1. 
   *  @param n is the numerator.  Must be nonnegative.
   */
  public Fraction(int n) {
    this(n, 1);
  }
  /** Constructs a Fraction 0/1. 
   */
  public Fraction() {
    this(0,1);
  }
  /** Copies the Fraction "original".
   */
  public Fraction(Fraction original) {
    this(original.numerator,original.denominator);
  }
  /** Converts this Fraction to a string format:  "numerator/denominator."
   *  Fractions should be printed in reduced form (part of your assignment is
   *  to make this true).
   *  @return a String representation of this Fraction.
   */
  public String toString() {
    in thisGcd = gcd(numerator, denominator);
    return (numerator / thisGcd + "/" + denominator / thisGcd);
  }
  /** Return the sum of two fractions.
   *  @param f2 is the Fraction to be added.
   *  @return the result of adding f2 to this Fraction.
   */
  public Fraction add(Fraction f2) {
    Fraction r = new Fraction((numerator * f2.denominator) +
                  (f2.numerator * denominator),
                  denominator * f2.denominator);
    return r;
  }
  /** Replaces this Fraction's numerator with a new value.
   *  @param numerator is the new numerator.  Must be nonnegative.
   */
  public void changeNumerator(int numerator) { // DO NOT CHANGE THIS SIGNATURE!
    // Fix the bug that prevents this method from working correctly.
    if (numerator < 0>      System.out.println("Fatal error:  Negative numerator.");
      System.exit(0);
    }
    this.numerator = numerator;
  }
  /** Returns the number of Fraction objects in existence.
   *  @return the number of Fraction objects in existence.
   */
  public static int fracs() {                         // DO NOT CHANGE THIS SIGNATURE!
    // Fix the bug that prevents this method from working correctly.
    return numberOfFractions;
  }
/** Computes the greatest common divisor (gcd) of the two inputs.
   * @param x must be nonnegative
   * @param y must be nonnegative
   * @return the gcd of x and y
   */
  static private int gcd (int x, int y) {
    /* Replace the following line with your solution. */
      if (y == 0)
          return x;
      else
          return gcd(y,x%y);
  }
 /** Put the Fraction class through some tests.
   * @param argv is not used.
   */
  public static void main(String[] argv) {
 /* Test all four constructor and toString. */
    Fraction f0 = new Fraction();
    Fraction f1 = new Fraction(3);
    Fraction f2 = new Fraction(12, 20);
    Fraction f3 = new Fraction(f2);
 System.out.println("nTesting constructors and toString():");
    System.out.println("The fraction f0 is " + f0.toString());
    System.out.println("The fraction f1 is " + f1);    // toString is implicit.
    System.out.println("The fraction f2 is " + f2);
    System.out.println("The fraction f3 is " + f3 + ", which should equal f2");
    /* Test the add method. */
    System.out.println("nTesting add:");
 Fraction sumOfTwo = f1.add(f2);              // Sum of f1 and f2.
    Fraction sumOfThree = f0.add(sumOfTwo);            // Sum of f0, f1, and f2.
 System.out.println("The sum of " + f1 + " and " + f2 + " is " + sumOfTwo);
    System.out.println("The sum of " + f0 + ", " + f1 + " and " + f2 + " is " +
                       sumOfThree);
  /* Test the methods used in Part III. */
    System.out.println("nTesting changeNumerator and fracs:");
    f3.changeNumerator(7);
    System.out.println("Now f3 is " + f3 + ", which should be 7/20");
    System.out.println("The total number of Fraction objects is " +
                    fracs());
 /* Test gcd function (static method). */
    System.out.println("nTesting gcd:");
    System.out.println("The gcd of 2 and 10 is: " + gcd(2, 10));
    System.out.println("The gcd of 15 and 5 is: " + gcd(15, 5));
    System.out.println("The gcf of 24 and 18 is: " + gcd(24, 18));
    System.out.println("The gcd of 10 and 10 is: " + gcd(10, 10));
    System.out.println("The gcd of 21 and 400 is: " + gcd(21, 400));
  }
}