How can I negate Java Fraction,a class which I've created

Question

This is my Fraction class code with several methods, the requirement I have is to keep numerator an denominator as an `int`: ``` /** * @author GKsiazek * Reference: https://github.com/kiprobinson/BigFraction/blob/master/com/github/kiprobinson/util/BigFraction.java * Reference: https://github.com/kiprobinson/BigFraction/blob/master/com/github/kiprobinson/junit/BigFractionTest.java */ package Fraction; import java.math.*; public class Fraction { private int numerator; private int denominator; /** * Constructor with two int parameters * @param num is numerator * @param den is denominator */ public Fraction() {} public Fraction(int num, int den) { if (den==0){//denominator cannot be zero System.out.println("Denominator cannot be zero"); return; } this.numerator = num; this.denominator = den; this.normalize(); } /** * Constructor with one int parameter * @param num is numerator * @param den is assumed one */ public Fraction(int num){ this.numerator = 1; this.denominator = num ; } /** * Con…

Accepted Answer

The problem is that your `negate` method returns a new `Fraction` object that you're never re-assigning to your `g` variable:

```
public void testNegate()
{
    Fraction g = new Fraction(1,3);
    g = g.negate(); //added "g ="
    assertEquals(-1, g.getNumerator());
    assertEquals(3, g.getDenominator());
}
```

As a side note, your `negate` method has an issue, which is that the `numerator` will always be negative due to multiplying the absolute value of `numerator` (which will always be positive) by -1. Just remove the `Math#abs` usage from there:

```
public Fraction negate()
{
    int num = this.numerator * -1;
    int den = this.denominator;
    return new Fraction(num,den);
}
```

An example to make your class immutable:

```
public class Fraction {
    //marking the fields as final in order to only be initialized
    //in class constructor
    private final int numerator;
    private final int denominator;

public Fraction() {
        //always initialize the fields in constructor
        numerator = 0;
        denominator = 1; //because it cannot be zero
    }

/**
     * Constructor with two int parameters
     * @param num is numerator
     * @param den is denominator
     */
    public Fraction(int num, int den) {
        if (den==0) {
            //denominator cannot be zero
            //it is better to throw an exception than just returning
            throw new IllegalArgumentException("Denominator cannot be zero");
        }
        int[] fractionData = this.normalize(num, den);
        //always initialize the fields in constructor
        this.numerator = fractionData[0];
        this.denominator = fractionData[1];
    }

private int[] normalize(int numParam, int denParam) {
        int[] fractionData = new int[2];
        fractionData[0] = numParam;
        fractionData[1] = denParam;
        BigInteger gcd;
        BigInteger num = BigInteger.valueOf(numParam);
        BigInteger den = BigInteger.valueOf(denParam);
        gcd = num.gcd(den);
        if (gcd.intValue() > 1) {
            fractionData[0] = numParam / gcd.intValue();
            fractionData[1] = denParam / gcd.intValue();
        }
        return fractionData;
    }

//leaving the rest of the implementation up to you...
}
```

How can I negate Java Fraction,a class which I've created

Solution

Problem

Related problems