Ejercicio "Fracción" (modificación)

Modificar la clase Fraccion, de manera que implemente las interfaces Comparable y Reseteable, es decir, debe poner código a las funciones de esas interfaces. Como las interfaces se encuentran en otro paquete distinto a la clase Fraccion, se deben importar.
Además, se creará la excepción FraccionException, que se lanzará en el constructor de la clase Fraccion cuando el denominador sea 0.

EXCEPCIÓN: FraccionException

public class FraccionException extends ArithmeticException {
    public FraccionException(){
    }
    public FraccionException(String mensaje){
        super(mensaje);
    }
}

Las excepciones se programan normalmente con dos constructores:

• Uno por defecto, que no recibe nada.
• Otro que recibe un String, con el texto que queremos que se muestre si se lanza esa excepción.

Las excepciones pueden heredar de las existentes en Java, siempre que tenga sentido que así sea. Si queremos que la excepción no sea marcada, heredará de RuntimeException o de alguna de las que están dentro de ese conjunto.

CLASE: Fraccion

import interfaces.Comparable;
import interfaces.Reseteable;

public class Fraccion implements Comparable, Reseteable {
    private int numerador;
    private int denominador;
    public Fraccion(int num){
        this(num, 1);
    }
    public Fraccion(int num, int den){
        if (den == 0)
            throw new FraccionException();
        numerador = num;
        denominador = den;
    }
    public Fraccion inversa() {
        Fraccion aux;
        aux = new Fraccion(denominador, numerador);
        return aux;
    }
    public Fraccion producto(Fraccion f) {
        Fraccion resultado;
        int numRes, denRes;
        numRes = f.numerador * numerador;
        denRes = f.denominador * denominador;
        resultado = new Fraccion(numRes, denRes);
        return resultado;
    }
    @Override
    public String toString() {
        return numerador+"/"+denominador;
    }
    public Fraccion opuesta() {
        Fraccion aux;
        aux = new Fraccion(-numerador, denominador);

        return aux;
    }
    public static int mcd(int num1, int num2) {
        int aux;
        //Algoritmo de Euclides
        while (num2 != 0){
            aux = num1;
            num1 = num2;
            num2 = aux % num2;
        }
        return num1;
    }
    public static int mcm(int num1, int num2) {
        int mcm;
        int a=num1, b=num2;

        while (num1 != num2){
            if (num1>num2)
                num1 = num1-num2;
            else
                num2 = num2-num1;
        }
        mcm = a*b/num2;
        return mcm;
    }
    public Fraccion suma(Fraccion f2) {
        Fraccion resultado;
        int minimo, num;
        minimo = mcm(denominador, f2.denominador);
        num = (minimo/denominador)*numerador + (minimo/f2.denominador)*f2.numerador;
        resultado = new Fraccion(num, minimo);
        return resultado;
    }
    public boolean equals(Fraccion f2) {
        return numerador==f2.numerador & denominador==f2.denominador;
    }
    public Fraccion simplificar() {
        int divisor;
        divisor = mcd(numerador, denominador);
        numerador = numerador/divisor;
        denominador = denominador/divisor;
        return this;
    }
    public int comparadoCon(Object obj) throws ClassCastException {
        Fraccion f2 = (Fraccion) obj;
        double prim, segun;
        int res;
        prim = numerador/(double)denominador;
        segun = f2.numerador/(double)f2.denominador;
        if (prim < segun)
            res = -1;
        else if (prim > segun)
            res = 1;
        else
            res = 0;
        return res;
    }
    public void reset() {
        numerador = 0;
        denominador = 1;
    }
}