Question

Consider a class Fraction of fractions. Each fraction is signed and has a numerator and a denominator that are integers. Your class should be able to add, subtract, multiply, and divide two fractions. These methods should have a fraction as a parameter and should return the result of the operation as a fraction. The class should also be able to find the reciprocal of a fraction, compare two fractions, decide whether two fractions are equal, and convert a fraction to a string.

Your class should handle denominators that are zero. Fractions should always occur in lowest terms, and the class should be responsible for this requirement. For example, if the user tries to create a fraction such as 4/8, the class should set the fraction to 1/2. Likewise, the results of all arithmetic operations should be in lowest terms. Note that a fraction can be improper—that is, have a numerator that is larger than its denominator. Such a fraction, however, should be in lowest terms.

Design the class Fraction. Begin by writing a CRC card for this class. Then write a Java interface that declares each public method.

To reduce a fraction such as 4/8 to lowest terms, you need to divide both the numerator and the denominator by their greatest common denominator. The greatest common denominator of 4 and 8 is 4, so when you divide the numerator and denominator of 4/8 by 4, you get the fraction 1/2. The following recursive algorithm finds the greatest common denominator of two positive integers:

Algorithm gcd(integerOne, integerTwo)

if (integerOne % integerTwo == 0)

result = integerTwo

else

result = gcd(integerTwo, integerOne % integerTwo) return result

It will be easier to determine the correct sign of a fraction if you force the fraction’s denominator to be positive. However, your implementation must handle negative denominators that the client might provide.

Write a program that adequately demonstrates your class.

Answer 1

Fraction

Responsibilities

Set the fraction

Add two fractions

Subtract two fractions

Multiply two fractions

Divide two fractions

Reciprocal of a fraction

Compare two fractions

Convert fraction to string

Minimize the fraction

Display the fraction

Collaborations

/* Code */

class Fraction
{
   /*Instance variables n=numerator and d=Denominator*/
   int n;
   int d;
  
   /* Parameterless constructor */
   Fraction()
   {
       n=0;
       d=1;
   }
   /* Parameterized constructor */
   Fraction(int n, int d)
   {
       try{
       if(d==0) throw new ArithmeticException(); // checking denominator is zero or not. If zero then throw ArithmeticException

/* checking denominator is negative or not. If denominator is positive then make sure it to be positive*/

if(d<0) {
           d=-d;
           n=-n;
       }
  
       /* Minimize the fraction */
       int g=gcd(n,d);
       this.n=n/g;
       this.d=d/g;
       }
       catch(ArithmeticException e)
       {
           System.out.println("Denominator is zoro");
       }
   }
  
   /* Method to display the fraction */  
   public void show()
   {
       System.out.println("Fraction is:"+n+"/"+d);
   }
  
   /* Method to add two fractions */  
   public Fraction add(Fraction f)
   {
       Fraction temp = new Fraction();
       temp.n = this.n * f.d + f.n * this.d;
       temp.d = this.d * f.d;
       temp.minimize();
       return temp;
   }
  
   /* Method to subtract two fractions */  
   public Fraction subtract(Fraction f)
   {
       Fraction temp = new Fraction();
       temp.n = this.n * f.d - f.n * this.d;
       temp.d = this.d * f.d;
       temp.minimize();
       return temp;
   }
  
   /* Method to multiplication two fractions */  
   public Fraction mult(Fraction f)
   {
       Fraction temp = new Fraction();
       temp.n = f.n * this.n;
       temp.d = f.d * this.d;
       temp.minimize();
       return temp;
   }
  
   /* Method to division two fractions */  
   public Fraction div(Fraction f)
   {
       Fraction temp = new Fraction();
       temp.n = f.d * this.n;
       temp.d = f.n * this.d;
       temp.minimize();
       return temp;
   }
  
   /* Method to find reciprocal of a fraction */  
   public Fraction reciprocal()
   {
       Fraction temp = new Fraction();
       temp.n = this.d;
       temp.d = this.n;

       return temp;
   }
  
   /* Method to compare two fractions */  
   public boolean compareTo(Fraction f)
   {
       if(this.n == f.n && this.d==f.d) return true;
       else return false;
   }
  
   /* Method to minimize a fraction */  
   public void minimize()
   {
       int g=gcd(this.n,this.d);
       this.n /= g;
       this.d /= g;
   }
  
   /* Method to find our gcd of two numbers */  
   static int gcd(int a, int b)
   {
       if(a==0) return b;
       return gcd(b%a,a);
   }
  
   /* Method to convert from fraction to string */  
   public String toString()
   {
       return "Fraction is:"+n+"/"+d;
   }
  
}

class Demo{
   public static void main (String[] args) {
      
       /* create two fraction objects */
       Fraction f1 = new Fraction(2,4);
Fraction f2 = new Fraction(1,2);
      
       /* display the fraction objects */
       f1.show();
       f2.show();
      
      
       System.out.println("Result of addition");
       Fraction f3 = f1.add(f2);
       f3.show();
      
       System.out.println("Result of subtraction");
       Fraction f4 = f1.subtract(f2);
       f4.show();
      
       System.out.println("Result of multiplication");
       Fraction f5 = f1.mult(f2);
       f5.show();
      
       System.out.println("Result of division");
       Fraction f6 = f1.div(f2);
       f6.show();
      
       System.out.println("Result of reciprocal");
      Fraction f7 = f1.reciprocal();
       f7.show();
      
       System.out.println("Result of fraction comparison");
   boolean b = f1.compareTo(f2);
   System.out.println(b);
  
   System.out.println("Convert to string");
      
       System.out.println("F1="+f1.toString());
  
}
}

/* Snapshot of output screen */