Question

When we test your Fraction.java we will use the given FractionTester.java file. Your Fraction.java file -MUST- work perfectly with the supplied FractionTester.java file. You may NOT modify the FractionTester to make your Fraction class work right.

Starter Fraction File: Fraction.java ADD METHODS TO THIS FILE. HAND IN THIS FILE ONLY.

Given/Completed Tester File: FractionTester.java DO NOT MODIFY. DO NOT HAND IN.

You are to add the following methods to the given Fraction.java file

public Fraction add( Fraction other) returns a Fraction that is the sum of the two Fractions.

public Fraction subtract( Fraction other) returns a Fraction that is the difference between this Fraction minus the other Fraction.

public Fraction multiply( Fraction other) returns a Fraction that is the product of the two Fractions.

public Fraction divide( Fraction other) returns a Fraction that is the quotient of the two Fractions.

public Fraction reciprocal() returns a Fraction that is the reciprocal of this Fractions.

private void reduce() Does not return a Fraction. It just modifies this Fraction by reducing it to its lowest form.

You must keep every Fraction reduced at all times. Every new fraction constructed it must be reduced before the constructor exits. No Fraction at any time may be stored in a form other than its reduced form. This makes the outputted value of the Fraction consistent in all cases.

All methods except reduce() must be a single return statement of the form:
return new Fraction(...); -OR- return (a call to another Fraction method)

/*
        FractionTester.java  A program that declares Fraction variables
        We will test your Fraction class on THIS tester.
*/
public class FractionTester
{
        public static void main( String args[] )
        {
                // use the word Fraction as if were a Java data type
                Fraction f1 = new Fraction( 44,14 ); // reduces to 22/7
                System.out.println( "f1=" + f1 ); // should output 22/7

                Fraction f2 = new Fraction( 21,14 ); // reduces to 3/2
                System.out.println( "f2=" + f2 ); // should output 3/2

                System.out.println( f1.add( f2 ) ); // should output 65/14
                System.out.println( f1.subtract( f2 ) ); // should output 23/14
                System.out.println( f1.multiply( f2 ) ); // should output 33/7
                System.out.println( f1.divide( f2 ) ); // should output 44/21
                System.out.println( f1.reciprocal() ); // should output 7/22

        } // END main
} // EOF

/* Fraction.java  A class (data type) definition file
   This file just defines what a Fraction is
   This file is NOT a program
   ** data members are PRIVATE
   ** method members are PUBLIC
*/
public class Fraction
{
        private int numer;
        private int denom;

        // ACCESSORS
        public int getNumer()
        {
                return numer;
        }
        public int getDenom()
        {
                return denom;
        }
        public String toString()
        {
                return numer + "/" + denom;
        }

        // MUTATORS
        public void setNumer( int n )
        {
                numer = n;
        }
        public void setDenom( int d )
        {
                if (d!=0)
                        denom=d;
                else
                {
                        // error msg OR exception OR exit etc.
                }
        }

        // DEFAULT CONSTRUCTOR - no args passed in
        public Fraction(  )
        {
                this( 0, 1 ); // "this" means call a fellow constructor
        }

        // 1 arg CONSTRUCTOR - 1 arg passed in
        // assume user wants whole number
        public Fraction( int n )
        {
                this( n, 1 ); // "this" means call a fellow constructor

        }

        // FULL CONSTRUCTOR - an arg for each class data member
        public Fraction( int n, int d )
        {
                // you could calc the gcd(n,d) here and then divide both by gcd in the setter calls
                setNumer(n); // i.e. setNumer( n/gcd );
                setDenom(d); // same here
        }

        // COPY CONSTRUCTOR - takes ref to some already initialized Fraction object
        public Fraction( Fraction other )
        {
                this( other.numer, other.denom ); // call my full C'Tor with other Fraction's data
        }

        private void reduce()
        {
                // reduces this fraction to lowest form
        }
}// EOF

Answer 1

Fraction.java

public class Fraction {
   private int numer;
private int denom;

// ACCESSORS
public int getNumer()
{
return numer;
}
public int getDenom()
{
return denom;
}
public String toString()
{
return numer + "/" + denom;
}

// MUTATORS
public void setNumer( int n )
{
numer = n;
}
public void setDenom( int d )
{
if (d!=0)
denom=d;
else
{
throw new IllegalArgumentException("** Denominator Must not be Zero **");
}
}

// DEFAULT CONSTRUCTOR - no args passed in
public Fraction( )
{
this( 0, 1 ); // "this" means call a fellow constructor
}

// 1 arg CONSTRUCTOR - 1 arg passed in
// assume user wants whole number
public Fraction( int n )
{
this( n, 1 ); // "this" means call a fellow constructor

}

// FULL CONSTRUCTOR - an arg for each class data member
public Fraction( int n, int d )
{
   int gcd = this.gcd(n, d);
       // if GCD is negative, change to positive
       if (gcd < 0)
       {
       gcd = -gcd;
       }
setNumer(n/gcd); // i.e. setNumer( n/gcd );
setDenom(d/gcd); // same here
}

// COPY CONSTRUCTOR - takes ref to some already initialized Fraction object
public Fraction( Fraction other )
{
this( other.numer, other.denom ); // call my full C'Tor with other Fraction's data
}

private void reduce()
{
   // determine the greatest common divisor
       int gcd = this.gcd(numer, denom);
       // if GCD is negative, change to positive
       if (gcd < 0)
       {
       gcd = -gcd;
       }
       // divide gcd into both numerator and denominator
       numer = numer / gcd;
       denom = denom / gcd;   
}

//Method which will find Greatest Common Divisor
private Integer gcd(Integer a, Integer b)
{
   // % is modulus which is the remainder of a division
   // base case
   if ((a % b) == 0) {
   return b;
   }
   // recursive case
   else {
   return gcd(b, a % b);
   }
   }
  
//This method is used to add two Fractions
public Fraction add(Fraction f)
{
  

int a=this.numer;
int b=this.denom;
int c=f.numer;
int d=f.denom;
int num=(a*d + b*c);
int den=(b*d);
   Fraction frac=new Fraction(num, den);
frac.reduce();
  
return frac;

}
//This method is used to subtract two Fractions
public Fraction subtract(Fraction f)
{
   int a=this.numer;
int b=this.denom;
int c=f.numer;
int d=f.denom;
int num=(a*d - b*c);
int den=(b*d);
    Fraction frac=new Fraction(num, den);
frac.reduce();
return frac;
}

//This method is used to multiply two Fractions
public Fraction multiply(Fraction f)
{
   int a=this.numer;
int b=this.denom;
int c=f.numer;
int d=f.denom;
int num=(a*c);
int den=(b*d);
    Fraction frac=new Fraction(num, den);
frac.reduce();
return frac;

}

//This method is used to Divide two Fractions
public Fraction divide(Fraction f)
{
   int a=this.numer;
int b=this.denom;
int c=f.numer;
int d=f.denom;
int num=(a*d);
int den=(c*b);
   Fraction frac=new Fraction(num, den);
frac.reduce();
return frac;
}

//This method is used to find the reciprocal of a Fraction
public Fraction reciprocal()
{
   Fraction Frac=new Fraction(denom,numer);
   reduce();
   return Frac;
}
}

___________________

FractionTester.java

public class FractionTester
{
public static void main( String args[] )
{
// use the word Fraction as if were a Java data type
Fraction f1 = new Fraction( 44,14 ); // reduces to 22/7
System.out.println( "f1=" + f1 ); // should output 22/7

Fraction f2 = new Fraction( 21,14 ); // reduces to 3/2
System.out.println( "f2=" + f2 ); // should output 3/2

System.out.println( f1.add( f2 ) ); // should output 65/14
System.out.println( f1.subtract( f2 ) ); // should output 23/14
System.out.println( f1.multiply( f2 ) ); // should output 33/7
System.out.println( f1.divide( f2 ) ); // should output 44/21
System.out.println( f1.reciprocal() ); // should output 7/22

}
}

_______________________

Output:

f1=22/7
f2=3/2
65/14
23/14
33/7
44/21
7/22

________Thank You