IT MUST COMPLIE AND FOLLOW THE RULES THATS ASKED Fraction.Java: /***************
ID: 645146 • Letter: I
Question
IT MUST COMPLIE AND FOLLOW THE RULES THATS ASKED
Fraction.Java:
/*************************************************************************************
*
* This class represents a fraction whose numerator and denominator are integers.
*
* Requirements:
* Implement interfaces: FractionInterface and Comparable (i.e. compareTo())
* Implement methods equals() and toString() from class Object
*
* Should work for both positive and negative fractions
* Must always reduce fraction to lowest term
* For number such as 3/-10, it is same as -3/10 (see hints 2. below)
* Must display negative fraction as -x/y,
* example: (-3)/10 or 3/(-10), must display as -3/10
* Must throw only FractionExcpetion in case of errors
* Must not add new or modify existing data fields
* Must not add new public methods
* May add private methods
*
* Hints:
*
* 1. 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 recursive algorithm which finds the greatest common denominator of
* two positive integers is implemnted (see code)
*
* 2. 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.
*
* 3. You need to downcast reference parameter FractionInterface to Fraction if
* you want to use it as Fraction. See add, subtract, multiply and divide methods
*
* 4. Use "this" to access this object if it is needed
*
Explanation / Answer
package PJ1;
public class Fraction implements FractionInterface, Comparable<Fraction>
{
private int num; // Numerator
private int den; // Denominator
public Fraction()
{
// set fraction to default = 0/1
setFraction(0, 1);
} // end default constructor
public Fraction(int numerator, int denominator)
{
// implement this method!
setFraction(numerator, denominator);
} // end constructor
public void setFraction(int numerator, int denominator)
{
// return FractionException if initialDenominator is 0
// implement this method!
if (denominator == 0)
throw new FractionException("My Exception Occurred");
if (denominator < 0){
numerator = num * -1;
denominator = denominator * -1;
}
num = numerator;
den = denominator;
this.simplify();
} // end setFraction
public double toDouble()
{
// return double floating point value
// implement this method!
return (double)num/den;
} // end toDouble
private int getDenominator(){
return this.den;
}
public FractionInterface add(FractionInterface secondFraction)
{
// a/b + c/d is (ad + cb)/(bd)
// implement this method!
Fraction second = (Fraction)secondFraction;
Fraction addition = new Fraction (((this.num * second.den) + (second.num * this.den)), (this.den * second.den));
addition.simplify();
return addition;
} // end add
public FractionInterface subtract(FractionInterface secondFraction)
{
// a/b - c/d is (ad - cb)/(bd)
// implement this method!
Fraction second = (Fraction)secondFraction;
Fraction subtract = new Fraction (((this.num * second.den) - (second.num * this.den)), (this.den * second.den));
subtract.simplify();
return subtract;
} // end subtract
public FractionInterface multiply(FractionInterface secondFraction)
{
// a/b * c/d is (ac)/(bd)
// implement this method!
Fraction second = (Fraction)secondFraction;
Fraction multiply = new Fraction ((this.num * second.num), (this.den * second.den));
multiply.simplify();
return multiply;
} // end multiply
public FractionInterface divide(FractionInterface secondFraction)
{
// return FractionException if secondFraction is 0
// a/b / c/d is (ad)/(bc)
// implement this method!
Fraction second = (Fraction)secondFraction;
Fraction divide = new Fraction((this.num * second.den), (this.den * second.num));
divide.simplify();
return divide;
} // end divide
public FractionInterface getReciprocal()
{
// return FractionException if secondFraction is 0
// implement this method!
Fraction recip = new Fraction(this.den, this.num); //constructor calls method that will throw Exception
return recip;
} // end getReciprocal
public boolean equals(Object other)
{
// implement this method!
Fraction test = (Fraction)other;
if(test.num == this.num && test.den == this.den)
return true;
return false;
} // end equals
public int compareTo(Fraction other)
{
// implement this method!
int a = this.num * other.den;
int b = this.den * other.num;
if (a > b)
return -1;
else if (a < b)
return 1;
else
return 0;
} // end compareTo
public String toString()
{
return num + "/" + den;
} // end toString
/** Task: Reduces a fraction to lowest terms. */
//-----------------------------------------------------------------
// private methods start here
//-----------------------------------------------------------------
private void reduceToLowestTerms()
{
// implement this method!
//
// Outline:
// compute GCD of num & den
// greatestCommonDivisor works for + numbers.
// So, you should eliminate - sign
// then reduce numbers : num/GCD and den/GCD
int gcd = greatestCommonDivisor(this.num, this.den);
this.num /= gcd;
this.den /= gcd;
} // end reduceToLowestTerms
//Syntactic sugar for reduceToLowestTerms
private void simplify()
{
reduceToLowestTerms();
}
/** Task: Computes the greatest common secondFraction of two integers.
* @param integerOne an integer
* @param integerTwo another integer
* @return the greatest common divisor of the two integers */
private int greatestCommonDivisor(int integerOne, int integerTwo)
{
int result;
if (integerOne % integerTwo == 0)
result = integerTwo;
else
result = greatestCommonDivisor(integerTwo, integerOne % integerTwo);
return result;
} // end greatestCommonDivisor
//-----------------------------------------------------------------
// Simple test is provided here
public static void main(String[] args)
{
FractionInterface firstOperand = null;
FractionInterface secondOperand = null;
FractionInterface result = null;
double doubleResult = 0.0;
Fraction nineSixteenths = new Fraction(9, 16); // 9/16
Fraction Fraction(1, 4); // 1/4
System.out.println(" =========================================");
// 7/8 + 9/16
firstOperand = new Fraction(7, 8);
result = firstOperand.add(nineSixteenths);
System.out.println("The sum of " + firstOperand + " and " +
nineSixteenths + " is " + result);
// 9/16 - 7/8
firstOperand = nineSixteenths;
secondOperand = new Fraction(7, 8);
result = firstOperand.subtract(secondOperand);
System.out.println("The difference of " + firstOperand +
" and " + secondOperand + " is " + result);
// 15/-2 * 1/4
firstOperand.setFraction(15, -2);
result = firstOperand.multiply(oneFourth);
System.out.println("The product of " + firstOperand +
" and " + oneFourth + " is " + result);
// (-21/2) / (3/7)
firstOperand.setFraction(-21, 2);
secondOperand.setFraction(3, 7);
result = firstOperand.divide(secondOperand);
System.out.println("The quotient of " + firstOperand +
" and " + secondOperand + " is " + result);
// -21/2 + 7/8
firstOperand.setFraction(-21, 2);
secondOperand.setFraction(7, 8);
result = firstOperand.add(secondOperand);
System.out.println("The sum of " + firstOperand +
" and " + secondOperand + " is " + result);
// 0/10, 5/(-15), (-22)/7
firstOperand.setFraction(0, 10);
doubleResult = firstOperand.toDouble();
System.out.println("The double floating point value of " + firstOperand + " is " + doubleResult);
firstOperand.setFraction(1, -3);
doubleResult = firstOperand.toDouble();
System.out.println("The double floating point value of " + firstOperand + " is " + doubleResult);
firstOperand.setFraction(-22, 7);
doubleResult = firstOperand.toDouble();
System.out.println("The double floating point value of " + firstOperand + " is " + doubleResult);
System.out.println(" =========================================");
firstOperand.setFraction(-21, 2);
System.out.println("First = " + firstOperand);
// equality check
System.out.println("check First equals First: ");
if (firstOperand.equals(firstOperand))
System.out.println("Identity of fractions OK");
else
System.out.println("ERROR in identity of fractions");
secondOperand.setFraction(-42, 4);
System.out.println(" Second = " + secondOperand);
System.out.println("check First equals Second: ");
if (firstOperand.equals(secondOperand))
System.out.println("Equality of fractions OK");
else
System.out.println("ERROR in equality of fractions");
// comparison check
Fraction first = (Fraction)firstOperand;
Fraction second = (Fraction)secondOperand;
System.out.println(" check First compareTo Second: ");
if (first.compareTo(second) == 0)
System.out.println("Fractions == operator OK");
else
System.out.println("ERROR in fractions == operator");
second.setFraction(7, 8);
System.out.println(" Second = " + secondOperand);
System.out.println("check First compareTo Second: ");
if (first.compareTo(second) < 0)
System.out.println("Fractions < operator OK");
else
System.out.println("ERROR in fractions < operator");
System.out.println(" check Second compareTo First: ");
if (second.compareTo(first) > 0)
System.out.println("Fractions > operator OK");
else
System.out.println("ERROR in fractions > operator");
System.out.println(" =========================================");
System.out.println(" check FractionException: 1/0");
try {
Fraction a1 = new Fraction(1, 0);
}
catch ( FractionException fe )
{
System.err.printf( "Exception: %s ", fe );
} // end catch
System.out.println(" check FractionException: division");
try {
Fraction a2 = new Fraction();
Fraction a3 = new Fraction(1, 2);
a3.divide(a2);
}
catch ( FractionException fe )
{
System.err.printf( "Exception: %s ", fe );
} // end catch
} // end main
} // end Fraction
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.