En este post de programación en Java te enseñaré a resolver fracciones o quebrados usando este lenguaje. Vamos a crear la clase Fracción y todos los métodos así como las operaciones necesarias.

Al final vamos a poder resolver fracciones con Java y aplicar la suma, multiplicación (producto), división, potencia, inversa y simplificación. De hecho esto es la solución a un ejercicio que dice así:

Crea una clase que permita modelar un objeto Fracción. Se considera como fracción a la representación de las partes de un todo, es decir, se divide en partes iguales y cada parte es la fracción del entero.

Los términos de una fracción son el numerador y el denominador. El numerador es el número de partes que tenemos y el denominador es el número de partes en que hemos dividido la unidad.

Métodos Java

Comportamientos o métodos principales:

• public Fraccion suma(Fraccion otra)
  public Fraccion resta(Fraccion otra)
  public Fraccion producto(Fraccion otra)
  public Fraccion cociente(Fraccion otra)
  public Fraccion inversa()
  public Fraccion potencia(int exponente)
  public Fraccion simplifica()

Otros métodos heredados:

• public String toString(): Pasa a cadena un objeto Fracción. Escribe el objeto a / b
• public boolean equals() y hashCode()

Explicación del algoritmo

Simplemente vamos a crear la clase y a implementar todos los métodos tal y como se describió en el apartado anterior. Es importante que sepamos cómo hacer las operaciones manualmente, pues aquí simplemente vamos a pasar todo a programación.

Por cierto, nos van a servir dos cosas que ya he explicado en mi blog: el mínimo común múltiplo y el máximo común divisor.

Clase Fracción

Veamos entonces cómo queda el código en Java para resolver quebrados, también conocidos como fracciones. Se ve así:

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me).
------------------------------------------------------------------------------------------------
            | IMPORTANTE |
Si vas a borrar este encabezado, considera:
Seguirme: https://parzibyte.me/blog/sigueme/
Y compartir mi blog con tus amigos
También tengo canal de YouTube: https://www.youtube.com/channel/UCroP4BTWjfM0CkGB6AFUoBg?sub_confirmation=1
Twitter: https://twitter.com/parzibyte
Facebook: https://facebook.com/parzibyte.fanpage
Instagram: https://instagram.com/parzibyte
Hacer una donación vía PayPal: https://paypal.me/LuisCabreraBenito
------------------------------------------------------------------------------------------------
*/package me.parzibyte;

import java.util.Objects;

class Fraccion {
    private int numerador, denominador;

    // Constructores

    public Fraccion() {
        this.numerador = 1;
        this.denominador = 1;
    }

    public Fraccion(int numerador) {
        this.numerador = numerador;
        this.denominador = 1;
    }

    public Fraccion(int numerador, int denominador) {
        this.numerador = numerador;
        // Llamar al setter para que se haga la validación del denominador
        this.setDenominador(denominador);
    }

    public Fraccion(Fraccion f) {
        this.numerador = f.getNumerador();
        this.denominador = f.getDenominador();
    }
    // Getters y setters

    public int getNumerador() {
        return this.numerador;
    }

    public int getDenominador() {
        return this.denominador;
    }

    public void setNumerador(int numerador) {
        this.numerador = numerador;
    }

    public void setDenominador(int denominador) {
        if (denominador == 0) {
            throw new IllegalArgumentException("Denominador debe ser distinto de 0");
        }
        this.denominador = denominador;
    }

    // Métodos ayudantes

    private int mcm(int a, int b) {
        return (a * b) / this.maximoComunDivisor(a, b);
    }

    public int maximoComunDivisor(int a, int b) {
        int temporal;//Para no perder b
        while (b != 0) {
            temporal = b;
            b = a % b;
            a = temporal;
        }
        return a;
    }

    // Métodos principales
    public Fraccion suma(Fraccion otra) {
        int mcm = this.mcm(this.getDenominador(), otra.getDenominador());
        int diferenciaFraccionActual = mcm / this.getDenominador();
        int diferenciaOtraFraccion = mcm / otra.getDenominador();
        Fraccion resultado = new Fraccion();
        resultado.setNumerador(
                (diferenciaFraccionActual * this.getNumerador()) + (diferenciaOtraFraccion * otra.getNumerador()));
        resultado.setDenominador(mcm);
        return resultado;
    }

    public Fraccion resta(Fraccion otra) {
        int mcm = this.mcm(this.getDenominador(), otra.getDenominador());
        int diferenciaFraccionActual = mcm / this.getDenominador();
        int diferenciaOtraFraccion = mcm / otra.getDenominador();
        Fraccion resultado = new Fraccion();
        resultado.setNumerador((diferenciaFraccionActual * this.getNumerador()) - (diferenciaOtraFraccion * otra.getNumerador()));
        resultado.setDenominador(mcm);
        return resultado;
    }

    public Fraccion producto(Fraccion otra) {
        return new Fraccion(this.getNumerador() * otra.getNumerador(), this.getDenominador() * otra.getDenominador());
    }

    public Fraccion cociente(Fraccion otra) {
        return new Fraccion(this.getNumerador() * otra.getDenominador(), this.getDenominador() * otra.getNumerador());
    }

    public Fraccion inversa() {
        return new Fraccion(this.getDenominador(), this.getNumerador());
    }

    public Fraccion potencia(int exponente) {
        return new Fraccion((int) Math.pow(this.getNumerador(), exponente), (int) Math.pow(this.getDenominador(), exponente));
    }

    public Fraccion simplifica() {
        int mcd = this.maximoComunDivisor(this.getNumerador(), this.getDenominador());
        return new Fraccion(this.getNumerador() / mcd, this.getDenominador() / mcd);
    }

    // Heredados
    @Override
    public String toString() {
        return String.valueOf(this.getNumerador()).concat("/").concat(String.valueOf(this.getDenominador()));
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Fraccion fraccion = (Fraccion) o;
        return numerador == fraccion.numerador && denominador == fraccion.denominador;
    }

    @Override
    public int hashCode() {
        return Objects.hash(numerador, denominador);
    }
}

Por cierto, si te fijas también hemos sobrescrito el método de toString para convertir la fracción a una cadena de una forma entendible, y el método equals para comparar dos objetos de esta clase.

Recuerda que una fracción es igual a otra si el numerador y el denominador de ambas coinciden (a su máxima simplificación, claro).

Modo de uso

Ya te enseñé la clase, es momento de ver el modo de uso. Recuerda que en la mayoría de métodos se regresa otro objeto de la misma clase, de modo que puedes encadenar las funciones.

public class Main {

    public static void main(String[] args) {
        Fraccion f = new Fraccion(5, 6);
        Fraccion f2 = new Fraccion(7, 24);
        System.out.println("Suma de " + f + " + " + f2 + " = " + f.suma(f2));
        System.out.println("Resta de " + f + " - " + f2 + " = " + f.resta(f2));
        System.out.println("Producto de " + f + " * " + f2 + " = " + f.producto(f2));
        System.out.println("Cociente de " + f + " / " + f2 + " = " + f.cociente(f2));
        System.out.println("Inversa de " + f + " = " + f.inversa());
        int exponente = 3;
        System.out.println("Potencia de " + f + " con exponente " + exponente + " = " + f.potencia(exponente));
        // Probar la simplificación y el constructor copia
        Fraccion paraSimplificar = new Fraccion(new Fraccion(80, 120));
        System.out.println("Simplificar la fracción " + paraSimplificar + " = " + paraSimplificar.simplifica());
        Fraccion f3 = new Fraccion(1, 5);
        Fraccion f4 = new Fraccion(1, 3);
        Fraccion f5 = new Fraccion(1, 5);
        System.out.println(f3 + " es igual a " + f4 + ": " + f3.equals(f4));
        System.out.println(f3 + " es igual a " + f5 + ": " + f3.equals(f5));
        System.out.println(f4 + " es igual a " + f5 + ": " + f4.equals(f5));
    }
}

En este caso estoy haciendo una pequeña demostración dentro del método Main, pero recuerda, es un simple ejemplo y tú puedes adaptarlo a tus necesidades.

Como puedes ver en la imagen de ejecución, la salida es correcta. Obviamente los datos de las fracciones pueden venir de cualquier lugar (de un input, de la consola, un archivo, etcétera).

Conclusión

Te comento que ya hice esto de fracciones hace un tiempo pero en Python en donde además manejamos fracciones mixtas e impropias.

También te dejo un enlace para aprender más sobre Java.

Igualmente puedes ver un vídeo si algo no te ha quedado claro: