/*******************************************************************************
ID: 3551614 • Letter: #
Question
/*************************************************************************************
* 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 excpetion 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
*
************************************************************************************/
package PJ1;
public class Fraction implements FractionInterface, Comparable<Fraction>
{
private int numerator;
private int denominator;
public Fraction()
{
// set fraction to default = 0/1
setFraction(0, 1);
} // end default constructor
public Fraction(int initialNumerator, int initialDenominator)
{
// implement this method!
numerator=initialNumerator;
denominator=initialDenominator;
} // end constructor
public void setFraction(int newNumerator, int newDenominator)
{
// return ArithmeticException if initialDenominator is 0
// implement this method!
} // end setFraction
public int getNumerator()
{
// implement this method!
return 0;
} // end getNumerator
public int getDenominator()
{
// implement this method!
return 0;
} // end getDenominator
public char getSign()
{
// implement this method!
return 0;
} // end getSign
public void switchSign()
{
// implement this method!
} // change setSign
public FractionInterface add(FractionInterface operand)
{
// a/b + c/d is (ad + cb)/(bd)
// implement this method!
//return null;
} // end add
public FractionInterface subtract(FractionInterface operand)
{
// a/b - c/d is (ad - cb)/(bd)
// implement this method!
return null;
} // end subtract
public FractionInterface multiply(FractionInterface multiplier)
{
// a/b * c/d is (ac)/(bd)
// implement this method!
return null;
} // end multiply
public FractionInterface divide(FractionInterface divisor)
{
// return ArithmeticException if divisor is 0
// a/b / c/d is (ad)/(bc)
// implement this method!
return null;
} // end divide
public FractionInterface getReciprocal()
{
// return ArithmeticException if divisor is 0
// implement this method!
return null;
} // end getReciprocal
public boolean equals (Object other)
{
return false;
// implement this method!
} // end equals
public int compareTo(Fraction other)
{
// implement this method!
return 0;
} // end compareTo
public String toString()
{
return numerator + "/" + denominator;
} // end toString
/** Task: Reduces a fraction to lowest terms. */
//-----------------------------------------------------------------
// private methods start here
//-----------------------------------------------------------------
private void reduceToLowestTerms()
{
// implement this method!
//
// Outline:
// compute GCD of numerator & denominator
// greatestCommonDivisor works for + numbers.
// So, you should eliminate - sign
// then reduce numbers : numerator/GCD and denominator/GCD
} // end reduceToLowestTerms
/** Task: Computes the greatest common divisor 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 driver is provided here
public static void main(String[] args)
{
FractionInterface firstOperand = null;
FractionInterface secondOperand = null;
FractionInterface result = null;
Fraction nineSixteenths = new Fraction(9, 16); // 9/16
Fraction Fraction(1, 4); // 1/4
// 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);
System.out.println();
// equality check
if (firstOperand.equals(firstOperand))
System.out.println("Idenominatortity of fractions OK");
else
System.out.println("ERROR in idenominatortity of fractions");
secondOperand.setFraction(-42, 4);
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;
if (first.compareTo(second) == 0)
System.out.println("Fractions == operator OK");
else
System.out.println("ERROR in fractions == operator");
second.setFraction(7, 8);
if (first.compareTo(second) < 0)
System.out.println("Fractions < operator OK");
else
System.out.println("ERROR in fractions < operator");
if (second.compareTo(first) > 0)
System.out.println("Fractions > operator OK");
else
System.out.println("ERROR in fractions > operator");
System.out.println();
try {
Fraction a1 = new Fraction(1, 0);
}
catch ( ArithmeticException arithmeticException )
{
System.err.printf( " Exception: %s ", arithmeticException );
} // end catch
try {
Fraction a2 = new Fraction();
Fraction a3 = new Fraction(1, 2);
a3.divide(a2);
}
catch ( ArithmeticException arithmeticException )
{
System.err.printf( " Exception: %s ", arithmeticException );
} // end catch
} // end main
} // end Fraction
/* This file specifies methods for FractionInterface */
/* Do not modify this file!! */
package PJ1;
public interface FractionInterface
{
/** Task: Sets a fraction to a given value.
* @param newNumerator the integer numerator
* @param newDenominator the integer denominator
* @throws ArithmeticException if denominator=0 */
public void setFraction(int newNumerator, int newDenominator);
/** Task: Gets the fraction's numerator.
* @return the fraction's numerator */
public int getNumerator();
/** Task: Gets the fraction's denominator.
* @return the fraction's denominator */
public int getDenominator();
/** Task: Gets the fraction's sign.
* @return the fraction's sign '+' or '-' */
public char getSign();
/** Task: Switch the fraction's sign,
* i.e. (+ to -) OR (- to +) */
public void switchSign();
/** Task: Adds two fractions.
* @param operand a fraction that is the second operand of the addition
* @return the sum of the invoking fraction and the second operand */
public FractionInterface add(FractionInterface operand);
/** Task: Subtracts two fractions.
* @param operand a fraction that is the second operand of the subtraction
* @return the difference of the invoking fraction and the second operand */
public FractionInterface subtract(FractionInterface operand);
/** Task: Multiplies two fractions.
* @param operand a fraction that is the second operand of the multiplication
* @return the product of the invoking fraction and the second operand */
public FractionInterface multiply(FractionInterface multiplier);
/** Task: Divides two fractions.
* @param operand a fraction that is the second operand of the division
* @return the quotient of the invoking fraction and the second operand
* @throws ArithmeticException if divisor=0 */
public FractionInterface divide(FractionInterface divisor);
/** Task: Get's the fraction's reciprocal
* @return the reciprocal of the invoking fraction
* @throws ArithmeticException if the new number with denominator=0*/
public FractionInterface getReciprocal();
}
/* This program is used to test PJ1.Fracition class
* More info are given in Readme file
*/
import java.util.*;
import PJ1.*;
class PJ1_Test
{
static private Scanner scanner;
private static Fraction readFraction() {
System.out.print( " Try to read a fraction x/y, please enter x y : " );
int numerator = scanner.nextInt();
int denominator = scanner.nextInt();
Fraction f = new Fraction(numerator, denominator);
System.out.println( " Read OK:"+f);
return f;
}
private static void printOperations() {
System.out.println("==============================================");
System.out.println(" Operations:");
System.out.println(" 0) exit 1) add 2) subtract 3) multiply 4) divide");
System.out.println(" 5) compareTo 6) equals 7) recipocal 8) switchSign 9) getSign ");
System.out.println(" 10) getNumerator 11) getDenominator 12) setFraction (x/y) ");
System.out.print( " Enter an operation number: ");
}
public static void main( String args[] )
{
scanner = new Scanner( System.in ); // scanner for input
boolean continueLoop = true; // determines if more input is needed
Fraction n1=null;
Fraction n2=null;
int op,x,y;
do
{
try // read two numbers and calculate quotient
{
printOperations();
op= scanner.nextInt();
if (op == 0) {
break;
} else if ((op >0) && (op <7)) {
n1 = readFraction();
n2 = readFraction();
} else if ((op > 6) && (op < 12)) {
n1 = readFraction();
} else if (op == 12) {
n1 = new Fraction();
} else if (op == 13) {
n1 = new Fraction();
} else {
System.out.print( " Invalid input... try again " );
continue;
}
System.out.println(" Tests: ");
switch (op) {
case 1:
System.out.println(" " + n1 + " + " + n1 + " = " + n1.add(n1));
System.out.println(" " + n2 + " + " + n2 + " = " + n2.add(n2));
System.out.println(" " + n1 + " + " + n2 + " = " + n1.add(n2));
System.out.println(" " + n2 + " + " + n1 + " = " + n2.add(n1));
break;
case 2:
System.out.println(" " + n1 + " - " + n1 + " = " + n1.subtract(n1));
System.out.println(" " + n2 + " - " + n2 + " = " + n2.subtract(n2));
System.out.println(" " + n1 + " - " + n2 + " = " + n1.subtract(n2));
System.out.println(" " + n2 + " - " + n1 + " = " + n2.subtract(n1));
break;
case 3:
System.out.println(" " + n1 + " * " + n1 + " = " + n1.multiply(n1));
System.out.println(" " + n2 + " * " + n2 + " = " + n2.multiply(n2));
System.out.println(" " + n1 + " * " + n2 + " = " + n1.multiply(n2));
System.out.println(" " + n2 + " * " + n1 + " = " + n2.multiply(n1));
break;
case 4:
System.out.println(" " + n1 + " / " + n1 + " = " + n1.divide(n1));
System.out.println(" " + n2 + " / " + n2 + " = " + n2.divide(n2));
System.out.println(" " + n1 + " / " + n2 + " = " + n1.divide(n2));
System.out.println(" " + n2 + " / " + n1 + " = " + n2.divide(n1));
break;
case 5:
System.out.println(" " + n1 + " ct " + n1 + " = " + n1.compareTo(n1));
System.out.println(" " + n2 + " ct " + n2 + " = " + n2.compareTo(n2));
System.out.println(" " + n1 + " ct " + n2 + " = " + n1.compareTo(n2));
System.out.println(" " + n2 + " ct " + n1 + " = " + n2.compareTo(n1));
break;
case 6:
System.out.println(" " + n1 + " eq "+ n1 + " = " + n1.equals(n1));
System.out.println(" " + n2 + " eq "+ n2 + " = " + n2.equals(n2));
System.out.println(" " + n1 + " eq "+ n2 + " = " + n1.equals(n2));
System.out.println(" " + n2 + " eq "+ n1 + " = " + n2.equals(n1));
break;
case 7:
System.out.println(" " + n1 + " getReciprocal= " + n1.getReciprocal());
break;
case 8:
System.out.print(" " + n1 );
n1.switchSign();
System.out.println(" switchSign - = " + n1);
System.out.print(" " + n1 );
n1.switchSign();
System.out.println(" switchSign + = " + n1);
break;
case 9:
System.out.println(" " + n1 + " getSign = " + n1.getSign());
break;
case 10:
System.out.println(" " + n1 + " getNumerator = " + n1.getNumerator());
break;
case 11:
System.out.println(" " + n1 + " getDenominator = " + n1.getDenominator());
break;
case 12:
System.out.print( "read a fraction x/y, please enter x y : " );
x = scanner.nextInt();
y = scanner.nextInt();
System.out.print(" " + n1 + " setFraction = ");
n1.setFraction(x,y);
System.out.println(n1);
break;
}
} // end try
catch ( ArithmeticException arithmeticException )
{
System.err.printf( " Exception: %s ", arithmeticException );
} // end catch
} while ( continueLoop ); // end do...while
} // end main
} // end class DivideByZeroWithExceptionHandling
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 ArithmeticException if initialDenominator is 0
if(denominator==0)
throw new ArithmeticException("Denominator can't be 0");
// handle negative denominators to make it easy
if(denominator<0){
//swap the negative sign of denominator to numerator
this.den = Math.abs(denominator);
this.num = -numerator;
}
else{
this.num = numerator;
this.den = denominator;
}
// implement this method!
} // end setFraction
public int getNumerator()
{
// implement this method!
return num;
} // end getNumerator
public int getDenominator()
{
// implement this method!
return den;
} // end getDenominator
public char getSign()
{
// implement this method!
if(num>=0)
return '+';
else
return '-';
} // end getSign
public void switchSign()
{
// implement this method!
num = -num;
} // change setSign
public FractionInterface add(FractionInterface secondFraction)
{
// a/b + c/d is (ad + cb)/(bd)
// implement this method!
int resultDen;
int resultNum;
resultDen = this.getDenominator()*secondFraction.getDenominator();
resultNum = (this.getNumerator()*secondFraction.getDenominator())+(secondFraction.getNumerator()*this.getDenominator());
Fraction sum = new Fraction(resultNum, resultDen);
sum.reduceToLowestTerms();
return sum;
} // end add
public FractionInterface subtract(FractionInterface secondFraction)
{
// a/b - c/d is (ad - cb)/(bd)
// implement this method!
int resultDen;
int resultNum;
resultDen = this.getDenominator()*secondFraction.getDenominator();
resultNum = (this.getNumerator()*secondFraction.getDenominator())-(secondFraction.getNumerator()*this.getDenominator());
Fraction difference = new Fraction(resultNum, resultDen);
difference.reduceToLowestTerms();
return difference;
} // end subtract
public FractionInterface multiply(FractionInterface secondFraction)
{
// a/b * c/d is (ac)/(bd)
// implement this method!
int resultDen;
int resultNum;
resultNum = this.getNumerator()*secondFraction.getNumerator();
resultDen = this.getDenominator()*secondFraction.getDenominator();
Fraction product = new Fraction(resultNum, resultDen);
product.reduceToLowestTerms();
return product;
} // end multiply
public FractionInterface divide(FractionInterface secondFraction)
{
// return ArithmeticException if secondFraction is 0
if(secondFraction.getNumerator()==0)
throw new ArithmeticException("Second fraction is 0");
// a/b / c/d is (ad)/(bc)
// implement this method!
int resultDen;
int resultNum;
resultNum = this.getNumerator()*secondFraction.getDenominator();
resultDen = this.getDenominator()*secondFraction.getNumerator();
Fraction divideResult = new Fraction(resultNum, resultDen);
divideResult.reduceToLowestTerms();
return divideResult;
} // end divide
public FractionInterface getReciprocal()
{
// return ArithmeticException if secondFraction is 0
if(this.getNumerator()==0)
throw new ArithmeticException("Reciprocal is not valid");
// implement this method!
return new Fraction(this.den, this.num);
} // end getReciprocal
public boolean equals(Object other)
{
// implement this method!
FractionInterface secondFraction = (FractionInterface) other;
if(this.num==secondFraction.getNumerator() && this.den==secondFraction.getDenominator()){
return true;
}
else
return false;
} // end equals
public int compareTo(Fraction other)
{
// implement this method!
double fraction = (double)num/(double)den;
double otherFraction = (double)other.getNumerator()/(double)other.getDenominator();
if(otherFraction==fraction)
return 0;
else
return (int) (otherFraction-fraction);
} // 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
int gcd = greatestCommonDivisor(num, den);
// greatestCommonDivisor works for + numbers.
// So, you should eliminate - sign
gcd = Math.abs(gcd);
// then reduce numbers : num/GCD and den/GCD
this.num = num/gcd;
this.den = den/gcd;
} // end 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
} // end Fraction
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.