ComplexRational.java

/**
 * Created by dhimandasgupta on 12/8/2015.
 *
 * A Complex Number class where the real and imaginary fields are both Rational
 * Can add, subtract, multiply and divide
 */
public class ComplexRational {
    private Rational mReal;
    private Rational mImaginary;

    public ComplexRational() {
        this(new Rational(), new Rational());
    }

    public ComplexRational(final Rational real, final Rational imaginary) {
        mReal = real;
        mImaginary = imaginary;
    }

    public Rational getReal() {
        return mReal;
    }

    public void setReal(Rational mReal) {
        this.mReal = mReal;
    }

    public Rational getImaginary() {
        return mImaginary;
    }

    public void setImaginary(Rational mImaginary) {
        this.mImaginary = mImaginary;
    }

    public ComplexRational add(final ComplexRational complexNumber) {
        final ComplexRational addedComplexNumber = new ComplexRational();

        addedComplexNumber.mReal = mReal.add(complexNumber.mReal);
        addedComplexNumber.mImaginary = mImaginary.add(complexNumber.mImaginary);

        return addedComplexNumber;
    }

    public ComplexRational subtract(final ComplexRational complexNumber) {
        final ComplexRational subComplexNumber = new ComplexRational();

        subComplexNumber.mReal = mReal.subtract(complexNumber.mReal);
        subComplexNumber.mImaginary = mImaginary.subtract(complexNumber.mImaginary);

        return subComplexNumber;
    }

    public ComplexRational multiply(final ComplexRational complexNumber) {
        final ComplexRational mulComplexNumber = new ComplexRational();

        mulComplexNumber.mReal = Rational.subtract(mReal.multiply(complexNumber.mReal),
                (mImaginary.multiply(complexNumber.mImaginary)));
        mulComplexNumber.mImaginary = Rational.add(mReal.multiply(complexNumber.mImaginary),
                (mImaginary.multiply(complexNumber.mReal)));

        return mulComplexNumber;
    }

    public ComplexRational divide(final ComplexRational complexNumber) {
        ComplexRational divComplexNumber = new ComplexRational();

        //final float divisor = (float) (Math.pow(complexNumber.mReal, 2) + Math.pow(complexNumber.mImaginary, 2));
        final Rational divisor = Rational.add(Rational.square(complexNumber.mReal),
                Rational.square(complexNumber.mImaginary));

        final Rational realNumerator = Rational.add(Rational.multiply(mReal, complexNumber.mReal), Rational.multiply(mImaginary, complexNumber.mImaginary));
        divComplexNumber.mReal = realNumerator.divide(divisor);

        final Rational imgNumerator = Rational.subtract(Rational.multiply(mImaginary, complexNumber.mReal),
                Rational.multiply(mReal, complexNumber.mImaginary));
        divComplexNumber.mImaginary = imgNumerator.divide(divisor);
        //divComplexNumber.mReal = ((mReal * complexNumber.mReal) + (mImaginary * complexNumber.mImaginary))/divisor;
        //divComplexNumber.mImaginary =  ((mImaginary * complexNumber.mReal) - (mReal * complexNumber.mImaginary))/divisor;

        return divComplexNumber;
    }

    /*public float mod() {
        return (float) Math.sqrt(Math.pow(mReal, 2) + Math.pow(mImaginary, 2));
    }

    public float amplitude() {
        return (float) Math.toDegrees(Math.atan2(mImaginary, mReal));
    }*/

    @Override
    public String toString() {
        if (mImaginary.isPositive()) {
            return mReal.toString() + " + " + mImaginary.toString() + "i";
        } else if (mImaginary.isNegative()) {
            return mReal.toString() + " - " + Rational.abs(mImaginary) + "i";
        } else {
            return String.valueOf(mReal);
        }
    }
}

ComplexRationalMain.java

/**
 * Created by dhimandasgupta on 12/8/2015.
 */
public class ComplexRationalMain {
    public static void main(String... args) {
        final ComplexRational c1 = new ComplexRational(new Rational(1, 2), new Rational(1, 3));
        final ComplexRational c2 = new ComplexRational(new Rational(1, 5), new Rational(1, 4));

        ComplexRational result = null;

        result = c1.add(c2);
        System.out.println(c1.toString() + " + " + c2.toString() + " = " + result.toString());
        System.out.println("-------------------------------------------");

        result = c1.subtract(c2);
        System.out.println(c1.toString() + " - " + c2.toString() + " = " + result.toString());
        System.out.println("-------------------------------------------");

        result = c1.multiply(c2);
        System.out.println(c1.toString() + " * " + c2.toString() + " = " + result.toString());
        System.out.println("-------------------------------------------");

        result = c1.divide(c2);
        System.out.println(c1.toString() + " / " + c2.toString() + " = " + result.toString());
        System.out.println("-------------------------------------------");

    }
}

Rational.java

/**
 * Created by dhimandasgupta on 12/8/2015.
 *
 * A Simple class Which can add, subtract, multiply, divide
 * two Rational Numbers
 */
public class Rational {
    private int mNumerator;
    private int mDenominator;

    public Rational() {
        this(0, 1);
    }

    public Rational(final int numerator) {
        this(numerator, 1);
    }

    public Rational(final int numerator, final int denominator) {
        super();

        if (denominator == 0) {
            throw new ArithmeticException("Demoninator can not be null...");
        }

        mNumerator = numerator;
        mDenominator = denominator;
    }

    public int getNumerator() {
        return mNumerator;
    }

    public void setNumerator(int numerator) {
        mNumerator = numerator;
    }

    public int getDenominator() {
        return mDenominator;
    }

    public void setDenominator(int denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("Demoninator can not be null...");
        }

        mDenominator = denominator;
    }

    public Rational add(final Rational r) {
        final Rational rational = new Rational();

        rational.mNumerator = mNumerator*r.mDenominator + r.mNumerator*mDenominator;
        rational.mDenominator = mDenominator * r.mDenominator;

        final int gcd = Rational.gcd(rational.mNumerator, rational.mDenominator);

        rational.mNumerator /= gcd;
        rational.mDenominator /= gcd;
        pad();

        return rational;
    }

    public Rational subtract(final Rational r) {
        final Rational rational = new Rational();

        rational.mNumerator = mNumerator*r.mDenominator - r.mNumerator*mDenominator;
        rational.mDenominator = mDenominator * r.mDenominator;

        final int gcd = Rational.gcd(rational.mNumerator, rational.mDenominator);

        rational.mNumerator /= gcd;
        rational.mDenominator /= gcd;
        pad();

        return rational;
    }

    public Rational multiply(final Rational r) {
        final Rational rational = new Rational();

        rational.mNumerator = mNumerator * r.mNumerator;
        rational.mDenominator = mDenominator * r.mDenominator;

        final int gcd = Rational.gcd(rational.mNumerator, rational.mDenominator);

        rational.mNumerator /= gcd;
        rational.mDenominator /= gcd;
        pad();

        return rational;
    }

    public Rational divide(final Rational r) {
        final Rational rational = new Rational();

        rational.mNumerator = mNumerator * r.mDenominator;
        rational.mDenominator = mDenominator * r.mNumerator;

        final int gcd = Rational.gcd(rational.mNumerator, rational.mDenominator);

        rational.mNumerator /= gcd;
        rational.mDenominator /= gcd;
        pad();

        return rational;
    }

    @Override
    public String toString() {
        if (mDenominator == 0) {
            System.out.println("Something is wrong, denominator can never be zero");
        } else if (mDenominator < 0) {
            mDenominator = Math.abs(mDenominator);
            mNumerator = -1 * mNumerator;
        } else if (mDenominator == 1 || mNumerator == 0) {
            return String.valueOf(mNumerator);
        }

        return mNumerator + "/" + mDenominator;
    }

    public static int gcd(int a, int b) {
        a = Math.abs(a);
        b = Math.abs(b);

        while (b > 0) {
            int temp = b;
            b = a % b; // % is remainder
            a = temp;
        }
        return a;
    }

    public static int lcm(int a, int b) {
        a = Math.abs(a);
        b = Math.abs(b);

        return a * (b / gcd(a, b));
    }

    private void pad() {
        if (mDenominator == 0) {
            System.out.println("Something is wrong, denominator can never be zero");
        } else if (mDenominator < 0) {
            mDenominator = Math.abs(mDenominator);
            mNumerator = -1 * mNumerator;
        }
    }

    public static Rational add(final Rational r1, final Rational r2) {
        return r1.add(r2);
    }

    public static Rational subtract(final Rational r1, final Rational r2) {
        return r1.subtract(r2);
    }

    public static Rational multiply(final Rational r1, final Rational r2) {
        return r1.multiply(r2);
    }

    public static Rational divide(final Rational r1, final Rational r2) {
        return r1.divide(r2);
    }

    public boolean isPositive() {
        return mNumerator > 0;
    }

    public boolean isNegative() {
        return mNumerator < 0;
    }

    public static Rational abs(Rational r) {
        if (r.isNegative()) {
            r.setNumerator(Math.abs(r.getNumerator()));
        }

        return r;
    }

    public static Rational square(Rational r) {
        final Rational square = new Rational();

        square.setNumerator((int) Math.pow(r.getNumerator(), 2));
        square.setDenominator((int) Math.pow(r.getDenominator(), 2));

        return square;
    }
}

1. Rational class represents a Rational Number. It has the basic Rational number functions like add, subtract, multiply and divide.
2. ComplexRational class represents a Complex number, where the real & imaginary parts are each a Rational number. It also has the functions to add, subtract, multiply & divide.
3. ComplexRationalMain is a class contains the java main method.